为什么我们不能声明 std::vector？

Question

在花了相当长的时间进行 C# 开发后，我注意到，如果您声明一个抽象类以将其用作接口，则无法实例化该抽象类的向量来存储子类的实例。

#pragma once
#include <iostream>
#include <vector>

using namespace std;

class IFunnyInterface
{
public:
    virtual void IamFunny()  = 0;
};

class FunnyImpl: IFunnyInterface
{
public:
    virtual void IamFunny()
    {
        cout << "<INSERT JOKE HERE>";
    }
};

class FunnyContainer
{
private:
    std::vector <IFunnyInterface> funnyItems;
};

声明抽象类向量的行在 MS VS2005 中导致此错误：

error C2259: 'IFunnyInterface' : cannot instantiate abstract class

我看到一个明显的解决方法，即将 IFunnyInterface 替换为以下内容：

class IFunnyInterface
{
public:
    virtual void IamFunny()
    {
        throw new std::exception("not implemented");
    }
};

这是 C++ 方面可接受的解决方法吗？ 如果没有，是否有像 boost 这样的第三方库可以帮助我解决这个问题？

感谢您阅读本文！

安东尼

Answer 1

您无法实例化抽象类，因此抽象类向量无法工作。

但是，您可以使用指向抽象类的指针向量：

std::vector<IFunnyInterface*> ifVec;

这也允许您实际使用多态行为 - 即使该类不是抽象的，按值存储也会导致 对象切片。

Answer 2

您无法创建抽象类类型的向量，因为您无法创建抽象类的实例，并且 C++ 标准库容器（如 std::vector ）存储值（即实例）。如果你想这样做，你将必须创建一个指向抽象类类型的指针向量。

您的解决方法将不起作用，因为虚拟函数（这就是您首先需要抽象类的原因）仅在通过指针或引用调用时才起作用。您也无法创建引用向量，因此这是必须使用指针向量的第二个原因。

您应该意识到 C++ 和 C# 几乎没有共同点。如果您打算学习 C++，您应该将其视为从头开始，并阅读良好的专用 C++ 教程，例如 Accelerated C++，作者：Koenig 和 Moo。

Answer 3

在这种情况下，我们甚至不能使用这样的代码：

std::vector <IFunnyInterface*> funnyItems;

或者

std::vector <std::tr1::shared_ptr<IFunnyInterface> > funnyItems;

因为FunnyImpl和IFunnyInterface之间不存在IS A关系，并且由于私有继承，FunnyImpl和IFunnyInterface之间不存在隐式转换。

您应该按如下方式更新您的代码：

class IFunnyInterface
{
public:
    virtual void IamFunny()  = 0;
};

class FunnyImpl: public IFunnyInterface
{
public:
    virtual void IamFunny()
    {
        cout << "<INSERT JOKE HERE>";
    }
};

Answer 4

传统的替代方案是使用指针向量，如前所述。

对于那些欣赏的人来说，Boost 附带了一个非常有趣的库：Pointer Containers，它非常适合该任务，并将您从指针隐含的各种问题中解放出来：

• 生命周期管理
• 双重迭代器的解引用

请注意，无论是在性能还是接口方面，这都明显优于智能指针的向量。

现在，有第三种选择，那就是改变你的层次结构。为了更好地隔离用户，我多次看到使用了以下模式：

class IClass;

class MyClass
{
public:
  typedef enum { Var1, Var2 } Type;

  explicit MyClass(Type type);

  int foo();
  int bar();

private:
  IClass* m_impl;
};

struct IClass
{
  virtual ~IClass();

  virtual int foo();
  virtual int bar();
};

class MyClass1: public IClass { .. };
class MyClass2: public IClass { .. };

这非常简单，是通过 Strategy 模式丰富的 Pimpl 习惯用法的变体。

当然，它仅在您不希望直接操作“真实”对象并且涉及深度复制的情况下才有效。所以这可能不是你所希望的。

Answer 5

因为要调整向量的大小，您需要使用默认构造函数和类的大小，这反过来又要求它是具体的。

您可以按照其他建议使用指针。

Answer 6

std::vector 将尝试分配内存来包含您的类型。如果您的类是纯虚拟的，则向量无法知道它必须分配的类的大小。

我认为通过您的解决方法，您将能够编译一个 vector 但您将无法在其中操作unnyImpl。例如，如果 IFunnyInterface （抽象类）的大小为 20（我真的不知道），而FunnyImpl 的大小为 30，因为它有更多的成员和代码，那么您最终将尝试将 30 放入 20 的向量中。

解决方案是使用“new”在堆上分配内存并将指针存储在vector中

Answer 7

我认为这个真正令人悲伤的限制的根本原因是构造函数不能虚拟。因此，编译器无法生成在编译时不知道对象时间的情况下复制对象的代码。