Comment gérer les informations de type d'exécution dans la programmation générique C++ ?

Dans la programmation générique C++, deux méthodes sont fournies pour gérer les informations de type d'exécution (RTTI) : L'opérateur Dynamic_cast est utilisé pour convertir un pointeur ou une référence de classe de base en un pointeur ou une référence de classe dérivée. L'opérateur typeid renvoie les informations de type d'un objet et le nom du type peut être obtenu via sa fonction membre name(). RTTI, bien que pratique, entraîne une surcharge supplémentaire et n'est donc recommandé qu'en cas de besoin, en gardant à l'esprit les problèmes de compatibilité binaire qu'il peut entraîner.

Gestion des informations de type d'exécution (RTTI) dans la programmation générique C++

Dans la programmation générique C++, nous avons souvent besoin d'obtenir les informations de type d'objets ou de variables de référence au moment de l'exécution. C++ fournit un mécanisme RTTI (Runtime Type Information) à cet effet.

Utilisation de Dynamic_cast

L'opérateur dynamic_cast est utilisé pour convertir un pointeur ou une référence de classe de base en un pointeur ou une référence de classe dérivée. Si la conversion réussit, elle renvoie un pointeur ou une référence à la classe dérivée ; sinon, nullptr est renvoyé. dynamic_cast 运算符用于将一个基类指针或引用转换为派生类指针或引用。如果转换成功，它返回派生类的指针或引用；否则，返回 nullptr。

class Base { };
class Derived : public Base { };

int main() {
  Base* base_ptr = new Derived();

  // 检查 base_ptr 是否指向 Derived 对象
  Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
  if (derived_ptr != nullptr) {
    // 转换成功，base_ptr 指向 Derived 对象
  }
}

使用 typeid

typeid 运算符返回对象的类型信息，该类型信息是一个 std::type_info 对象。可以使用 name() 成员函数获取类型名称，可以使用 before() 和 after()

class Base { };
class Derived : public Base { };

int main() {
  Base obj;
  std::cout << typeid(obj).name() << std::endl; // 输出：Base

  // 检查 obj 是否属于 Derived 类型
  if (typeid(obj).before(typeid(Derived))) {
    std::cout << "obj is not a Derived object" << std::endl;
  }
}

Utilisez l'opérateur typeid

typeid pour renvoyer les informations de type de l'objet, qui est un objet std::type_info. Les noms de types peuvent être obtenus à l'aide de la fonction membre name(), et les types peuvent être comparés à l'aide des fonctions membres before() et after(). .

class Shape {
public:
  virtual void draw() = 0;
};

class Circle : public Shape {
public:
  void draw() override {
    std::cout << "Drawing a circle" << std::endl;
  }
};

class Rectangle : public Shape {
public:
  void draw() override {
    std::cout << "Drawing a rectangle" << std::endl;
  }
};

class Triangle : public Shape {
public:
  void draw() override {
    std::cout << "Drawing a triangle" << std::endl;
  }
};

int main() {
  std::vector<Shape*> shapes{new Circle, new Rectangle, new Triangle};

  for (auto shape : shapes) {
    // 使用 RTTI 获取形状类型
    std::cout << "Drawing a " << typeid(*shape).name() << std::endl;

    // 根据类型调用相应的方法
    shape->draw();
  }
}

Remarques sur l'utilisation de RTTI

RTTI entraîne une surcharge supplémentaire, il est donc recommandé de ne l'utiliser qu'en cas de besoin. RTTI peut provoquer des problèmes de compatibilité binaire, alors soyez prudent lorsque vous utilisez RTTI dans des bibliothèques.

Cas pratique

Scénario :

Il existe un ensemble de formes (telles que des cercles, des rectangles et des triangles) qui doivent effectuer différentes opérations en fonction de leurs types.

🎜Code : 🎜🎜

Drawing a Circle
Drawing a Rectangle
Drawing a Triangle

🎜Sortie : 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!