Discussion :

[beegees]

Bonjour tout le monde,

J'ai une classe Rectangle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

class CRectangle : public CForme 

Voici CForme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
class CForme
{
public:
	CForme();
	CForme(const CForme& Source);
	CForme(const char* UnNom);
	~CForme();
 
	bool				EstValide() const;
 
	const char*			Nom() const;
	double				Surface() const;
 
	bool				Nom(const char* UnNom);
 
private:
	CChaine				m_Nom;
};

- Est-ce que CRectangle hérite de toutes les méthodes de CForme ?
- Même des private ?
- N'importe où dans le code ?

Comment appeler une méthode de CForme dans CRectangle ?

Je vous remercie d'avance pour votre aide.

beegees

[koala01]

Salut,

La classe CRectangle permet d'accéder de manière publique à tout ce qui est public de CForme.

En local (donc, au sein d'une méthode propre de CRectangle), tu peux accéder aux méthodes et aux membres publics et protegés de CForme.

Par contre, tout ce qui est privé dans CForme n'est accessible que par les méthodes de CForme (quel que soit la visibilité de la méthode qui essaye d'y accéder).

Ainsi, de manière général, avec une classe de base du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Base
{
    public:
       void methodePublique();
       int membrepublic;
    protected:
       void methodeProtegee();
       int membreprotege;
    private:
       void methodePrivee();
       int membreprive;
};

et une classe dérivée du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Derivee : public Base
{
    public:
        void methodeDeriveePublique();
         int membrederivePublic;
    protected:
         void MethodeDeriveeProtectee();
         int membrederiveprotege;
    private:
         void methodeDeriveePrivee();
         int membrederivepublic;
};

et une déclaration de variable du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Derivee obj;

tu pourras accéder directement à

• obj.methodePublique()
• obj.methodeDeriveePublique()
• obj.membrepublic
• obj.membrederivepublic

Au sein des méthode de Derivee, tu peux accéder

• à tous les membre et méthodes de la classe Derivee
• à methodeProtegee() et
• à membreprotege

Mais seuls les méthodes

• methodePublique
• methodeProtegee et
• methodePrivee

pourront accéder à membreprive

Maintenant, ce n'est valable que dans le cadre d'un héritage public.

En effet, tu peux provoquer un héritage protege ou même privé, et, dans ce cas, la visibilité maximale des différents éléments de la classe de base ne sera que celle de l'héritage.

Ainsi, avec une classe du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class Derivee2: protected Base
{
   /*...*/
};

meme les méthodes et membres publics de Base deviendront protected (et donc accessible seulement depuis les méthodes de Derivee2)

Pär contre, les membres et méthodes privés de Base resteront inaccessible depuis les méthodes de Derivee2

Le principe étant le même dans le cadre d'un héritage privé

Pour appeler une méthode de ta classe de base dans ta classe dérivée, deux situations peuvent exister:

La méthode à appeler n'est pas redéfinie dans la classe dérivée.

Il suffit alors de l'appeler de manière classique (en prenant en compte la visibilité: methodePrivee() ne serait donc pas accessible depuis les méthodes de Derivee )

Le code peut donc être tout simplement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void Derivee::methodeDeriveePublique()
{
    methodePublique(); 
    /* ou */
    methodeProtegee();
}

Le deuxième cas est que la méthode est redéfinie dans la classe dérivée.

Elle est alors déclarée comme méthode virtuelle au sein des deux classes.

Pour appeler explicitement le comportement de la classe de base, il faut indiquer au compilateur que c'est ce que tu veux, en fournissant la portée réelle de la fonction:

ainsi, avec un héritage de l'ordre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Base2
{
    public:
        // une fonction dont le comportement varie en fonction du type réel
        virtual void methodeVirtuelle();
};
class Derivee3: public Base2
{
    public:
        //pour pouvoir redéfinir le comportement, il faut redéclarer la méthode
        virtual void methodeVirtuelle();
        //et une autre méthode pour montrer le fonctionnement
        void laMethode();
};
 
void Derivee3::laMethode()
{
    //ici, on appelle le comportement défini pour Derivee3
    methodeVirtuelle();
    //et ici, on appelle le comportement défini pour la classe de base
    Base2::methodeVirtuelle();
}

[beegees]

Salut Koala,

Woaw, quelle magnifique réposne Merci.

Je relis ça à mon aise et je reviens très vite.

Merci encore.

beegees

[mac&cheese]

N'est-il pas possible de rentre les methodes privées accessibles avec les classes friend?

[koala01]

si, de fait, je n'ai pas parlé de l'amitié...

Voilà la preuve qu'il reste toujours difficile d'être exhaustif

[beegees]

si, de fait, je n'ai pas parlé de l'amitié...

Voilà la preuve qu'il reste toujours difficile d'être exhaustif

Bonjour Koala,

Je viens de terminer quelques tests sur l'héritage et malheureusement, ce que je pensais correct me semble incorrecte.

L'héritage a bien pour but de taper des fonctions afin qu'elles puissent être utilisées par des objets d'autres classes qui ont en commun des objets qui utiliseront ces fonctions ? On les tape alors qu'une seule fois les fonctions.

J'ai fais un test en créant une classe Personne.

Une personne a comme caractéristiques (que ça soit un garçon ou une fille) un nom, un prénom et un âge.

J'ai donc créé ma classe comme ceci dans un fichier .h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class CPersonne
{
public:
	CPersonne();
	CPersonne(const char* Nom,const char* Prenom,int Age);
	~CPersonne();
 
	bool			Nom(const char* UnNom);
	bool			Prenom(const char* UnPrenom);
	bool			Age(int UnAge);
};

J'ai ensuite créé une classe CGarcon en me disant que si je ne tape que ça... :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class CGarcon : public CPersonne
{

	
};

...Je pourrais créer dans le main une variable de type CGarcon nommée par exemple Eric et qu'ensuite, je n'aurais qu'à taper :

Eric. et là les fonctions auraient apparûes.

Ce n'est pas le cas, y'a-t'il quelque chose que je n'ai pas compris ?

Est-ce que ma logique est correcte au niveau de l'héritage ?

Merci d'avance pour votre aide.

beegees