c++Rational class (just for fun) targil 5 beta

// still not done.
//used for operators like * - / +
//Rational.h
#pragma once
class Rational
{
public:
    Rational(int numerator=0,int denominator =1);
    ~Rational();
    int Getnumerator() const;
    void Setnumerator(int);
    int Getdenominator() const;
    void Setdenominator(int);
    void Setden_num(int, int);
    void print()const;
    Rational operator+ (const Rational&)const;
    Rational operator- (const Rational&)const;
    Rational operator* (const Rational&)const;
    Rational operator/ (const Rational&)const;

private:
    int numerator;
    int denominator;
};
//Rational.cpp
#include "Rational.h"
#include <iostream>
#include <math.h>

using namespace std;


Rational::Rational(int a,int b)
{
    this->numerator = a;
    this->denominator = b;
}

Rational::~Rational()
{
}

int Rational::Getnumerator() const
{
    return this->numerator;
}

void Rational::Setnumerator(int x)
{
    numerator = x;
}

int Rational::Getdenominator() const
{
    return this->denominator;
}

void Rational::Setdenominator(int y)
{
    denominator = y;
}

void Rational::Setden_num(int num, int deno)
{
    this->numerator = num;
    this->denominator = deno;
}

void Rational::print() const
{
    cout << "(" << numerator << "," << denominator << ")"<< endl;
}

int gcd(int a, int b)
{
    // Everything divides 0
    if (a == 0)
        return b;
    if (b == 0)
        return a;

    // base case
    if (a == b)
        return a;

    // a is greater
    if (a > b)
        return gcd(a - b, b);
    return gcd(a, b - a);
}

long long lcm(int a, int b)
{
    return (a / gcd(a, b) * b);
}



Rational Rational::operator+ (const Rational& n)const
{
    Rational result; // first bug fixed -> 2 same denominator
    if (this->denominator==n.denominator)
    {
        result.numerator = this->numerator + n.numerator;
        result.denominator = denominator;
        return result;
    }
    else
    {
        //**************************************************************************
        //*
        //*
        //*
        //*              algorithm DONT WORK!
        //*
        //*
        //***************************************************************************
        //int lcm_temp = lcm(this->denominator, n.denominator); // 1/4 & 1/5 == holds 20
        //int temp_numerator_first = (this->numerator * n.denominator);  //1/4 ->1*5 holds 5
        //int temp_denominator_first = (this->denominator * n.denominator);// 1/4 -> 4*5 holds 20
        //int temp_numerator_secand = (n.numerator * this->denominator); // 1/5 -> 1*4 holds 4
        //int temp_denominator_secand = (n.denominator * this->denominator); // 1/5 -> 5*4 holds 20
        //result.numerator = temp_numerator_first + temp_numerator_secand; // just 5+4 -> 9
        //result.denominator = lcm_temp; // lcm
        //return result; // we return the result
        int temp = gcd(denominator, n.denominator); // Greatest common divisor of two numbers
        int f1 = n.denominator / temp; //
        int f2 = denominator / temp; //

        result.numerator = numerator * f1 + n.numerator * f2;
        result.denominator = f1 * denominator;
        return result;
    }

}

Rational Rational::operator- (const Rational& n)const
{
    Rational temp(-n.numerator,n.denominator);
    return (*this) + temp;
}

Rational Rational::operator* (const Rational& n)const
{
    // 1/4 * 1/5; = 1*1=1 + 5*4=20 == 1/20
    Rational temp;
    int numerator_holder = numerator * n.numerator;
    int denominator_holder = denominator * n.denominator;
    temp.numerator = numerator_holder;
    temp.denominator = denominator_holder;
    return temp;
}

Rational Rational::operator/ (const Rational& n)const
{
    Rational temp;
}
//Main.cpp
#include <iostream>
#include "Rational.h"
using namespace std;

void main()
{
    Rational v1(4,8);
    Rational v2; // default
    Rational v3; // default with set func
    v1.print();
    v2.print();
    v3.Setden_num(55, 22);
    v3.print();
    v2.Getdenominator();
    //etc....
    //test of 2 oprators "+"
    cout << "----------------------" << endl;
    Rational v4(1,4);
    Rational v5(1,5);
    Rational v6;
    v6 = v4 + v5;
    v6.print();
    cout << "----------------------" << endl;
    Rational v7(4, 99);
    Rational v8(3, 99);
    Rational v9;
    v9 = v7 + v8;
    v9.print(); // bug fixed
    cout << "test to print 2 sided" << endl;
    Rational test;
    test = v8 + v7;
    test.print();//bug fixed
    cout << "----------------------" << endl;
    Rational v10(1 , 20);
    Rational v11(2 , 40);
    Rational v12;
    v12 = v11 + v10;
    v12.print(); // bug fixed
    cout << "----------------------" << endl;
    Rational v13(55, 72);
    Rational v14(66, 120);
    Rational v15;
    v15 = v14 + v13;
    v15.print();// call for normlize need to be done + bug |update| delt with new algorithm
    cout << "----------------------" << endl;
    //test of 2 oprators "-"
    Rational v16(33, 75);
    Rational v17(63, 41);
    Rational v18;
    v18 = v17 - v16;
    v18.print();
    cout << "----------------------" << endl;
    //test of 2 oprators "*"
    Rational v20(1, 5);
    Rational v21(1, 4);
    Rational v22;
    v22 = v20 * v21;
    v22.print();
    // more test by imri rand
    Rational v23(1, 7);
    Rational v24(3, 8);
    Rational v25(1,1);
    v25 = v24 * v23; // bug fixed
    v25.print();
}