Discussion :

[matthieu637]

Bonjour à tous,
je vais donner le code puisqu'il est très simple :

Une classe mère, qui contient un constructeur qui appelle une méthode virtuelle.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
class A{
public:
  A(){
    test();
  }
 
  virtual void test(){
    std::cout << "classe A";
  }
};

Puis une classe fille qui ne fait que redéfinir la méthode virtuelle :

Code :

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

1
2
3
4
5
6
7
 
class B : public A{
public:
    void test() {
    std::cout << "classe B";
  }
};

Le main ne contient que la création d'un objet B, qui provoque l'affichage du message : "classe A".
Or je voudrais le contraire, vennant de Java j'utilisais souvent ce mécanisme pour éviter de la duplication de code.

Comment palier à ce résultat?
Merci à toutes réponses.

[r0d]

Bonjour,

je ne suis pas sûr de comprendre. Car tout simplement:

Code :

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

1
2
B b();
b.test();

Affichera: "classe B"

[rmdak]

Ces liens pourraient t'interesser : http://www.artima.com/cppsource/nevercall.html et http://stackoverflow.com/questions/4...om-constructor

[matthieu637]

Effectivement, sauf que je veux que ce soit fait dans le constructeur de la classe mère.
C'est une façon de personnaliser le constructeur de la classe B sans pour autant copier-coller celui de la A.

Exemple :
- A la base le constructeur de la classe A est complet.
- Puis je vois que je vais devoir dériver une classe B de A, mais la j'aimerais modifier légèrement le constructeur pour ma classe B [ sans faire un copier-coller de celui de A et modifier la ligne approprié ( car duplication de code ) ]

Je vais donc isolé la partie que je veux modifier dans une méthode virtuelle.
Le constructeur de A sera alors général. Dans toutes les classes filles je n'aurais qu'à redéfinir la méthode pour changer quelques petites choses.

Exemple en code ( ma classe A ) :

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
 
class Tableau{
public:
    Tableau(){
 
         ... pleins d opérations initiales ...
 
         for(...)     
            tableau[...] = creerValeur(...);
    }
 
    virtual int creerValeur(...){
         return ...;
    }
};

Ma classe B, qui veut un contenu un peu différent pour son tableau, mais sans modifier les nombreuses opérations initiales :

Code :

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

1
2
3
4
5
6
7
 
class TableauTrie : public Tableau{
 
   int creerValeur(...){
        return ....;
   }
};

Voila c'est tout. Peut-être dois-je utiliser une méthode virtuelle pure?

[gbdivers]

As tu consulté la FAQ à ce sujet ?

Puis-je appeler des fonctions virtuelles dans le constructeur (ou le destructeur) ?

De mémoire, il y aura une nouvelle fonctionnalité dans c++0x pour cela (delegating constructors je crois ?)

Une alternative est de créer une fonction init() ou équivalent qui initialise ton objet en appelant les fonctions virtuelles

EDIT : suite à ton message
Par exemple, tu souhaites appeler une fonction creerValeur() dans le constructeur d'un tableau. En terme objet, ça me semble être une approche "étrange"
On s'attendrait plutôt à ce qu'un tableau (un conteneur en général) ne se remplisse pas tout seul mais lors d'appel de fonctions spécifique (push_back, addQuelqueChose, etc.) ou à défaut se redimensionne avec des valeurs par défaut (resize, addRow, UnConstructeur(int x, inty) càd en remplissant avec des 0, des chaines vides ou en appelant le constructeur par défaut du type contenu)
Donc le remplir avec des éléments en fonction du type de tableau n'est pas un comportement habituel, non ? (si quelqu'un a des contre-exemples)

[matthieu637]

Merci à tous, j'ai lu les différents liens et cela ne fonctionne pas comme en java.
Je retiens donc qu'on n'appelle pas de méthode virtuelle dans le constructeur.

Je vais utiliser des init().

[JolyLoic]

La différence fondamentale entre le C++ et le Java en l'occurrence est que le C++ considère que le constructeur défini comment initialiser l'objet, alors que Java considère qu'il est appelé après une initialisation par défaut de l'objet, pour lui donner des paramètres additionnels.


A part ça, plutôt qu'un simple init, que l'on risque d'oublier d'appeler, le plus sûr est de faire les appels virtuels dans une factory, dès que l'objet est fini d'être construit. On met alors le constructeur de A en private afin d'éviter de construire l'objet sans passer par la factory.

[matthieu637]

Je vois merci pour la précision.