Heritage - surcharge

Version imprimable

Bonjour,
je dispose de:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
class A
{
    virtual void bla() {cout << "class A" << endl; }
};
 
class B: public A
{
    void bla()
    {
        ??-- ligne de code que je cherche --??
        cout << "class B" << endl;
    }
};
 
void main()
{
   B b;
   b.bla();
}

je veux que le résultat soit

Code:

1
2
3
 
class A
class B

oui, oui! je veux les deux.
en java, on ferait super.bla()
en C++, aucune idée

20/01/2006, 21h12
Selenite

Code:

A::bla();
20/01/2006, 21h17
Volune

A noter aussi la notation

Code:

this->A::bla();

et en dehors de la fonction (dans main() par exemple) :

Code:

b.A::bla();

ok, merci de la réponse, ca marche.
Autre question

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
class A
{
    virtual void bla() {cout << "class A" << endl; }
};
 
class B: public A
{
    virtual void bla() {cout << "class B" << endl; }
}; 
 
class C: public B
{
     C() {bla();}
};
 
void main()
{
   C c();
}

ca affiche quoi?

21/01/2006, 00h09
Raish
Salut!

Il suffit de faire:
Code:

1 2 3 4 A *aTest = new B; //Opérations delete aTest;
Quand on fait une construction comme ceci d'une classe polymorphique, le constructeur de la base est appelé avant celui de la classe derivée :) .
L'appel aux deconstructeurs se fait dans le sens inverse.

Note: Le design pattern template method est une autre approche à ton problème.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 struct A { void f() { std::cout << "A\n"; do_spe_f(); } private: void do_spe_f() = 0; // ou {} si A doit être instanciable }; struct B : A { private: void do_spe_f() { std::cout << "B\n"; } };
Quand à ta dernière question relative à ce qui est affiché, je dirais "class B". Même si C avait été dérivé en D et que tu construisais un D. Dans les constructeurs, la définition d'une fonction virtuelle appélée est celle du type officiel associé au constructeur en cours d'exécution, et non pas le type dynamique. D'où la règle répandue de ne jamais appeler de fonction virtuelle dans un constructeur (ou un destructeur).