Да. Зачет надо сдавать!
Зачем приводить к общему знаменателю? Делаешь сложение или вычитание, а потом выполняешь сокращение. Примерную реализацию нарисовал. Недостающее допишешь сама.

mathematics.h

//---------------------------------------------------------------------------

#ifndef mathematicsH
#define mathematicsH
//---------------------------------------------------------------------------
int max(int x, int y);
int min( int x, int y) ;

class fraction
{
public:
int numerator; //числитель
int denominator; //знаменатель
public:
fraction( int iWhole, int iNumerator, int iDenominator);
fraction( int iNumerator, int iDenominator);
fraction( int iNumerator);
fraction( );
fraction( const fraction& ss);
~fraction( ){};

fraction operator +( fraction& rhs);
fraction operator -( fraction& rhs);
void operator +=( fraction& rhs);
void operator *=( fraction& rhs);
void operator *=( int *i);

void cancellation();//сокращает дробь. можно перенести в private

};
#endif

mathematics.cpp

//---------------------------------------------------------------------------


#pragma hdrstop

#include <math.h>

#include "mathematics.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

int max(int x, int y)
{
return (x > y) ? x : y;
}
int min( int x, int y)
{
return (x < y) ? x : y;
}

fraction::fraction( int iWhole, int iNumerator, int iDenominator)
{
numerator = iNumerator + iWhole * iDenominator;
denominator = iDenominator;
}

fraction::fraction( int iNumerator, int iDenominator)
{
numerator = iNumerator;
denominator = iDenominator;
}

fraction::fraction( int iNumerator)
{
numerator = iNumerator;
denominator = 1;
}

fraction::fraction( )
{
numerator = 1;
denominator = 1;
}
fraction::fraction( const fraction&ss)
{
numerator = ss.numerator;
denominator = ss.denominator;
}


fraction fraction::operator +( fraction& rhs)
{
fraction dd;
dd.numerator = numerator * rhs.denominator +
denominator * rhs.numerator;
dd.denominator = denominator * rhs.denominator;
return dd;
}
fraction fraction::operator -( fraction& rhs)
{
fraction dd;
dd.numerator = numerator * rhs.denominator -
denominator * rhs.numerator;
dd.denominator = denominator * rhs.denominator;
return dd;
}
void fraction::operator +=( fraction& rhs)
{
numerator = numerator * rhs.denominator +
denominator * rhs.numerator;
denominator = denominator * rhs.denominator;
return ;
}
void fraction::operator *=( fraction& rhs)
{
numerator *= rhs.numerator;
denominator *= rhs.denominator;
return ;
}
void fraction::operator *=( int *i)
{
numerator *= *i;
denominator *= *(i+1);
return ;
}


void fraction::cancellation( )
{
int N;
bool bReturn;
do
{
N = min( abs( numerator), abs( denominator));
int num = numerator;
int den = denominator;
bReturn = false;
for( int i = N; i>1; i--)
{
num = (numerator / i) * i;
den = (denominator / i) * i;
if( ( (numerator / i) * i == numerator) &&
( (denominator / i) * i == denominator))
{
numerator /= i;
denominator /= i;
bReturn = true;
break;
}
}
} while( bReturn);

return ;
}

//примеры вызова



//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
fraction aa (12,18);
fraction ae (3,2,3);
fraction *ab = new fraction(5,6);
fraction cc = aa + ae;
int ar[2] = {2,3};
cc *= ar;
aa.cancellation();
fraction dd(aa);
fraction ww = *ab;
}
//---------------------------------------------------------------------------