[débutant] appel de la fonction d'une super-classe

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:

1 2 3 4 void B::Truc() { ((A*)this)->Truc(); }
Mais ca marche pas...

Quelqu'un sait comment faire ?

Merci

Code:

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

Code:

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() {}
};

Le pattern template method est pas mal quand on peut.

Code:

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()    { ... }
};

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

Citation:
Envoyé par Luc Hermitte
Le pattern template method est pas mal quand on peut.
Code:

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?

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:

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:

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 } };

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:

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:

1 2 3 4 void B::Truc() { __super::Truc(); }
un peu comme super en Java ou base en C#.