POO: classe et heritage

class fraction
{
      public:
             fraction(int=0,int=1);
             fraction(double&);
             int pgcd(int,int);
             fraction operator+=(fraction);
             fraction operator-=(fraction);
             fraction operator*=(fraction);
             bool operator==(fraction);
             int num();
             int den();
             void afficher();
             
      protected:
              int a,b;
              void reduire();
};
class intfract: public fraction
{
      public:
             intfract(int=0);
		     intfract(int=0,int=0,int=0);
		     intfract(fraction);
             intfract& operator+=(intfract&);
             void aff();
       protected:
               int Pint;
};

#include <iostream>
#include <sstream>

template <typename T>
class Complex
{
public:
  Complex();
  Complex(T real);
  Complex(T real, T img);

  Complex<T> operator*(const Complex<T>& image) const
  {
    return Complex<T>(_real * image._real - _img * image._img,
		      _real * image._img + _img * image._real);
  }

  T real() const;
  T img() const;

  void display(std::ostream& out) const;
private:
  T _real;
  T _img;
};

template <typename T>
std::ostream& operator<<(std::ostream& out, const Complex<T>& imag);

template <typename T>
Complex<T>::Complex()
  : _real(0), _img(0)
{
}

template <typename T>
Complex<T>::Complex(T real)
  : _real(real), _img(0)
{
}

template <typename T>
Complex<T>::Complex(T real, T img)
  : _real(real), _img(img)
{
}

template <typename T>
void Complex<T>::display(std::ostream& out) const
{
  out << _real << " + " << _img << "i";
}

template <typename T>
T Complex<T>::real() const
{
  return _real;
}

template <typename T>
T Complex<T>::img() const
{
  return _img;
}

template <typename T>
std::ostream& operator<<(std::ostream& out, const Complex<T>& imag)
{
  imag.display(out);
  return out;
}


template <typename T>
class Fraction
{
public:
  Fraction();
  Fraction(T num);
  Fraction(T num, T den);
  Fraction(const Fraction<T>& frac);
  Fraction<T> operator*(const Fraction<T>& frac) const;
  void display(std::ostream& out) const;
private:
  T _num;
  T _den;
};

template <typename T>
std::ostream& operator<<(std::ostream& out, const Fraction<T>& imag);

template <typename T>
Fraction<T>::Fraction()
  : _num(0), _den(1)
{
}

template <typename T>
Fraction<T>::Fraction(T num)
  : _num(num), _den(1)
{
}

template <typename T>
Fraction<T>::Fraction(T num, T den)
  : _num(num), _den(den)
{
}

template <typename T>
Fraction<T>::Fraction(const Fraction<T>& frac)
  : _num(frac._num), _den(frac._den)
{
}

template <typename T>
Fraction<T> Fraction<T>::operator*(const Fraction<T>& frac) const
{
  return Fraction<T>(_num * frac._num, _den * frac._den);
}

template <typename T>
void Fraction<T>::display(std::ostream& out) const
{
  out << _num << "/" << _den;
}

template <typename T>
std::ostream& operator<<(std::ostream& out, const Fraction<T>& imag)
{
  imag.display(out);
  return out;
}

int main()
{
  Complex<int> im(4, 5);
  std::cout << im << std::endl;

  {
    Fraction<int> f(5, 6);
    Fraction<int> g(5, 2);
    Fraction<int> h = f * g;
    std::cout << f << std::endl
	      << g << std::endl
	      << h << std::endl;
  }
  {
    Fraction<double> f(5.5, 6.6);
    Fraction<double> g(5.5, 2.2);
    Fraction<double> h = f * g;
    std::cout << f << std::endl
	      << g << std::endl
	      << h << std::endl;
  }
  {
    Fraction<Complex<int> > f(Complex<int>(5, 6), Complex<int>(6, 8));
    Fraction<Complex<int> > g(Complex<int>(8, 10), Complex<int>(78, 2));
    Fraction<Complex<int> > h = f * g;
    std::cout << f << std::endl
	      << g << std::endl
	      << h << std::endl;
  }

  return 0;
}