了解 C++ 中子类的类

Question

我至少有 7 年没有接触过 C++ 了，突然间我深深地投入到了一个 C++ 项目中。我想要一些关于以下方面的指导：

我有一个名为 Animal 的类，我有 3 个继承自 Animal 的类：Cat、Dog 和 Bird。我创建了一个列表对象并使用它来存储动物类型。

此列表可以包含 Cats Dogs 和 Birds，当我遍历此 Animals 列表时，我想知道每个 Animal 的直接类型（无论是 Cat、Dog 还是 Bird）。

当我说typeid(animal).name(); 时，它给了我动物，这是真的，但我想知道是什么样的动物。

有什么想法吗？？我应该使用枚举吗？？

Answer 1

你几乎肯定不想知道。您应该做的是声明为与这些动物交互的虚拟适当方法。

如果您需要专门对它们进行操作，您可以使用访问者模式来传递访问者对象或在每个具体类中处理正确的数据。如果您坚持使用标签（我强调这是第三种选择 - 其他两种解决方案将使您的代码更清晰），请使用名为 classname 的虚拟方法返回类型标识符（无论是作为字符串还是 int 或任何）。

如果你有一个对象类型的数组，而不是指针类型，还要注意关于切片的要点。如果你 7 年没有使用过 C++，你可能没有意识到模板使用的增长使语言变得更好。查看 boost 之类的库，看看可以做什么，以及模板如何让您编写类型推断的通用代码。

Answer 2

Dog* dog = dynamic_cast<Dog*>(myAnimalPointer);
if (dog == NULL)
{ 
    // This animal is not a dog.
}

Answer 3

需要知道特定的具体对象类型通常是 C++ 中的一种设计味道，所以我建议您不要尝试这样做。

相反，在Animal 中创建一个抽象（纯虚拟）接口，描述您希望您的动物拥有的功能。然后，您可以利用动态调度来调用该功能，甚至不需要知道对象的动态类型。如果需要，您始终可以在子类中创建私有的非虚拟辅助函数。

还请注意，您需要通过（智能）指针将Animals 存储在容器中，而不是按值存储。如果您按值存储它们，它们将在插入列表时全部被切片，从而丢失动态类型信息。

正如@Marcin 指出的那样，如果您确实需要在特定子类上调用特定方法，则使用访问者模式进行双重调度可能是一种更好的方法。

Answer 4

根据具体代码typeid 返回不同的东西。另外name() 可以返回任何内容（包括将首字母变为大写或删除 *），它仅用于调试。现在我有几个不同的可能答案typeid(animal).name() 可以返回。

版本 1 animal 是一个类名：

struct animal {
    virtual ~animal() {}
};

struct dog 
    : animal
{};

struct cat
    : animal
{};

struct bird
    : animal
{};

int main() {
    std::cout << typeid(animal).name() << std::endl; // animal
    return 0;
}

版本 2 animal 是 Animal 的 typedef：

struct Animal {
};

struct Dog 
    : Animal
{};

struct Cat
    : Animal
{};

struct Bird
    : Animal
{};

int main() {
    typedef Animal animal;
    std::cout << typeid(animal).name() << std::endl; // Animal
    return 0;
}

Vesion 3 animal 是一个指针：

struct Animal {
};

struct Dog 
    : Animal
{};

struct Cat
    : Animal
{};

struct Bird
    : Animal
{};

int main() {
    Dog d;
    Animal* animal=&d;
    std::cout << typeid(animal).name() << std::endl; // Animal*
    return 0;
}

版本 4 animal 是一个对象：

struct Animal {
};

struct Dog 
    : Animal
{};

struct Cat
    : Animal
{};

struct Bird
    : Animal
{};

int main() {
    Animal animal;
    std::cout << typeid(animal).name() << std::endl; // Animal
    return 0;
}

版本 6 animal 是对非多态对象的引用：

struct Animal {
};

struct Dog 
    : Animal
{};

struct Cat
    : Animal
{};

struct Bird
    : Animal
{};

int main() {
    Dog d;
    Animal& animal=d;
    std::cout << typeid(animal).name() << std::endl; // Animal
    return 0;
}

版本 7 animal 是对多态对象的引用：

struct Animal {
  ~virtual Animal() {}
};

struct Dog 
    : Animal
{};

struct Cat
    : Animal
{};

struct Bird
    : Animal
{};

int main() {
    Dog d;
    Animal& animal=d;
    std::cout << typeid(animal).name() << std::endl; //Dog
    return 0;
}

正如其他人所写，最好不要依赖name()。但是如果没有一些代码，就很难说什么是正确的。

Answer 5

由于列表可以包含任何类型的动物，我将假设它是一个指针列表。 In such case typeid will consider the most derived type of the object if you pass it the dereferenced pointer.

typeid(*animal).name();

就是你要找的。​​p>

Answer 6

在每个子类中实现一个函数 name()。

Answer 7

如果不使用特殊技巧为您的基类提供有关派生类型的信息，它就无法知道实例是什么子类型。正如@Joachim Wuttke 建议的那样，最简单的方法是创建一个虚拟函数，强制派生类实现 name() 方法。

但是，如果您想变得更高级一点，奇怪的重复出现的模板部分 CRTP 提供了一个更优雅但深奥的解决方案：

#include <typeinfo>
#include <string>
#include <iostream>


template <class T>
class Animal {
public:
    virtual ~Animal() {};  // a base class
    std::string name() {
        return typeid(T).name();
    }
};


class Cat: public Animal<Cat> {

};

class Dog: public Animal<Dog> {

};

int main( int argc, char* argv[] ){
    Cat c;
    Dog d;

    std::cout << c.name() << std::endl;
    std::cout << d.name() << std::endl;

}

结果（g++）：

3Cat
3Dog

结果（vs2008）：

class Cat
class Dog

请注意，正如其他人所说，typeid 的名称修饰依赖于平台/编译器，因此要从上面的名称返回到类，您必须实现一个依赖于平台/编译器的去修饰例程。不是特别困难，但它确实使解决方案失去了优雅。