Разработать класс (Объект «рациональная дробь, представлен парой целых чисел»)

class rational {
    int num;
    int denom;
 
public:
    rational( int n, int d ) : num(n), denom(d) {}
};

#include <iostream>
#include <conio.h>
using namespace std;
 
class CDrob
{
private:
    int n;
    int m;
public:
    CDrob(): n(1),m(1) // Конструктор без параметров
    { }
 
    CDrob(int n1,int m1): n(n1) // Конструктор с параметрами
    {
        if(m1 == 0) // Если делитель равен нулю - ошибка
        { cout << "Error" << endl; }
        else
        { m = m1; }
    }
 
    CDrob operator * (CDrob temp) // Перегрузка операции *
    {
        CDrob buffer;
        buffer.m = m * temp.m;
        buffer.n = n * temp.n;
        return buffer;
    }
 
    CDrob operator / (CDrob temp) // Перегрузка операции /
    {
        CDrob buffer;
        buffer.m = m * temp.n;
        buffer.n = n * temp.m;
        return buffer;
    }
 
    CDrob operator = (CDrob& temp) // Перегрузка операции присваивания
    {
        n = temp.n;
        m = temp.m;
        return CDrob(n,m);
    }
 
friend ostream& operator << (ostream& s,CDrob& temp); // Вывод самой дроби
};
 
ostream& operator << (ostream& s,CDrob& temp)
{
    s << temp.n << "/" << temp.m;
    return s;
}
 
 
void main()
{
    CDrob drob1(2,3);
    CDrob drob2(4,5);
    CDrob drob3;
 
    drob3 = drob1 * drob2;
    cout << drob3; // Вывод произведения
 
    cout << endl;
 
    drob3 = drob1 / drob2;
    cout << drob3; // Вывод частного
 
    cout << endl;
 
    CDrob drob4(3,0); // А тут ошибка,потому что нельзя делить на 0
 
    getch();
}

bool operator==(const CDrob &right)
{
    return n*right.m == m*right.n;
}

// Класс для работы с дробями. Операции: "+", "-", "*", "/"
 
#ifndef RATIONAL_H
#define RATIONAL_H
#include <iostream>
using namespace std;
 
class Rational
{
    friend ostream &operator << (ostream &, Rational &);
    friend istream &operator >> (istream &, Rational &);
 
public:
    Rational(int = 1, int = 1);
    Rational(Rational &);
    void setRational(int, int);
    Rational operator + (Rational &);
    Rational operator - (Rational &);
    Rational operator * (Rational &);
    Rational operator / (Rational &);
    void sumRational(Rational, Rational);
    void diffRational(Rational, Rational);
    void prodRational(Rational, Rational);
    void quoRational(Rational, Rational);
    void printRational();
    void printDoubleRational();
    ~Rational();
 
private:
    int nodR(int, int);
    int nokR(int, int);
    int numer;
    int denom;
 
 
};
#endif

#include "rational.h"
#include <iostream>
#include <iomanip>
using namespace std;
 
Rational::Rational(int ch, int zn)
{
    setRational(ch, zn);
}
 
Rational::Rational(Rational &arg)
{
    setRational(arg.numer, arg.denom);
}
 
Rational::~Rational() {};
 
int Rational::nodR(int x, int y)
{
    if ( y == 0 )
        return x;
    else
        return nodR(y, x % y);
}
 
int Rational::nokR(int x, int y)
{
    for (int i = 1; i > 0; i++)
        if (i % x == 0 && i % y == 0)
            return i;
    return 1;
}
 
void Rational::setRational(int ch, int zn)
{
    int nod;
 
    if (ch >= zn)
        nod = nodR(ch, zn);
    else
        nod = nodR(zn, ch);
 
    if (!zn)
        cout << "Деление на \"0\" невозможно." << endl;
    else
        if (ch < 0 && zn < 0)
        {
            numer = (ch / nod) * -1;
            denom = (zn / nod) * -1;
        }
        else
        {
            numer = ch / nod;
            denom = zn / nod;
        }
    
}
 
void Rational::sumRational(Rational x, Rational y)
{
    int nok = nokR(x.denom, y.denom);
 
    setRational((x.numer * (nok / x.denom)) + (y.numer * (nok / y.denom)), nok);
}
 
void Rational::diffRational(Rational x, Rational y)
{
    int nok = nokR(x.denom, y.denom);
 
    setRational((x.numer * (nok / x.denom)) - (y.numer * (nok / y.denom)), nok);
}
 
void Rational::prodRational(Rational x, Rational y)
{
    setRational(x.numer * y.numer, x.denom * y.denom);
}
 
void Rational::quoRational(Rational x, Rational y)
{
    setRational(x.numer * y.denom, x.denom * y.numer);
}
 
void Rational::printRational()
{
    cout << numer << "/" << denom;
}
 
void Rational::printDoubleRational()
{
    cout << setprecision(6) << setiosflags(ios::fixed | ios::showpoint) 
         << (double)numer / (double)denom;
}
 
ostream &operator << (ostream &output, Rational &right)
{
    right.printRational();
    return output;
}
 
istream &operator >> (istream &input, Rational &right)
{
    input >> right.numer;
    cin.get();
    input >> right.denom;
    right.setRational(right.numer, right.denom);
    return input;
}
 
Rational Rational::operator+(Rational &right)
{
    Rational temp = *this;
    temp.sumRational(temp, right);
    return temp;
}
 
Rational Rational::operator-(Rational &right)
{
    Rational temp = *this;
    temp.diffRational(temp, right);
    return temp;
}
 
Rational Rational::operator*(Rational &right)
{
    Rational temp = *this;
    temp.prodRational(temp, right);
    return temp;
}
 
Rational Rational::operator/(Rational &right)
{
    Rational temp = *this;
    temp.quoRational(temp, right);
    return temp;
}

#include <iostream>
#include <conio.h>
using namespace std;
 
class CDrob
{
private:
    int n;
    int m;
public:
    CDrob(): n(1),m(1) // Конструктор без параметров
    { }
 
    CDrob(int n1,int m1): n(n1) // Конструктор с параметрами
    {
        if(m1 == 0) // Если делитель равен нулю - ошибка
        { cout << "Error" << endl; }
        else
        { m = m1; }
    }
 
    CDrob operator * (CDrob temp) // Перегрузка операции *
    {
        CDrob buffer;
        buffer.m = m * temp.m;
        buffer.n = n * temp.n;
        return buffer;
    }
 
    CDrob operator / (CDrob temp) // Перегрузка операции /
    {
        CDrob buffer;
        buffer.m = m * temp.n;
        buffer.n = n * temp.m;
        return buffer;
    }
 
    CDrob operator = (CDrob& temp) // Перегрузка операции присваивания
    {
        n = temp.n;
        m = temp.m;
        return CDrob(n,m);
    }
     
     bool operator==(const CDrob &right) // Перегрузка операции проверки на равенство
    {
         return n*right.m == m*right.n;
    }
 
friend ostream& operator << (ostream& s,CDrob& temp); // Вывод самой дроби
};
 
ostream& operator << (ostream& s,CDrob& temp)
{
    s << temp.n << "/" << temp.m;
    return s;
}
 
 
int main()
{
    setlocale(LC_ALL, "Russian");
 
    CDrob drob1(2,3);
    CDrob drob2(2,3);
 
    if (drob1 == drob2)
        cout << "Дроби равны" << endl;
    else
        cout << "Дроби не равны" << endl;
    
 
    system("pause");
    return 0;
}

 else
        if (ch < 0 && zn < 0)
        {
            numer = (ch / nod) * -1;
            denom = (zn / nod) * -1;
        }
        else
        {
            numer = ch / nod;
            denom = zn / nod;
        }