Discussion :

[bit_o]

Bonsoir,

mes classes sont schématisées comme suit :

Code :

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

1
2
3
 
A --> B
A --> C

j'ai défini une méthode virtuelle au niveau de la classe A

Code :

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

virtual void func() = 0;

Maintenant je voudrais la redéfinir au niveau de B puis au niveau de C.
j'ai essayé plusieurs méthodes sans parvenir à aucun résultat .. :-/

dans B.cpp :

Code :

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

1
2
3
 
//1er essai
void B::func() { ... }

génère une erreur : la méthode n'a pas été définie dans B.h.
En effet, je n'ai pas besoin de remettre le prototype dans B.h puisque B hérite de A, non?

dans B.cpp :

Code :

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

1
2
3
 
//2nd essai
void A::func() { ... }

Lorsque je mets le même code dans C.cpp, j'ai une erreur de compilation qui me dit que la méthode func() est définie à deux endroits...

est-ce que vous pouvez m'apporter vos lumières sur ce problème ?

merci de votre aide

[koala01]

Salut,

Déjà, il faut préciser: la fonction que tu déclare est... une fonction virtuelle pure (à comprendre: une fonction pour laquelle tu ne fournis pas de définition).

Le terme pure en l'occurrence est nécessaire parce qu'il implique, entre autre, que la classe de base n'est pas instanciable (on parle aussi de "classe abstraite").

La raison est bien simple: le compilateur a horreur du vide, et ne permet donc pas d'instancier une classe pour laquelle toutes les méthodes n'auraient pas été définies.

Ensuite, il faut bien comprendre que le fait de faire hériter une classe d'une autre ne suffit pas pour permettre de redéfinir (ou de définir s'il s'agit d'une méthode virtuelle pure) une méthode virtuelle de la classe de base.

Le mot clé virtual signifie en effet, de manière simplifiée "cette fonction risque d'être (ou peut) redéfinie dans les classes dériviée", les mots importants étant risque et peut, ce qui montre bien que rien n'oblige à le faire, mais que si l'utilisateur le souhaite, il peut les redéfinir

Pour pouvoir (re)définir une méthode virtuelle de la classe de base dans la classe héritée, tu dois redéclarer la méthode en question dans la classe dans laquelle tu souhaite la redéfinir.

Au final, les déclarations des classes ressemble donc à

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class Base
{
    public:
        /*...*/
        /* une méthode virtuelle: l'implémentation de la méthode existe
         * pour la classe de base
         */
        virtual void foo();
        /*voire
         * une méthode virtuelle pure: l'implémentation n'est pas donnée
         * pour la classe de base, ce qui rend la classe de base abstraite
         * seules les classes dérivées redéfinissant cette méthodes deviendront
         * concrètes
         */
        virtual void bar() =0;
};
 
class Derivee1 : public Base
{
    public:
        /* permet de redéfinir foo pour la classe Derivee1
         */
        virtual void foo();
        /* comme on ne redéfinit pas bar, la classe est égalemetn abstraite
         */
};
class Derivee2 : public Base
{
    public:
        /* comme on ne redéfinit pas foo, c'est le comportement prévu
         * pour la classe de base qui sera utilisé
         * par contre, le fait de redéfinir bar fait de Derivee2 une classe 
         * concrète (instanciable)
         */
        virtual void bar();
};
 
class Derivee3 : public Base
{
    public:
       /* modifie le comportement de foo pour Derivee3
        */
        virtual void foo();
        /* définis le comportement de bar pour Derivee3, ce qui en fait
         * une classe concrète (instanciable)
         */
        virtual void bar();
};

Au niveau de l'implémentation, il faudra fournir la définition de

• void Base::foo()
• void Derivee1::foo()
• void Derifee2::bar()
• void Derivee3::foo()
• void Derifee3::bar()

sous peine d'avoir une erreur lors de l'édition des liens

[bit_o]

Merci beaucoup pour l'explication

[NiamorH]

Déjà, il faut préciser: la fonction que tu déclare est... une fonction virtuelle pure (à comprendre: une fonction pour laquelle tu ne fournis pas de définition).

Une exception : les destructeurs peuvent être déclarés virtuels purs et pour autant doivent fournir une définition.

[koala01]

Une exception : les destructeurs peuvent être déclarés virtuels purs et pour autant doivent fournir une définition.

Tout à fait, mais, si j'ai décidé de ne pas en parler, c'est pour des raisons que je trouve bonnes et que je vais t'exposer:

1. Le problème bit_o était à la base un problème propre à la redéfinition des fonctions virtuelles, qu'elles soient pures, ou non
2. L'idée de base de mon intervention était de donner suffisemment d'informations à bit_o pour lui permettre d'appréhender ce qu'est une fonction virtuelle pure, ce qui représentait déjà une digression par rapport à son problème réel (qui n'est "tombé" que "par hasard" sur une fonction virtuelle pure)
3. L'exception que peut représenter le destructeur virtuel pur est, certes, importante, mais elle justifie de donner des explications sur les raisons de cette exception qui se seraient encore écartées d'avantage du problème réel de bit_o

Tu le sais, j'ai déjà tendance à donner énormément d'informations dans mes interventions...

Pour une fois que j'essayais de "la faire courte", tu ne vas pas me le reprocher, quand même

@bit_o>> Si tu souhaites des précisions sur les raisons qui font qu'un destructeur virtuel pure doit malgré tout être défini, n'hésite pas à nous le faire savoir

[JolyLoic]

Une exception : les destructeurs peuvent être déclarés virtuels purs et pour autant doivent fournir une définition.

[Mode chipotage]
Ce n'est pas vraiment exactement ça... On peut toujours définir une fonction virtuelle pure, quelle qu'elle soit. Pure veut juste dire : "Je rends la classe abstraite, ainsi que toutes les classes dérivées où je n'ai pas été supplanté". Maintenant, une fonction virtuelle pure que l'on aurait défini ne sera normalement pas appelé, car la résolution virtuelle de l'appel l'empêchera, sauf :
- En cas d'appel explicite dans une classe fille (base::f())
- Dans le cas du destructeur qui sera obligatoirement appelé.
[/mode]

[scolyo]

Bonjour à tous,

Koala01, tu disais, si j'ai bien saisi qu'une fonction virtuelle pure peut ou doit être rédéfini. C'est le "peut" qui m'intéresse quelque peu . Je suis tombé par hasard sur le "problème" des classes abstraites en essayant de faire ceci:

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
 
void MyWriter()
{
	CoInitializeSecurity(
           NULL,                                 //  IN PSECURITY_DESCRIPTOR         pSecDesc,
           -1,                                  //  IN LONG                         cAuthSvc,
           NULL,                                //  IN SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
           NULL,                                //  IN void                        *pReserved1,
           RPC_C_AUTHN_LEVEL_PKT_PRIVACY,       //  IN DWORD                        dwAuthnLevel,
           RPC_C_IMP_LEVEL_IDENTIFY,            //  IN DWORD                        dwImpLevel,
           NULL,                                //  IN void                        *pAuthList,
           EOAC_NONE,
                                                //  IN DWORD                        dwCapabilities,
           NULL                                 //  IN void                        *pReserved3
           );
	static const VSS_ID WriterId  = { 0x8adfb024, 0x971e, 0x582a, { 0x77, 0x64, 0x22, 0xf4, 0x32, 0xc1, 0xdf, 0x74 } };
 
CVssWriter SydogWriter;
	SydogWriter.Initialize(WriterId, L"SyDoG", VSS_UT_USERDATA, VSS_ST_OTHER, VSS_APP_FRONT_END, 60000, VSS_AWS_NO_ALTERNATE_WRITER, FALSE);
}

Apparemment, on ne fait pas les choses en C++ comme on est tenté de les faire en java. Le compilateur m'a dit (d'aller siffler sur la colline):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
1>error C2259: 'CVssWriter'*: impossible d'instancier une classe abstraite
1>        à cause des membres suivants*:
1>        'bool CVssWriter::OnPrepareSnapshot(void)'*: est abstrait
1>        C:\Program Files\Microsoft\VSSSDK72\inc\winxp\VsWriter.h(591)*: voir la déclaration de 'CVssWriter::OnPrepareSnapshot'
1>        'bool CVssWriter::OnFreeze(void)'*: est abstrait
1>        C:\Program Files\Microsoft\VSSSDK72\inc\winxp\VsWriter.h(594)*: voir la déclaration de 'CVssWriter::OnFreeze'
1>        'bool CVssWriter::OnThaw(void)'*: est abstrait
1>        C:\Program Files\Microsoft\VSSSDK72\inc\winxp\VsWriter.h(597)*: voir la déclaration de 'CVssWriter::OnThaw'
1>        'bool CVssWriter::OnAbort(void)'*: est abstrait
1>        C:\Program Files\Microsoft\VSSSDK72\inc\winxp\VsWriter.h(600)*: voir la déclaration de 'CVssWriter::OnAbort'

Alors du coup, j'ai essayer, pour voir ce que ça donne, de redéfinir une fonction (virtuelle pure?), pour instancier une classe CVssWriter (encore merci la faq, sinon je croix que je serais encore en train de chercher):

Code :

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

1
2
3
4
5
6
 
class SydogWriter : public CVssWriter
	{
	public:
		bool CVssWriter::OnAbort();
	}

mais ça ne marche pas non plus:

Code :

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

1
2
3
4
5
6
7
 
1>.\VssFunction.cpp(38) : error C3254: 'MyWriter::SydogWriter'*: la classe contient une substitution explicite 'OnAbort', mais ne dérive pas d'une interface qui contient la déclaration de fonction
1>.\VssFunction.cpp(38) : warning C4822: 'MyWriter::SydogWriter::OnAbort'*: la fonction membre de classe locale n'a pas de corps
1>.\VssFunction.cpp(38) : error C2695: 'MyWriter::SydogWriter::OnAbort'*: la fonction virtuelle de substitution ne diffère de 'CVssWriter::OnAbort' que par la convention d'appel
1>        C:\Program Files\Microsoft\VSSSDK72\inc\winxp\VsWriter.h(600)*: voir la déclaration de 'CVssWriter::OnAbort'
1>.\VssFunction.cpp(38) : error C3640: 'MyWriter::SydogWriter::OnAbort'*: une fonction membre référencée ou virtuelle d'une classe locale doit être définie
1>.\VssFunction.cpp(44) : error C2143: erreur de syntaxe*: absence de ';' avant '}'

D'ou mes trois questions:
Quand on a pas le code source, comment peut-on savoir si la fonction sur laquelle rechigne le compilateur est vraiment virtuelle pure?

Est-on obligé de redéfinir dans la classe cette fameuse fonction?

Si c'est mon cas (que la fonction OnAbort() est virtuelle pure et que je doive la redéfinir), qu'est-ce que j'ai loupé?

Je voudrais juste instancier un objet de type CVssWriter et l'initialiser

D'avance merci

[Jean-Marc.Bourguet]

Déjà, il faut préciser: la fonction que tu déclare est... une fonction virtuelle pure (à comprendre: une fonction pour laquelle tu ne fournis pas de définition).

Non, voir message de Loic.

Le mot clé virtual signifie en effet, de manière simplifiée "cette fonction risque d'être (ou peut) redéfinie dans les classes dériviée", les mots importants étant risque et peut, ce qui montre bien que rien n'oblige à le faire, mais que si l'utilisateur le souhaite, il peut les redéfinir

Non. On peut toujours redefinir une fonction membre, virtuelle, ou non. Le mot cle virtual signifie qu'il faut faire une resolution de surcharge qui prend en compte le type dynamique de l'objet sur lequel la fonction membre est appelee (en plus des types statiques des -- autres? -- arguments).

[Médinoc]

Code :

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

1
2
CVssWriter *SydogWriter = ... /*sans doute CoCreateInstance() ou new*/ ;
	SydogWriter->Initialize(WriterId, L"SyDoG", VSS_UT_USERDATA, VSS_ST_OTHER, VSS_APP_FRONT_END, 60000, VSS_AWS_NO_ALTERNATE_WRITER, FALSE);

[scolyo]

Pour Jean-Marc:

Si je comprend bien l'explication de JolyLoic, si je ne redéfini pas une fonction virtuelle pure, elle n'est pas appelé, donc, ce n'est pas une obligation de la redéfinir, c'est bien ça? Si c'est bien ça, pourquoi le compilateur refuse de compiler?

Pour Medinoc:

Si j'utilise new comme ça:

Code :

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

1
2
 
CVssWriter *SydogWriter = new CVssWriter SydogWriter;

J'ai la même erreur qu'au début, la C2259...

Je sais bien que je suis débutant, que mon niveau en dev est proche de zéro, mais je reconnais que j'ai du mal à voir l'utilité des fonctions virtuelles pure...

[Médinoc]

C'est normal, CVssWriter est une classe abstraite.
Par contre, ceci pourrait marcher si la classe SydogWriter implémentait toutes les méthodes abstraites de CVssWriter :

Code C++ :

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

1
2
CVssWriter *pWriter = new SydogWriter;
	pWriter->Initialize(WriterId, L"SyDoG", VSS_UT_USERDATA, VSS_ST_OTHER, VSS_APP_FRONT_END, 60000, VSS_AWS_NO_ALTERNATE_WRITER, FALSE);

[3DArchi]

Pour Jean-Marc:

Si je comprend bien l'explication de JolyLoic, si je ne redéfini pas une fonction virtuelle pure, elle n'est pas appelé, donc, ce n'est pas une obligation de la redéfinir, c'est bien ça?

Non. Une fonction virtuelle pure indique que ta classe sera abstraite et ne pourra pas être instanciée. Pour une classe qui dérive de ta classe, elle restera abstraite si elle ne redéfinie pas ta fonction. Pour pouvoir l'instancier il faut que tu redéfinisse la fonction.
Deuxième point différent. La fonction virtuelle pure peut avoir un corps qui la définisse. Mais comme dans la classe fille tu auras forcément redéfinis cette fonction pour pouvoir l'instancier, alors: soit dans la classe fille tu fais appel à la méthode de la classe mère explicitement, soit la fonction de la classe mère ne sera jamais appelé.
Bien sûr, pour embrouillé la chose, c'est presque faux pour le destructeur qui sera lui systématiquement appelé et pour lequel il n'y a pas à faire d'appel explicite au destructeur de la classe mère.

En résumé:

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
23
24
25
26
27
 
class CAbstraite
{
...
virtual void MaFonctionVirutellePure()=0
   {
        ......
   }
};
class CConcrete  :public CAbstraite
{
.....
virtual void MaFonctionVirutellePure()
   {
        // Si je veux appeler la classe parente, il faut le faire explicitement:
        CAbstraite::MaFonctionVirutellePure();
   }
};
 
class CAutreClasseAbstraite  :public CAbstraite
{
...
// Jamais de redéfinition de MaFonctionVirutellePure
};
 
new CConcrete; // OK
new CAutreClasseAbstraite ; // KO (C2259)

[Jean-Marc.Bourguet]

si je ne redéfini pas une fonction virtuelle pure, elle n'est pas appelé

Tu ne peux pas instancier la classe. C'est la le sens du pure: impossible d'instancier la classe ou un de ses descendants si elle n'est pas supplantee quelque part dans la hierarchie.

[NiamorH]

@ scolyo

Ce sont les fonctions virtuelles non pures qu'il est possible de ne pas redéfinir mais la classe de base est donc obligée d'en fournir une définition.

[scolyo]

D'accord, merci beaucoup, je vais déjà essayer d'implémenter la fonction OnAbort()