Appendix:

Main.cpp
#include <iostream>
#include "ourclasses.h"
using namespace std;
int main()
{ mytime t1,t2,t3;
t1.setseconds(100);
t1.setminutes(90);
t1.sethours(4);
t2.setseconds(90);
t2.setminutes(80);
t2.sethours(2);
t1.getseconds();
t1.getminutes();
t1.gethours();
t3=t2.add(t1);
cout << "Addition is : " << endl;
t1.print();
t2.print();
t3.print();
t3=t2.subtract(t1);
cout << "Subtraction is: " << endl ;
t1.print();
t2.print();
t3.print();
mycomplex c1,c2,c3;
c1.setreal(2.1);
c1.setimaginary(2.2);
c2.setreal(4.1);
c2.setimaginary(3.2);
c3 = c1.add(c2);
cout << "The addition of two complex numbers is: " << endl ;
c1.print();
c2.print();
c3.print();
c3 = c1.subtract(c2);
cout << "The subtraction of two complex numbers is: " << endl ;
c1.print();
c2.print();
c3.print();
c3 = c1.multiply(c2);
cout << "The multiplication of two complex numbers is: " << endl ;
c1.print();
c2.print();
c3.print();
fraction f1,f2,f3,simp;
f1.setnumerator(1);
f1.setdenumerator(3);
f2.setnumerator(1);
f2.setdenumerator(4);
cout << "The two fractions are:" << endl ;
f1.print();
f2.print();
cout << "The addition of two fractions is:" << endl ;
f3=f1.add(f2);
f3.print();
cout << "The subtraction of two fraction is:" << endl;
f3=f1.subtract(f2);
f3.print();
cout << "The multiplication of two fractions is:" << endl ;
f3=f1.multiply(f2);
f3.print();
cout << "The simplification of fractions is:" << endl ;
simp.setdenumerator(9);
simp.setnumerator(3);
f3= f3.simplify(simp);
f3.print();
return 0; }
Header file:
#ifndef OURCLASSES_H_INCLUDED
#define OURCLASSES_H_INCLUDED
class mytime
{ int hours;
int minutes;
int seconds;
public:
void sethours(int h) ;
void setminutes(int m) ;
void setseconds (int s) ;
void reset();
int gethours();
int getminutes();
int getseconds();
mytime add (mytime t);
mytime subtract (mytime t);
void print(); };
class mycomplex
{ double real;
double imaginary;
public:
void setreal(double r);
void setimaginary(double i);
 double getreal();
double getimaginary();
void print();
mycomplex add(mycomplex c);
mycomplex subtract(mycomplex c);
mycomplex multiply(mycomplex c); };
class fraction
{ int numerator;
int denumerator;
public:
void setnumerator(int n);
void setdenumerator(int d);
int getnumerator();
int getdenumerator();
fraction add(fraction f1);
fraction subtract(fraction f1);
fraction multiply(fraction f1);
fraction simplify (fraction f1);
void print(); };
#endif // OURCLASSES_H_INCLUDED
Source file:
#include <iostream>
#include "ourclasses.h"
#include <iomanip>
using namespace std;
void mytime::setseconds(int s)
{ seconds = s%60 ;
minutes = s/60 ; }
void mytime:: setminutes(int m)
{ minutes = (m%60) + minutes ;
hours = m/60 ; }
void mytime::sethours(int h)
{ hours = h + hours ; }
void mytime::reset()
{ hours = minutes = seconds = 0; }
int mytime::gethours()
{ return hours ; }
int mytime::getminutes()
{return minutes ;}
int mytime::getseconds()
{return seconds ; }
mytime mytime::add (mytime m2)
{ mytime sum;
sum.reset();
sum.setseconds(seconds + m2.getseconds());
sum.setminutes(minutes + m2.getminutes());
sum.sethours(hours + m2.gethours());
return sum; }
mytime mytime::subtract(mytime m2)
{ mytime sub;
if (seconds < m2.getseconds() && minutes < m2.getminutes() && hours < m2.gethours()) {
sub.reset();
sub.setseconds(m2.getseconds()-seconds);
sub.setminutes(m2.getminutes()-minutes);
sub.sethours(m2.gethours()-hours) ; }
else if (seconds < m2.getseconds() && minutes > m2.getminutes() && hours > m2.gethours()) {
sub.reset();
sub.setseconds(m2.getseconds()-seconds);
sub.setminutes(minutes-m2.getminutes());
sub.sethours(hours-m2.gethours()) ; }
else if (seconds > m2.getseconds() && minutes > m2.getminutes() && hours > m2.gethours())
{ sub.setseconds(seconds-m2.getseconds());
sub.setminutes(minutes-m2.getminutes());
sub.sethours(hours - m2.gethours()) ; }
return sub; }
void mytime::print() {
cout<<setfill('0') << setw(2)<< hours << ":" << setw(2)<<minutes << ": "<< setw(2)<< seconds << endl ; }
void mycomplex::setreal(double r)
{ real = r; }
void mycomplex::setimaginary(double i)
{imaginary = i; }
double mycomplex::getreal ()
{ return real; }
double mycomplex::getimaginary ()
{ return imaginary; }
mycomplex mycomplex::add(mycomplex c)
{ mycomplex sum;
sum.setreal(real+c.getreal());
sum.setimaginary(imaginary+c.getimaginary());
return sum; }
mycomplex mycomplex::subtract(mycomplex c)
{ mycomplex sub ;
sub.setreal(real-c.getreal());
sub.setimaginary(imaginary - c.getimaginary());
return sub ; }
mycomplex mycomplex::multiply (mycomplex c)
{ mycomplex mul;
mul.setreal(real*c.getreal()-imaginary*c.getimaginary());
mul.setimaginary(real*c.getimaginary()+imaginary*c.getreal());
return mul; }
void mycomplex::print()
{ if (imaginary<0)
cout << real << "" <<imaginary <<"j" << endl ;
else
cout << real << "+" <<imaginary <<"j" << endl ;}
#include <iostream>
#include "ourclasses.h"
using namespace std;
void fraction::setnumerator(int n)
{ numerator = n; }
void fraction::setdenumerator(int d)
{ denumerator = d; }
int fraction::getnumerator()
{ return numerator; }
int fraction::getdenumerator()
{return denumerator; }
fraction fraction::add (fraction f1)
{ fraction sum;
if (denumerator == f1.getdenumerator())
{ sum.setdenumerator(denumerator);
sum.setdenumerator(numerator+f1.getnumerator()); }
else if (denumerator%f1.getdenumerator() ==0 || f1.getdenumerator()%denumerator==0)
{ if (denumerator < f1.getdenumerator())
{ sum.setdenumerator(f1.getdenumerator());
sum.setnumerator(numerator*(f1.getdenumerator()/denumerator)+f1.getnumerator()); }
else
{ sum.setdenumerator(denumerator);
sum.setnumerator(numerator+f1.getnumerator()*(denumerator/f1.getdenumerator())); } }
else if (denumerator%f1.getdenumerator()!=0 && f1.getdenumerator()%denumerator!=0)
{ sum.setdenumerator(denumerator*f1.getdenumerator());
sum.setnumerator(numerator*f1.getdenumerator()+f1.getnumerator()*denumerator); }
return sum ; }
fraction fraction::subtract (fraction f1)
{ fraction sub;
if (denumerator == f1.getdenumerator())
{ sub.setdenumerator(denumerator);
sub.setdenumerator(numerator+f1.getnumerator()); }
else if (denumerator%f1.getdenumerator() ==0 || f1.getdenumerator()%denumerator==0)
{ if (denumerator < f1.getdenumerator())
{ sub.setdenumerator(f1.getdenumerator());
sub.setnumerator(numerator*(f1.getdenumerator()/denumerator)-f1.getnumerator()); }
else{
sub.setdenumerator(denumerator);
sub.setnumerator(numerator-f1.getnumerator()*(denumerator/f1.getdenumerator())); } }
else if (denumerator%f1.getdenumerator()!=0 && f1.getdenumerator()%denumerator!=0)
{ sub.setdenumerator(denumerator*f1.getdenumerator());
sub.setnumerator(numerator*f1.getdenumerator()-f1.getnumerator()*denumerator);
return sub ; }
fraction fraction::multiply (fraction f1) {
fraction mul;
mul.setnumerator(numerator*f1.getnumerator());
mul.setdenumerator(denumerator*f1.getdenumerator());
return mul; }
fraction fraction::simplify ( fraction f1 )
{ fraction simp;
int n,d;
n=f1.getnumerator();
d=f1.getdenumerator();
if (n == d)
{ simp.setnumerator(n/d);
simp.setdenumerator(n/d); }
else if (n% d==0 || d%n == 0)
{ if (n < d )
 { simp.setdenumerator(d/n);
simp.setnumerator(n/n); }
else if (n > d )
{ simp.setdenumerator(d/d);
simp.setnumerator(n/d) ; } }
else if (n% d>0 || d %n > 0)
{ for (int i = 2 ; i < 100 ; i++ )
{ if (n%i ==0)
{ simp.setnumerator(n/i);
i--; }
if (d%i == 0) {
simp.setdenumerator(d/i);
i-- } } }
return simp ; }
void fraction::print () {
cout << numerator << "/" << denumerator << endl;}
Output of task 1 and 2: Output of task 3:

Output of task 4: