héritage des classes + operateur externe

//Exercice c ++ par la pratique , l'héritage des classes + operateur externe<<

#include <iostream>
#include <cmath>
using namespace std;

//----------------------------------------------------------------------
//----------------------------------------------------------------------
class Rectangle {
    //private:
    protected://autorise l'héritage dans classes dérivés
        double largueur;
        double longueur;
    public :
        Rectangle(double _largueur,double _longueur);
        double getSurface() const;
        double getLargueur() const;
        double getLongueur() const;

        void setLargueur(double l);
        void setLongueur (double l);

};
//----------------------------------------------------------------------
Rectangle::Rectangle (double _largueur=0,double _longueur=0):largueur(_largueur),
    longueur(_longueur){}
double Rectangle::getSurface() const {return largueur*longueur;}
double Rectangle::getLargueur() const{return largueur;}
double Rectangle::getLongueur() const{return longueur;}

void Rectangle::setLargueur(double _largueur){largueur=_largueur;}
void Rectangle::setLongueur (double _longueur){longueur=_longueur;}

//----------------------------------------------------------------------
class Cercle{
    private:
    double rayon,x,y;

    public:
    Cercle(double _rayon,double _x,double _y);
    double getSurface () const;
    bool estInterieur(double _x,double _y) const;
    void getCentre(double& x_out ,double& y_out) const;
    void setCentre(double _x,double _y);
    double getRayon() const;
};
//----------------------------------------------------------------------
Cercle::Cercle(double _rayon=0 , double _x=0, double _y=0):rayon(_rayon) , x(_x) , y(_y) {}
double Cercle::getSurface () const {return M_PI* rayon*rayon;}
bool Cercle::estInterieur(double _x,double _y) const
    {return  ( (_x - x) * ( _x * x) -  (_y - y) * ( _y * y) )  <= rayon*rayon; }
void Cercle::getCentre(double& x_out ,double& y_out) const
    { x_out=x;
    y_out=y;}

void Cercle::setCentre(double _x,double _y){x=_x;y=_y;}
double Cercle::getRayon() const{return rayon;}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//Héritage .Classe qui hérite de la précédente Rectangle
class RectangleColore:public Rectangle{
    unsigned int couleur;
    public:
    RectangleColore (double _largueur,double _longueur ,int couleur);
    int getCouleur() const;
    void setCouleur(int c);
};
RectangleColore::RectangleColore (double _largueur=0,double _longueur=0 ,int _couleur=0):
    //Appel d'abord le constructeur de la classe mere
    Rectangle(_largueur,_longueur),couleur(_couleur){};

int RectangleColore::getCouleur() const{return couleur;}
void RectangleColore::setCouleur(int c){couleur=c;}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//Operateurs externes << cout
ostream& operator <<(ostream& sortie,const Rectangle rectangle){
    cout <<endl<<" Largueur = "<<rectangle.getLargueur()<<" , Longeur = "<<rectangle.getLongueur()
    <<" = "<<rectangle.getSurface();
    return sortie;
}

ostream& operator <<(ostream& sortie,const Cercle cercle){
    cout <<endl<<" Rayon = "<<cercle.getRayon()<<", surface = "<<cercle.getSurface();
    return sortie;
}


//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
int main (){
    Rectangle r(2,3);

    cout<<r<<endl;//utilise une redéfinition de l'opérateur externe <<

    RectangleColore rc(5,7,2);
    cout <<rc<<" , couleur = "<< rc.getCouleur();//utilise une redéfinition de l'opérateur externe <<

    rc.setCouleur(12);
    rc.setLargueur(15);
    rc.setLongueur(17);

    //cout <<rc.getCouleur() <<","<<rc.getLargueur()<<","<<rc.getLongueur()<<" = "<<rc.getSurface() <<endl;
    cout <<rc<<" , couleur = "<< rc.getCouleur();//utilise une redéfinition de l'opérateur externe <<

    Cercle c(12,1,1);
    cout <<c<<endl;
    return 0;
}