vérifier l'héritage des types dynamiques de 2 variables - mais ils ne sont pas déclarés dans le champ

Question

Est-il possible de vérifier l'héritage entre le type sous-jacent (par exemple B et C) de 2 variables (par exemple b et c) si les deux ne sont pas déclarés dans le champ d'application ? Je pense que c'est impossible, mais je ne suis pas sûr.

test1.h: -

#include <vector> 
class A{}; 
std::vector<A*> test1(); 

test1.cpp: -

#include "Test1.h" 
class B : public A{}; 
class C : public B{}; 
class D : public A{}; 
std::vector<A*> test1(){ 
    A* b=new B();  A* c=new C();  A* d=new D(); 
    std::vector<A*> re; 
    re.push_back(b); re.push_back(c); re.push_back(d); 
    return re; 
} 

test2.cpp; Notez que, BCD ne sont pas connus ici (par la conception): -

#include "Test1.h" 
int test2(){ 
    std::vector<A*> v=test1(); 
    A* b=v[0]; A* c=v[1]; A* d=v[2]; 
    isInherit(b,c); //true 
    isInherit(c,d); //false 
    isInherit(b,d); //false 
} 

Si la réponse est oui, s'il vous plaît montrer comment le code bool isInherit(A* base,A* derive){}.

Notez que la modification class A n'est pas autorisée.
(Ainsi, un hack pour définir un non-static field of A = a value depending on type n'est pas autorisé.)

je peut l'utiliser comme certains types de magie noire à l'intérieur de mon code.

Answer 1

Trier par.

Il faut virtual bool A::baseOf(A const* derived) const = 0 et bool B::baseOf(A const* derived) const override { return dynamic_cast<B*>(derived); }

Cela vous permet maintenant de vérifier foo->baseOf(bar) quand tout ce que vous avez est la définition de A.

Les choses ne se décomposent si C oublie de passer outre B::baseOf.