Exemple : fenêtres avec bord

On considère, une classe fenetre_base des fenêtres dans un environnement graphique, une des données membres est la position de la fenêtre, la fonction membre affiche() est la fonction qui permet l'affichage normal d'un fenêtre ; c'est une fonction virtuelle puisque chaque descendant de cette classe pourra avoir une forme d'affichage particulière. _affiche() est la fonction d'affichage spécifique à cette classe, cet affichage se fait par rapport à la position de la fenêtre.

#include <iostream.h>
struct position{int x,y;};
class fenetre_base{
protected:
    position p; // la position de la fenetre
    // ...
public:
    fenetre_base(){ p.x=10;p.y=10;}
    virtual position get_position(){
        return p;
    }
    void _affiche(){
        cout<<"\tfenetre_base::_affiche ("
                  <<p.x<<","<<p.y<<")\n";
    }
    virtual void affiche(){
        _affiche();
    }
};

La classe fenetre_borde est une classe dérivée de la classe fenetre_base. Une fenêtre avec bord est simplement une fenêtre (de base) et un bord (repéré par une position). Dans ce cas, pour l'affichage, il faudra, d'une part afficher la fenêtre de base et d'autre part, afficher le bord.

class fenetre_borde: 
public  virtual fenetre_base{
    position pb; // la position du bord
public:
    fenetre_borde(){ pb.x=p.x+1;pb.y=p.y+1;}
    void _affiche(){
        cout<<"\tfenetre_borde::_affiche() ("
                 <<pb.x<<","<<pb.y<<")\n";
                 // ...
    };  
    void affiche(){ 
        fenetre_base::_affiche(); 
        _affiche();
    }
    position get_position(){
        return pb;
    }
};

La classe menu est une fenêtre particulière.

class menu: public  virtual fenetre_base{
public:
    void _affiche(){
        position pm=get_position();
        cout<<"\tmenu::_affiche() ("
               <<pm.x<<","<<pm.y<<")\n";
               // ...
    }
    void affiche(){
        fenetre_base::_affiche();
        _affiche();
    }
};

La classe fenetre_borde_menu, représente des fenêtres avec un bord et un menu. Le point important est que l'affichage du menu, dans ce cas, doit se faire par rapport à la fenêtre avec le bord.

class fenetre_borde_menu :public fenetre_borde, 
        public menu, 
        virtual public fenetre_base{
public:
    void _affiche(){
       cout<<"\tfenetre_borde_menu::_affiche()\n";
       // ...
    }
    void affiche(){
        fenetre_base::_affiche();
        fenetre_borde::_affiche();
        menu::_affiche();
        _affiche();
    }
};

Pour un appel:

void main(){
    fenetre_borde_menu p; menu* m=&p;
    cout<<"affiche de m---->\n";
    m->affiche();}

On aura l'affichage :

affiche de m---->
        fenetre_base::_affiche (10,10)
        fenetre_borde::_affiche() (11,11)
        menu::_affiche() (11,11)
        fenetre_borde_menu::_affiche()

Si on détaille un peu l'appel menu::_affiche(), cette fonction appelle la fonction get_position(), à ce moment, grâce à la notion de domination, la liaison dynamique fera que cette fonction sera associée à fenetre_borde::get_position(), et c'est ce qui fait que l'affichage se fera par rapport à la position de la fenêtre avec bord. En d'autres termes, cette fonction sera liée à la fonction d'une classe sÏur !

void main(){
    fenetre_borde_menu p; menu* m=&p;
    cout<<"affiche de m---->\n";
    m->affiche();}

affiche de m---->
        fenetre_base::_affiche (10,10)
        fenetre_borde::_affiche() (11,11)
        menu::_affiche() (11,11)
        fenetre_borde_menu::_affiche()