模板中的多态类

Question

假设我们有一个类层次结构，其中有一个通用 Animal 类，该类有几个直接继承自它的类（例如 Dog、Cat 、马等）。

在此继承层次结构上使用模板时，仅使用 SomeTemplateClass 然后将 Dogs、Cats 和 Horses 推入此模板化对象是否合法？

例如，假设我们有一个模板化的 Stack 类，我们想要在其中托管各种动物。我可以简单地说一下Stack吗？ s；狗d; s.push(d);猫c; s.push(c);

Answer 1

如果否，则回答您的问题。但是您可以使用 SomeTemplateClass 并将派生类对象的指针传递给它。

例如，如果您有一个模板化的 Stack 类，您想要在其中托管各种动物。您可以简单地执行以下操作：

Stack<Animal*> s; 
Dog d; 
s.push(&d); 
Cat c; 
s.push(&c)

Answer 2

不，您必须使用指针，即 Stack（或某种智能指针）。原因是 Dog、Cat、Horse 等大小不一定相同，因为它们可能会添加成员变量。

容器可以分配仅足以存储动物的空间。如果 Dog 大于该值，容器将尝试复制构造一个 Dog，并将其推入太小的空间中，从而可能导致内存损坏。

Answer 3

Stack 和 Stack 是完全不同的类。

您甚至无法在 Stack 和 Stack 之间进行转换。

编辑：但正如 @Mihran 指出的，您可以尝试使用 Stack 代替 Stack

Answer 4

这取决于模板对传递的类型的用途。如果您指的是标准容器（例如 std::vector、std::map 等），那么答案是否定的。即使在您的类层次结构中，狗派生自动物，std::vector和 std::vector 之间也没有任何关系。

您不能将 Dog 放入 std::vector...C++ 使用复制语义，您会遇到所谓的“切片”，这意味着您的 Dog 实例将丢失任何不存在于Animal 基类中的成员。

然而，一般来说，模板当然很可能以不同的方式使用该类型，从而允许接受派生类的实例。例如，在以下代码中，模板 MethodCaller 可以使用类型实例化，但使用派生类型的实例并正确处理后期绑定分派。这是可能的，因为 MethodCaller 实例仅保存引用并且不复制该对象。

#include <stdio.h>

template<typename T>
struct MethodCaller
{
    T& t;
    void (T::*method)();
    MethodCaller(T& t, void (T::*method)())
        : t(t), method(method)
    {}
    void operator()() { (t.*method)(); }
};

struct Animal { virtual void talk() = 0; };
struct Dog : Animal { virtual void talk() { printf("Bark\n"); } };
struct Cat : Animal { virtual void talk() { printf("Meow\n"); } };
struct Crocodile : Animal { virtual void talk() { printf("??\n"); } };

void makenoise(Animal *a)
{
    MethodCaller<Animal> noise(*a, &Animal::talk);
    noise(); noise(); noise();
}

int main()
{
    Dog doggie;
    Cat kitten;
    Crocodile cocco;
    makenoise(&doggie);
    makenoise(&kitten);
    makenoise(&cocco);
}

也可以根据需要实现 Stack 类...

#include <vector>

template<typename T>
struct Stack
{
    std::vector<T *> content;
    ~Stack()
    {
        for (int i=0,n=content.size(); i<n; i++)
            delete content[i];
    }

    template<class S>
    void push(const S& s)
    {
        content.push_back(new S(s));
    }

    template<class S>
    S pop()
    {
        S result(dynamic_cast<S&>(*content.back()));
        content.pop_back();
        return result;
    }

private:
    // Taboo
    Stack(const Stack&);
    Stack& operator=(const Stack&);
};

int main()
{
    Dog doggie;
    Cat kitten;
    Crocodile cocco;

    Stack<Animal> s;
    s.push(doggie);
    s.push(kitten);
    s.push(cocco);

    Crocodile cocco2 = s.pop<Crocodile>();
    Cat kitten2 = s.pop<Cat>();
    Dog doggie2 = s.pop<Dog>();
}

请注意，在实现中我使用了 std::vector 来保存指针/strong> 对动物来说，因此可以避免切片问题。我一直在使用模板方法来接受推送调用中的派生类型。

另请注意，在弹出动物时，您必须提供类是什么以及是否是错误的类（例如，当堆栈顶部元素是 Dog 时，您弹出 Crocodile） ）你会在运行时得到一个 bad_cast 异常。