在vector中存储不同的子类

Question

我试图在unique_ptr < BaseClass >的向量中存储不同的子类。当子类是一层深度时，这种方法似乎有效，但当子类是两层深度时就失败了。

这就是我要做的

#include <iostream>
#include <memory>
#include <vector>
using namespace std;
class A
{
    int foo;
 public:
    explicit A(int bar)
    {
        foo = bar;
    }
    int getFoo()
    {
        return foo;
    }
    virtual void func1() = 0;
};
class B : public A
{
 public:
    using A::A;
};
class C : public A
{
 public:
    virtual void func2() = 0;
    using A::A;
};
class D : public B
{
 public:
    using B::B;
    void func1()
    {
        cout << "D1" << endl;
    }
};
class E : public C
{
 public:
    using C::C;
    void func1()
    {
        cout << "E1" << endl;
    }
    void func2()
    {
        cout << "E2" << endl;
    }
};
int main()
{
    vector<unique_ptr<A> > vec;
    vec.emplace_back(new D(1));
    vec.emplace_back(new E(2));
    vec[0]->func1(); // Okay
    vec[1]->func1(); // Okay
    vec[1]->func2(); // error: 'class A' has no member named 'func2'
    E foo(3);
    foo.func2(); // Okay
    return 0;
}

Answer 1

由于您只存储指向类A的指针，因此如果func1被重载，则可以调用它。

但是，在类A中不存在func2，所以即使指针是指向具有func2的类C的指针，您也将其作为指向类A的指针来处理，因此您不能调用func2，因为func2在类A的上下文中没有任何意义。

Answer 2

你必须看看多态性是如何工作的:如果你在a上有一个指针，你只能调用它的一个方法。在您的示例中，A::func2()没有意义

Answer 3

在多态性中，您需要实现稍后将在实际指向的类中使用的所有方法:

class A
{
public:
    virtual void func();
    virtual void func2();
}
class B : public A
{
public:
    void func();
}
class C : public A
{
public:
    void func2()
}

变量也是如此。现在如果你调用func2 (A)实际上什么都不会发生。如果你有返回类型，你必须寻找一个更聪明的解决方案。

Answer 4

您的问题与您存储指针的方式无关。问题很简单，A没有func2方法。

  A* p = new E(2);
  p->func2();

也会失败。

需要将func2添加到A或将p强制转换为E指针