c++ - C++中的向下转换继承

Question

我有一个类叫 Animal

class Animal
{
    std::string name;
 public:

    Animal(string n)
    {
        name = n;
    }

    string getname()
    {
        return name;
    }
};

和两个继承类 Cat 和 Dog

class Cat : public Animal
{
public:
    Cat(string name):Animal(name)
    {}
};

class Dog : public Animal
{
public:
    Dog(string name):Animal(name){}
};

我有一个名为 AnimalQueue 的类，其中包含 2 个列表，猫列表和狗列表

class AnimalQueue
{
    std::list<Cat*> cats;
    std::list<Dog*> dogs;

public:

    void Enqueue(Animal a)
    {
        if(a.getname().compare("Cat") == 0)
        {
            // what should i do here
        }
        else
        {
            // what should i do here
        }
    }

};

我想要的是，当我输入 cat 时，它应该转到 cat 列表，并且在 Enqueue 函数中也与 dog 相同。我不确定它是如何工作的，我如何从 Animal 类型转换为 Cat 或 Dog。我试过了

Cat *c = (Cat*) &a; 

但是它不起作用。

int main()
{
    string name = "Cat";
    Cat c(name);

    name = "Dog";
    Dog d(name);

    AnimalQueue aq;
    aq.Enqueue(c);
    aq.Enqueue(d);
}

这是工作代码，您可以在编辑器中复制粘贴。您可以更改 Animal 的签名或任何您想要的签名，这样有助于使我对继承中的类型转换的概念更加清晰。

Answer 1

作为引用，下面是这段代码在 C++ 中的样子:

#include <string>
#include <utility>
#include <vector>

class Animal
{
    std::string name_;

public:
    explicit Animal(std::string name) : name_(std::move(name)) {}
    virtual ~Animal() {}
};

class Cat : public Animal { using Animal::Animal; };
class Dog : public Animal { using Animal::Animal; };

class AnimalQueue
{
    std::vector<Cat> cats_;
    std::vector<Dog> dogs_;

public:
    void Enqueue(Animal const & animal)
    {
        if (Cat const * p = dynamic_cast<Cat const *>(&animal))
        {
            cats_.push_back(*p);
        }
        else if (Dog const * p = dynamic_cast<Dog const *>(&animal))
        {
            dogs_.push_back(*p);
        }
        else
        {
            // discarding unrecognized animal
        }
    }
};

用法:

AnimalQueue q;
q.Enqueue(Dog("dog"));
q.Enqueue(Cat("cat"));

注意事项:

C++ 基础:

• 不要说using namespace std .
• 选择的容器是std::vector , 不是 std::list .
• 避免隐式转换。一切都是explicit除非另有要求。
• string-sink 构造函数从它的参数移动。
• 为类数据成员采用系统的命名约定。
• 不需要大量的局部变量；您可以将任意表达式放入函数调用中。
• 出于懒惰的原因，我的具体类继承了构造函数。在真实环境中，您可能需要编写自己的构造函数。

多态性:

• 多态基类有一个虚析构函数。
• 当参数作为指针或对基础子对象的引用传递时，可以使用多态性。

高层设计:

• 正如所写，似乎没有理由拥有多态基础，因为您的整个代码都是静态的。几个不同的重载(对于 Cat 和 Dog )会更合适。
• 当直到运行时才知 Prop 体类型时，需要多态基础。在那种情况下，您将没有具体类型的变量，您将需要动态创建对象。发生这种情况时，您将希望绕过 std::unique_ptr<Animal> ，并且必须调整动态类型转换。