Discussion :

[r0d]

Bonjour à tous,

sur vos conseils, je suis parti sur l'implémentation d'un ensemble de classes en utilisant le Template Method. Ca donne à peu près 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
class Mere
{
[...]
void  MethodImpl();
virtual void MethodDerivate() = 0;
};
 
class Fille1 : public Mere
{
void MethodDerivate(){<mon code ici>}
};
 
class Fille2 : public Mere
{
void MethodDerivate(){<mon code (différent) ici>}
};

Cela fonctionait très bien. Mais voilà qu'aujourd'hui, je dois apporter une modification. En effet, la classe Fille2 va maintenant devoir gérer des données propres à elle que Fille1 n'aura pas. Prenons un tableau de int pour l'exemple:

Code :

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

1
2
3
4
5
class Fille2 : public Mere
{
void MethodDerivate(){<mon code (différent) ici>}
vector<int> m_array;
};

Jusque là, tout va bien. Je voudrais maintenant une méthode qui modifie ce tableau, qui le vide par exemple. Donc j'ai fait cela:

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 Mere
{
[...]
void  MethodImpl();
virtual void MethodDerivate() = 0;
virtual void ClearArray() = 0;
};
 
class Fille1 : public Mere
{
void MethodDerivate(){<mon code ici>}
void ClearArray(){m_array.clear();}
vector<int> m_array;
};
 
class Fille2 : public Mere
{
void MethodDerivate(){<mon code (différent) ici>}
void ClearArray(){}
};

Jusqu'ici tout va bien. Le problème c'est que maintenant, je voudrais appeler ClearArray depuis une méthode implémentée dans la classe Mere, ce qui nous donnerais quelque chose comme cela:

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 Mere
{
[...]
void  MethodImpl(ClearArray()); //modif ici
virtual void MethodDerivate() = 0;
virtual void ClearArray() = 0;
};

class Fille1 : public Mere
{
void MethodDerivate(){<mon code ici>}
void ClearArray(){m_array.clear();}
vector<int> m_array;
};

class Fille2 : public Mere
{
void MethodDerivate(){<mon code (différent) ici>}
void ClearArray(){}
};

Mais là, ça ne fonctionne pas. Ca plante à l'exécution:

R6025: pure virtual call.

J'espère avoir été clair, et si vous m'avez suivi, je serais bien aise de recevoir vos conseils avisés

merci.

[Matthieu Brucher]

Normalement, ça devrat marcher.
Mais les "()" à la place des "{}", c'est une erreur de recopie ou pas ?

[r0d]

Euh, lesquels?
J'ai bien peur que ce ne soit pas une erreur de copier/coller, mais une erreur "tout court"

[Matthieu Brucher]

Là où tu as indiqué que tu avais modifié le code de la classe mère.

[r0d]

Oui en effet, c'était une erreur. Et tu as raison, cela fonctionne, j'ai fait un test ce matin. Mon erreur est donc ailleurs.

pour ton aide

[r0d]

pour info, et on ne sait jamais, quelqu'un pourra s'intéresser au problème un jour, je poste le code que j'ai testé ce matin et qui fonctionne parfaitement:

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
/// fichier.h
#pragma once
#include <vector>
 
class CMere 
{
public:
    virtual ~CMere();
 
    virtual void f1() = 0;
    virtual void f2() = 0;
    void f3();
 
protected:
    std::vector<int> m_vector1;
};
 
 
class CFille1 : public CMere
{
public:
    CFille1();
    ~CFille1();
 
    void f1();
    void f2();
 
private:
};
 
 
class CFille2 : public CMere
{
public:
    CFille2();
    ~CFille2();
 
    void f1();
    void f2();
 
private:
    std::vector<int> m_vector2;
};

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
///fichier .cpp
#include "stdafx.h"
#include "fichier.h"
 
//////////////////////////////////////////////////////////////////////////
CMere::~CMere()
{
    m_vector1.clear();
}
 
 
void CMere::f3()
{
    f2();
}
 
//////////////////////////////////////////////////////////////////////////
 
CFille1::CFille1(){}
 
CFille1::~CFille1(){}
 
void CFille1::f1()
{
    m_vector1.push_back(2);
}
 
void CFille1::f2(){}
 
//////////////////////////////////////////////////////////////////////////
 
CFille2::CFille2(){}
 
CFille2::~CFille2()
{
    m_vector2.clear();
}
 
void CFille2::f1()
{
    m_vector1.push_back(2);
    m_vector2.push_back(3);
}
 
void CFille2::f2()
{
    m_vector2.push_back(4);
}

[r0d]

Pour info: en fait, mon erreur venait que fait que j'apellais ma fonction (f2() dans l'exemple ci-dessus) dans le destructeur de la classe mere.
Je ne comprend pas trop pourquoi...

[ep31]

Pour info: en fait, mon erreur venait que fait que j'apellais ma fonction (f2() dans l'exemple ci-dessus) dans le destructeur de la classe mere.
Je ne comprend pas trop pourquoi...

Dans ta classe mère, f2 était une fonction virtuelle pure et implémentée uniquement par les classes dérivées, c'était donc normal d'avoir ce type de message.

[r0d]

Dans ta classe mère, f2 était une fonction virtuelle pure et implémentée uniquement par les classes dérivées, c'était donc normal d'avoir ce type de message.

Oui mais pourquoi ai-je le droit de l'appeler dans les autres méthodes de ma classe mère, mais pas dans le destructeur?

[ep31]

Oui mais pourquoi ai-je le droit de l'appeler dans les autres méthodes de ma classe mère, mais pas dans le destructeur?

Si tu es dans une méthode quelconque (hors destructeur) de ta classe mère, la fonction f2() appelée sera celle de la classe dérivée. Par contre, dans le cadre de l'appel au destructeur de la classe mère, le destructeur de la classe dérivée est exécuté en premier, ce qui fait donc que l'objet this de la classe dérivée n'existe plus. Dans ce cadre-là, le destructeur de la classe mère n'aurait plus d'autre choix que d'exécuter le fonction f2 virtuelle pure.

[Matthieu Brucher]

Dans le constructeur et le destructeur de la classe mère, la seule chose qui existe est la classe mère.
Au début, à l'instanciation, la classe mère est crée, son constructeur est appelé. Le type de la classe est à ce moment celui de la classe mère.
Ensuite seulement le constructeur fils est appelé et l'objet devient du bon type.
Pour le destructeur, c'est exactement l'inverse.

-> il est très vivement déconseillé de faire appel à des fonctions virtuelles dans les constructeurs et les destructeurs. Ce livre http://c.developpez.com/livres/#L2744071447 donne des infos plus détaillées sur d'autres déconseils/interdits de ce type.
D'ailleurs dans ton cas, ta fonction virtuelle est en fait à appeler dans le destructeur de la classe fille et non dans le destructeur de a classe mère puisque l'objet à effacer est déjà détruit à ce moment.

[r0d]

Ok, c'est clair maintenant!
Vraiment

P.S: l'exemple que j'ai donné n'avait aucun sens, c'était juste pour comprendre la problématique.