Discussion :

[Higestromm]

Bonjour,

Je me heurte à un probleme vraiment con mais je trouve pas ma solution.

J'ai une classe A et une classe B;
B hérite de A.

B surcharge un fonction virtuelle de A qui s'apelle Truc();

Quand je définit ma fonction Truc() dans B j'aimerais appeler Truc() de A.

j'ai essayer ca :

Code :

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

1
2
3
4
void B::Truc()
{
    ((A*)this)->Truc();
}

Mais ca marche pas...

Quelqu'un sait comment faire ?

Merci

[JolyLoic]

Code :

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

1
2
3
4
void B::Truc()
{
    A::Truc();
}

[zoubidaman]

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 A
{
protected:
        virtual Truc()
        {
                //blabla
        };
public:
        A() {}
};
 
class B : public A
{
private:
        Truc()
        {
                A::Truc();
                //blabla
        };
public:
        B() {}
};

[Luc Hermitte]

Le pattern template method est pas mal quand on peut.

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
struct A {
    void f() {
        code commun...
        int z = do_f1(42);
        code commun...
        do_f2();
    }
private:
    virtual int  do_f1(int) = 0;
    virtual void do_f2()    = 0;
};
 
struct B : A {
private:
    virtual int  do_f1(int) { ... }
    virtual void do_f2()    { ... }
};

[Higestromm]

Merc pour vos réponses... c'est horrible après un ptit séjour Java le trucs que l'on oublie

[zoubidaman]

Le pattern template method est pas mal quand on peut.

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
struct A {
    void f() {
        code commun...
        int z = do_f1(42);
        code commun...
        do_f2();
    }
private:
    virtual int  do_f1(int) = 0;
    virtual void do_f2()    = 0;
};
 
struct B : A {
private:
    virtual int  do_f1(int) { ... }
    virtual void do_f2()    { ... }
};

Ca oblige A à implémenter toutes les fonctions qui peuvent être appellées, et chaque fonction à être définie dans chacune des classes qui dérivent de A.

Ca me parait pas très adapté à son cas...

Je vois pas trop l'intérêt en fait de ce pattern... Tu l'utilises à quel moment?

[Laurent Gomila]

Moi je trouve au contraire ce design pattern très utile, ça permet d'une part de ne pas avoir des fonctions virtuelles qui doivent impérativement commencer ou finir par appeler la même fonction de la classe de base (un oubli est si vite arrivé), et d'autre part de centraliser la logique de code au sein de la classe mère et de ne déléguer aux dérivées que les parties qui leur sont vraiment spécifiques.

Un exemple tout bête :

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
class Control
{
public :
 
    virtual void OnEvent(...)
    {
         // Trucs communs à tous les types de contôles
    }
};
 
class Button : public Control
{
public :
 
    void OnEvent(...)
    {
         Control::OnEvent(...);
 
        // Trucs spécifiques aux boutons
    }
};

Et bien moi je préfère cette version :

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
class Control
{
public :
 
    void OnEvent(...)
    {
         // Trucs communs à tous les types de contôles
 
         ProcessEvent();
    }
 
private :
 
    virtual void ProcessEvent() = 0;
};
 
class Button : public Control
{
private :
 
    void ProcessEvent(...)
    {
        // Trucs spécifiques aux boutons
    }
};

[Aurelien.Regat-Barrel]

La question est, je pense, de savoir si c'est un code commun ou une implémentation par défaut. Dans le cas des events, souvent on souhaite pouvoir remplacer le traitement par défaut :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class MyWindow : public Window
{ 
public : 
    virtual void OnClose() 
    { 
         bool ok = MsgBox( "Voulez-vous vraiment quitter ?" );
         if ( ok )
         {
             Window::OnClose();
         }
    } 
};

Note que certains compilos offrent une extension à ce sujet, comme __super pour VC++.

Code :

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

1
2
3
4
void B::Truc() 
{ 
    __super::Truc(); 
}

un peu comme super en Java ou base en C#.