Vérifiez si la classe est dérivée d'une classe spécifique (compilation, exécution à la fois des réponses disponibles)

Vous pouvez utiliser dynamic_cast.

if (dynamic_cast<DerivedClass*>(ptr)) {
    std::cout << "Class is derived from DerivedClass.";
}

OriginalL'auteur sashoalm

Je pense que la réponse à cette question est très difficile. Bien sûr, il est std::is_base_of et dynamic_cast. Les deux vous fournir des informations très limitées. La troisième option est de surcharge de fonctions. Avec toutes ces techniques, vous pouvez choisir un chemin spécial dans votre code qui doit être exécuté.

std::is_base_of peut être interprétée dans un contexte booléen, et c'est un dérivé de la std::true_type ou std::false_type. Ce fait rend-il possible de l'utiliser comme paramètre d'une fonction et l'utilisation du temps de compilation polymorphisme via la fonction de surcharge. Ce premier exemple montre comment l'utiliser dans un contexte booléen, mais vous n'avez pas tout autre type spécifique de l'information. Si la compilation échoue dans la plupart des cas (voir ici pour une description plus détaillée):

template<class T>
void do_it1(T const& t) {
  if (std::is_base_of<T,derived1>::value) {
    //we have a derived1 
  } else {
    //we have a base 
  }
}

La deuxième version est simple surcharge de fonctions. Ici, le temps de compilation polymorphisme est utilisé, mais tous les runtime type d'information est perdue (à l'exception des fonctions virtuelles et dynamic_cast sont utilisés):

void do_it2(Base const& b) {
  //we have a base your algorithm for base here
}
void do_it2(Derived2 const& d) {
  //Derived algorithm here
}

Maintenant la troisième version combine à la fois:

template<class T>
void do_it3_impl(T const& t, std::true_type) {
  //here t will be of a type derived from derived1
}

template<class T>
void do_it3_impl(T const& t,std::false_type) {
  //here t will be of type not derived from derived1
}

template<class T>
void do_it_3(T const& t) {
  do_it3_impl(t, std::is_base_of<T,derived1>()); //here we forward to our impl
}

La troisième variante est normalement utilisé pour l'en-tête uniquement les bibliothèques qui n'utilisent pas le moteur d'exécution poylmorphism (recherche de std::advance pour un excample).

Maintenant polymorphisme d'exécution. Ici vous avez la dynaminc_cast variante:

void do_it4(Base const* ptr)
if (derived1 const* obj = dynamic_cast<derived*>(ptr)) {
  //here we have obj with type derived1*
} else {
  //here we have only base
}

Si cette variante n'est pas assez rapide, vous pouvez mettre en œuvre votre onw fonte à derived1:

class derived1;
class base {
  //as above
public:
  virtual derived1 const*  to_derived1() const {
    return 0;
  }
};

class derived1 
   : public base 
{
  //...
  virtual derived1 const*  to_derived1() const {
    return this;
  }
};

void do_it5(Base const* ptr)
if (derived1 const* obj = ptr->to_derived1() {
  //here we have obj with type derived1*
} else {
  //here we have only base
}

C'est rapide, mais elle s'adapte très bien pour seulement très peu de (environ 1) les classes dérivées.

Le dernier mais non le moins, vous devriez penser au sujet de votre conception de classe et deside quelles sont les méthodes pour faire de virtuel et de mettre en œuvre dans base, derived1 ou d'autres classes. Vous devriez certainement regarder pour modèle de stratégie.

OriginalL'auteur Jan Herrmann

Le compilateur acceptera uniquement les pointeurs vers les classes dérivées à partir de votre classe de base si vos fonctions de la bibliothèque prend des pointeurs de la classe de base. Ma réponse est avec une approche classique de type de sécurité de la poignée. De mon expérience, ce genre de type de vérification est assez. Ayant 25 ans d'expérience dans l'industrie, j'ai question de la nécessité de faire cette vérification. Peut-être une telle question fondamentale n'est pas la bienvenue? Je voudrais voir la justification d'avoir le besoin de faire ce genre de sortie. Je n'ai jamais eu à le faire. À l'opposé, c'est à dire une baisse de cast j'ai besoin assez fréquemment.

OriginalL'auteur Frodo