C++ 虚拟类的向量：指针是干净的方法吗？

注: 这几乎是该条目的重复：

我需要创建一个虚拟类的向量。以下是想法：

#include <vector>
using namespace std;

class VirtualFoo {
protected:
    VirtualFoo();
    virtual ~VirtualFoo();
public:
    virtual void doStuff()=0;
};

class ConcreteFoo: public VirtualFoo {
public:
    ConcreteFoo(double a);
    virtual ~ConcreteFoo();
    void doStuff();
private:
    double a;
};

class Foo {
public:
    Foo(std::vector<VirtualFoo> foos);
    virtual ~Foo();
    void doAllStuff();
protected:
    std::vector<VirtualFoo> foos;
};

#包括
使用名称空间std；
类VirtualFoo{
受保护的：
VirtualFoo（）；
virtual~VirtualFoo（）；
公众：
虚空doStuff（）=0；
};
类ConcreteFoo：公共VirtualFoo{
公众：
ConcreteFoo（双a）；
虚拟~ConcreteFoo（）；
void doStuff（）；
私人：
双a；
};
福班{
公众：
Foo（标准：向量foos）；
虚拟~Foo（）；
void doAllStuff（）；
受保护的：
std：：矢量foos；
};

我想这样使用它：

int main(int argc, char *argv[]){

    std::vector<ConcreteFoo> cfoos;
    cfoos.push_back(ConcreteFoo(1.0));
    cfoos.push_back(ConcreteFoo(2.0));

    Foo foo = Foo(cfoos);
    foo.doAllStuff();

}

intmain（intargc，char*argv[]）{
std：：向量cfoos；
cfoos.推回（ConcreteFoo（1.0））；
cfoos.推回（ConcreteFoo（2.0））；
Foo-Foo=Foo（cfoos）；
foo.doAllStuff（）；
}

当然，这不起作用，因为cfoos是VirtualFoo的载体，而不是ConcreteFoo

现在，如果我不使用VirtualFoo的向量，而是使用VirtualFoo*的向量，并将指针向后推到ConcreteFoo的实例，这似乎很好

---

只是，我不确定这是最干净的方式。这更像是我没有想到任何其他的方法。这样做可以吗？

带有

std:：vector cfoos指针的向量很好。您无法实例化抽象类，因此编译器无法实例化或专门化使用抽象类作为值的向量模板。用基类指针指向元素很好，这就是Liskov替换原理（）

我同意其他人的意见，共享指针是更好的解决方案，这样您就不必担心内存管理：

std::vector<shared_ptr<VirtualFoo>> cfoos;  
cfoos.push_back( shared_ptr<VirtualFoo> (new ConcreteFoo(1.0)) );   
cfoos.push_back( shared_ptr<VirtualFoo> (new ConcreteFoo(2.0)) );

std:：向量cfoos；
cfoos.push_back（共享的ptr（新的ConcreteFoo（1.0））；
cfoos.push_back（共享的ptr（新的ConcreteFoo（2.0））；
智能指针向量是一个干净的解决方案，具体的智能指针取决于您需要的所有权语义。@juanchopanza几乎可以肯定地分享了向量？@AlexChamberlain这一点我现在还不清楚，但我还没有喝过一杯咖啡。@AlexChamberlain我同意这一点（当我打字的时候，我砰砰地喝着咖啡）=P@WhozCraig同意什么？共享指针？通常，我们希望对象的生存期与容纳它们的容器的生存期绑定，因此唯一所有权更有意义（客户端毕竟不必拥有所有权）。