Discussion :

[olivier_78]

Bonjour,

Je me forme à l'utilisation des fonction virtuelles pure.

Je part du code suivant trouvé sur le net qui compile et fonctionne très bien:

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
#include <iostream>
 
class A {
    public:
        virtual void action() = 0;
};
 
class B : public A {
    public:
 
        void action() {
             std::cout << "action" << std::endl;
        }
};
 
class MyClass {
 
    public:
 
        static void setInstance(A *newInstance) {
                instance = newInstance;
        }
 
    private:
        MyClass();
        static A *instance;
};
 
A *MyClass::instance = 0;
 
int main(int argc, char** argv) {
    B myInstance;
    MyClass::setInstance(&myInstance);
    myInstance.action();
    return 0;
}

J'aimerais maintenant ajouter un 'getter' getInstance dans la classe MyClass permettant d'instancier une classe A si la variable instance est nulle.

Ce qui donne le code suivant:

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
#include <iostream>
 
class A {
    public:
        virtual void action() = 0;
};
 
class B : public A {
    public:
 
        void action() {
             std::cout << "action" << std::endl;
        }
};
 
class MyClass {
 
    public:
 
        static void setInstance(A *newInstance) {
                instance = newInstance;
        }
 
        static A& getInstance() {
 
            static A newInstance;
 
            if (!instance)
                instance = &newInstance;
 
            return *instance;
        }
 
    private:
        MyClass();
        static A *instance;
};
 
A *MyClass::instance = 0;
 
int main(int argc, char** argv) {
    B myInstance;
    MyClass::setInstance(&myInstance);
    myInstance.action();
    return 0;
}

Je ne sais pas comment résoudre le problème de compilation suivant :

g++ -o test test.cpp
test.cpp: In static member function ‘static A& MyClass::getInstance()’:
test.cpp:26:22: erreur: cannot declare variable ‘newInstance’ to be of abstract type ‘A’
test.cpp:3:7: note: because the following virtual functions are pure within ‘A’:
test.cpp:5:22: note: virtual void A::action()

La fonction action est définie dans la classe B.

Qu'en pensez vous ?

Merci par avance.

[Ekleog]

Lignes 24-32, le compilateur ne peut pas savoir si tu veux utiliser la classe B pour instancier A, ou bien si tu veux utiliser une (hypothétique) classe C.

Du coup, remplacer le A par un B ligne 26 résoudrait le problème.

[olivier_78]

Vouaouu merci beaucoup.

Tout devient clair avec une bonne explication :-)

[koala01]

Salut,

Un peu de théorie, d'abord, pour te permettre de comprendre

Une fonction virtuelle pure est ce que l'on appelle une "fonction d'interface", c'est à dire une fonction dont on sait que les classes dérévées en auront besoin mais pour laquelle il nous est impossible de fournir une implémentation en l'état actuel des choses.

La raison la plus fréquente (hormis celle de rendre la classe abstraite, mais j'y reviendrai plus tard) est, tout simplement, que la classe de base ne dispose pas des informations nécessaires pour permettre de définir un "comportement cohérent" pour la fonction.

Le fait de déclarer une fonction virtuelle comme étant pure ( en faisant suivre sa déclaration du fameux " = 0 ") va simplement indiquer au compilateur qu'il ne sert à rien qu'il se mette à chercher l'implémentaion de la fonction, pour la raison que je viens d'expliquer

Seulement, le compilateur a "horreur du vide"...

Tu comprendras cependant assez facilement que l'on ne puisse pas se permettre d'accepter de créer une instance d'une classe pour laquelle une fonction n'a pas été définie!!!

Si cela devait arriver, on serait bien embêtés le jour où cette fonction serait appelée, car on ne peut absolument pas prévoir ce qui pourrait bien se passer

Mais une chose est sure: quoi qu'il puisse se passer dans cette hypothèse, ce ne serait surement rien de bon pour l'application

La décision la plus sage à prendre, et qui a d'ailleurs été prise, consiste à, purement et simplement, interdire la création d'une instance d'une classe dans laquelle toutes les fonctions n'ont pas été correctement définies.

Le terme qui définit une classe dont on ne peut pas créer d'instance est le terme "abstrait" (et, plus précisément "classe abstraite"), qu'il faut, tout simplement, mettre en opposition avec le mot "concrèt" (qui existe )

Maintenant, il existe deux grands axes pour utiliser cette restriction:

La première est de se dire "bon, je dispose d'aucun moyen de fournir une implémentation pour telle ou telle fonction, car je ne dispose pas des données suffisante pour ce faire" et le fait de déclarer une fonction virtuelle comme étant "pure" rendra, de facto, la classe abstraite, et interdira donc d'en créer une instance.

La deuxième solution est de se dire "je dois créer une classe dont d'autre vont hériter, afin de profiter de la substitution, et donc du polymorphisme, mais je ne veux surtout pas que l'utilisateur puisse créer une instance de cette classe, simplement parce que cela n'aurait aucun sens : l'objet obtenu ne serait pas viable".

Ce serait, par exemple, le cas d'une classe "véhicule".

Les classes qui en dérivent (voiture, camion, moto, vélo, bateau, char à voile, caisse à savon) sont, effectivement, autant de véhicules, avec chacuns leurs particularités propres, clairement identifiables (il est rare que tu prenne une moto pour un char à voile ), mais par contre, si je te dis "j'ai acheté un nouveau véhicule" ben, tu aimeras surement savoir si j'ai acheté une moto, un camion, un char à voile ou une voiture .

Le véhicule, en tant que tel est beaucoup trop imprécis pour pouvoir etre touché, analysé, comparé, ou quoi que ce soit d'autre

Tu prendras alors la décision de déclarer une fonction virtuelle (il faut que ce soit une fonction virtuelle, pour qu'elle puisse etre implémentée dans les classes qui dériveront de la classe que tu crées ) comme étant pure, et l'interdiction se mettra en place, parce que tu auras beau lui parler poliment, l'insulter de tous les noms d'oiseaux, crier dessus ou le menacer, le compilateur sera toujours plus buté que toi

Lignes 24-32, le compilateur ne peut pas savoir si tu veux utiliser la classe B pour instancier A, ou bien si tu veux utiliser une (hypothétique) classe C.

Du coup, remplacer le A par un B ligne 26 résoudrait le problème.

Et justement, pourquoi un B et non un éventuel C, D, E ou F qui hériterait de A

Si tu veux utiliser le polymorphisme dans cette situation, le moins mauvais choix est de mettre en place une gestion d'erreur (assert ou lancement d'exception) si le pointeur est encore à null au moment où l'on invoque la fonction instance

Ceci dit, la notion de polymoprhisme est rarement compatbile avec la notion de singleton, qui est, soit dit en passant, à considérer comme un anti pattern

La solution la "moins mauvaise" consisterait à avoir un objet de type singleton et à implément le pimpl idiom, avec une gestion cohérente du type réel de l'objet pointé

[3DArchi]

Salut,

(les variables statiques, c'est mal).

Un tutoriel sur les fonctions virtuelles : Les fonctions virtuelles en C++

[Ekleog]

Et justement, pourquoi un B et non un éventuel C, D, E ou F qui hériterait de A

J'ai juste essayé de lire dans ses pensées.

Et j'étais trop pressé pour expliquer plus en détail. (Oui, je sais, j'aurais mieux fait de me taire, mais il m'a semblé évident que ce qu'il attendait était ce que j'ai proposé comme réponse, et je me suis donc senti obligé de répondre en vitesse.)

[olivier_78]

Merci pour les explications très précises

Ce me permet d'avancer en toute compréhension

Ekleog aucune raison de te taire, ta réponse m'a permise de me dire que mais oui mais c'est bien sur :-)