Question

请允许我给出一些背景知识。我有一个抽象类，Foo。

class Foo {
public:
    virtual void bar() = 0;
}

我有两个继承自这个类的类。

class FooOne : public Foo {
public:
    void bar();
}

和

class FooTwo : public Foo {
public:
    void bar();
}

现在在一个完全不同的类中，我想在一个函数中创建一个数组，该函数可以保存这两个类之一的实例。我遇到的问题是我不能创建一个像这样的动态类型的数组，可以吗？我已经习惯了Objective-C，我可以在其中创建id类型的对象。

理想情况下，这就是我所寻找的（伪代码）：

void someFunction(FooType type) {
    class aClass = (type == FooTypeOne ? FooOne : FooTwo);
    vector<aClass> container;

    // Do something with the container.
}

注意：我不能在这个项目中使用C ++ 11.

Answer 1

您可以在STL容器中使用智能指针：

Foo* MakeFoo(FooType type)
{
  switch(type)
  { 
  case FooTypeOne :
    return new FooOne();
    break;
  case FooTypeTwo :
    return new FooTwo();
    break;
  default:
    break;
  }
  return null;
}

void someFunction(FooType type) 
{
    std::vector<std::shared_ptr<Foo> > container;
    std::shared_ptr<Foo> f_ptr(MakeFoo(type));
    container.push_back(f_ptr);

    // Do something with the container.
    for(std::vector<std::shared_ptr<Foo> >::iterator iter = container.begin(); 
        iter != container.end(); iter++)
    {
       (*iter)->bar();  // call derived object's bar function respectively 
    }
}

当您使用C ++ 03时，shared_ptr在std::tr1

下可用

注意：您需要将虚拟析构函数添加到Foo

class Foo {
public:
    virtual ~Foo() {}
    virtual void bar() = 0;
};

否则，如果通过指向基类的指针删除派生类型的对象，则会出现未定义的行为。

Answer 2

我能想到的唯一简单易用的选择是模板。即如果你想避免像你说的那样指针。

template <typename FooType>
void SomeFunction() {
    vector<FooType> container;

    // Do something with the container.
}


void SomeFunctionCaller(){
...
    if(type == "FooOne")
        SomeFunction<FooOne>();
    else
        SomeFunction<FooTwo>();

}

但它与你的设计完全不同，不确定它是否合适。

编辑：如果您使用智能指针就可以了，那么这就是您的选择。

在运行时动态设置矢量类

2 个答案: