Considérez cette situation simple:fonction virtuelle C de pas appelé dans la sous-classe
A.h
class A {
public:
virtual void a() = 0;
};
B.h
#include <iostream>
class B {
public:
virtual void b() {std::cout << "b()." << std::endl;};
};
C.h
#include "A.h"
#include "B.h"
class C : public B, public A {
public:
void a() {std::cout << "a() in C." << std::endl;};
};
int main() {
B* b = new C();
((A*) b)->a(); // Output: b().
A* a = new C();
a->a(); // Output:: a() in C.
return 0;
}
En d'autres termes:
- A est une classe virtuelle pure .
- B est une classe sans super classe et une fonction virtuelle non pure.
- C est une sous-classe de A et B et remplace la fonction virtuelle pure de A.
Ce qui me surprend est la première sortie à savoir
((A*) b)->a(); // Output: b().
Bien que j'appelle() dans le code, b() est invoqué. Je suppose qu'il est lié au fait que la variable b est un pointeur vers la classe B qui n'est pas une sous-classe de la classe A. Mais le type d'exécution est toujours un pointeur vers une instance C.
Quelle est la règle C++ exacte pour expliquer cela, d'un point de vue Java, comportement bizarre?
Plus simplement: ** B sont pas des A ** Ils sont totalement indépendants les uns des autres, mais votre (pas bon à utiliser!) La distribution en style C ne s'en soucie pas non plus. 'dynamic_cast' traversera correctement votre hiérarchie. Lorsque vous générez des types de pointeurs indépendants, vous obtenez un comportement indéfini. Cela signifie que tout peut arriver, de ce qui semble fonctionner pour faire exploser votre ordinateur. – GManNickG
Ne pas oublier les démons nasaux. –