无继承多态性

Question

X：我有一组不相关的类似容器的对象（矢量、地图、树……）处理不同不相关类型的对象。这些容器中对象的生命周期在它们的某些子集之间共享。我有一个对象负责他们的同步。我能想到的同步类的最简单实现是有一个BaseContainerLike 指针向量，其中BaseContainerLike 将是一个为我要管理的所有类容器对象实现公共接口的类。但并非所有人都像容器一样。它们可以像容器一样使用，但是让它们从一个通用的基类继承感觉很奇怪，我担心它会非常强烈地结合我的设计。

所以我创建了一个像这样的ContainerLikeInterface 类：

struct ContainerLikeInterface {
template<T>
ContainerLikeInterface(T& t) 
 : create([](int i){ return t->create(i); }),    // this is just an example
   delete([](int i){ return t->delete(i); }) {}

std::function<void(int)> create;
std::function<void(int)> delete;
};

template<class T>
ContainerLikeInterface make_containerLikeInterface(T& t) {
  return ContainerLikeInterface(t);
}

这使我能够以非侵入性的方式轻松创建接口向量（我可以为不同类型的构造函数部分专门化）。我使用这种方法的代码比使用继承时稍快，但它需要更多的内存和更长的编译时间（但我不优先考虑编译时间）。但是，我不知道这种方法是否能很好地适应我的项目。而且我读过一些关于价值语义的文章，其中人们更喜欢将对象所有权转移到接口，所以我有以下问题：

• 这种方法的优缺点是什么？
• 从长远来看，这会给我带来一些问题吗？
• 我应该改用继承吗？
• 我应该以不同的方式实现它吗？
• 我应该改用库吗？ （boost::TypeErasure、adobe::poly 或 pyrtsa/poly）

Answer 1

您的基本想法（不需要继承）很好。我建议改用 Adob​​e.Poly。当您在每个单一操作中使用 1 个std::function 时，您有 N 种虚拟表（指针），以及可能的 N 堆分配（取决于是否可以应用 SBO（小缓冲区优化））。

您也很可能遇到对象生命周期管理问题。在您的实现中，您假设真实对象的寿命比“接口”长。迟早你会弄错的。这就是我鼓励采用value-semantic 方法的原因。 Adobe.Poly 为您提供。

使用 Adob​​e.Poly，您只能获得一个 vtable（指针）。它还实现了 SBO：可能不是单一分配。

我不一定会选择 Boost.TypeErasure。它需要学习另一种“语言”来指定接口，这种语言利用了大量的元编程，并且截至今天它还没有实现 SBO。

Adobe.Poly 没有很好的文档记录。有关如何使用它的示例，请参阅 this post。另外，请参阅this paper 了解它是如何实现的。

Answer 2

您的界面与在 Rust object system。经典的基于 VMT 的接口有一个指向对象的指针，该对象包含指向 VMT 的指针。你的有 2 个指针：一个指向对象，另一个指向方法表。它 [几乎] 看起来总是比具有您已经提到的缺点（内存使用等）的虚拟功能更强大 至于速度，std::function 使用标准分配器来保存指向t 的指针。如果你经常调用 ContainerLikeInterface 构造函数，它可能会导致性能下降，因为它需要在你的界面中为每个 std::function 至少分配一次，你可以为此编写自己的。

Answer 3

您实际上是在创建一个带有ContainerLikeInterface 接口的代理对象，该接口带有一个指向某些T 的指针或引用。

有一种方法可以避免创建代理，同时仍然使用无法派生ContainerLikeInterface 的标准容器。它可能被称为混合设计模式，并且在 C++11 中完美转发，它看起来像：

#include <vector>

struct IContainerLikeInterface
{
    virtual void create(int) = 0;
    virtual void erase(int) = 0;
};

template<class T>
struct ContainerLikeInterface : T, IContainerLikeInterface
{
    template<class... Args>
    ContainerLikeInterface(Args&& ...args) 
        : T(std::forward<Args>(args)...)
    {}

    // implement IContainerLikeInterface
    void create(int) override;
    void erase(int) override;
};

int main() {
    ContainerLikeInterface<std::vector<int> > v(10);
    v.size();
}

但是，它具有侵入性，因为所有有问题的容器声明，例如 std::vector<int>，都必须更改为 ContainerLikeInterface<std::vector<int> >。不过用法保持不变，因为ContainerLikeInterface<T> 是-a T。