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上有一个指针，你只能调用它的一个方法。在您的示例中，A :: func2（）没有任何意义

Answer 2

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

但是，func2确实不存在于A类中，所以即使指针是指向具有func2的类C的指针，您也将它作为指向A类的指针处理，因此您无法调用func2，因为func2 doest在A类的上下文中并不意味着什么。

Answer 3

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

console.log(formData)

变量也一样。现在，如果你打算调用A的func2，那么一切都不会发生。如果您有返回类型，则必须搜索更聪明的解决方案。

Answer 4

您的问题与存储指针的方式无关。问题只是A没有方法func2。

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

也会失败。

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

在向量中存储不同的子类

4 个答案: