C++ 技术 : Type-Erasure vs. 纯多态性

Question

比较这两种技术的优点/缺点是什么？更重要的是:为什么以及何时应该使用一个而不是另一个？这只是个人品味/偏好的问题吗？

尽我所能，我还没有找到其他明确解决我问题的帖子。在有关多态性和/或类型删除的实际使用的许多问题中，以下似乎是最接近的，或者看起来如此，但它也没有真正解决我的问题:

C++ -& CRTP . Type erasure vs polymorphism

请注意，我非常了解这两种技术。为此，我在下面提供了一个简单、独立的工作示例，如果觉得不必要，我很乐意将其删除。但是，该示例应阐明这两种技术对我的问题的意义。我对讨论命名法不感兴趣。另外，我知道编译时和运行时多态性之间的区别，尽管我认为这与问题无关。请注意，我对性能差异的兴趣不大，如果有的话。但是，如果有一个基于性能的引人注目的论点，我会很好奇阅读它。特别是，我想听听实际上只能使用这两种方法之一的具体示例(无代码)。

看下面的例子，一个主要的区别是内存管理，对于多态性，它保留在用户端，而对于类型删除，它被巧妙地隐藏起来，需要一些引用计数(或提升)。话虽如此，根据使用场景，多态性示例的情况可能会通过使用带有 vector (?) 的智能指针来改善，尽管对于任意情况，这很可能证明是不切实际的 (?)。另一个可能支持类型删除的方面可能是通用接口(interface)的独立性，但为什么这会是一个优势(？)。

下面给出的代码已使用 MS VisualStudio 2008 进行了测试(编译和运行)，只需将以下所有代码块放入单个源文件即可。它也应该在 Linux 上使用 gcc 编译，或者我希望/假设，因为我看不出为什么不 (？) :-) 为了清楚起见，我在这里拆分/划分了代码。

这些头文件应该足够了，对吧(？)。

#include <iostream>
#include <vector>
#include <string>

简单的引用计数来避免提升(或其他)依赖。该类仅在下面的类型删除示例中使用。

class RefCount
{
  RefCount( const RefCount& );
  RefCount& operator= ( const RefCount& );
  int m_refCount;

  public:
    RefCount() : m_refCount(1) {}
    void Increment() { ++m_refCount; }
    int Decrement() { return --m_refCount; }
};

这是简单的类型删除示例/插图。它是从以下文章中复制和修改的。主要是我试图让它尽可能清晰和直接。 http://www.cplusplus.com/articles/oz18T05o/

class Object {
  struct ObjectInterface {
    virtual ~ObjectInterface() {}
    virtual std::string GetSomeText() const = 0;
  };

  template< typename T > struct ObjectModel : ObjectInterface {
    ObjectModel( const T& t ) : m_object( t ) {}
    virtual ~ObjectModel() {}
    virtual std::string GetSomeText() const { return m_object.GetSomeText(); }
    T m_object;
 };

  void DecrementRefCount() {
    if( mp_refCount->Decrement()==0 ) {
      delete mp_refCount; delete mp_objectInterface;
      mp_refCount = NULL; mp_objectInterface = NULL;
    }
  }

  Object& operator= ( const Object& );
  ObjectInterface *mp_objectInterface;
  RefCount *mp_refCount;

  public:
    template< typename T > Object( const T& obj )
      : mp_objectInterface( new ObjectModel<T>( obj ) ), mp_refCount( new RefCount ) {}
    ~Object() { DecrementRefCount(); }

    std::string GetSomeText() const { return mp_objectInterface->GetSomeText(); }

    Object( const Object &obj ) {
      obj.mp_refCount->Increment(); mp_refCount = obj.mp_refCount;
      mp_objectInterface = obj.mp_objectInterface;
    }
};

struct MyObject1 { std::string GetSomeText() const { return "MyObject1"; } };
struct MyObject2 { std::string GetSomeText() const { return "MyObject2"; } };

void UseTypeErasure() {
  typedef std::vector<Object> ObjVect;
  typedef ObjVect::const_iterator ObjVectIter;

  ObjVect objVect;
  objVect.push_back( Object( MyObject1() ) );
  objVect.push_back( Object( MyObject2() ) );

  for( ObjVectIter iter = objVect.begin(); iter != objVect.end(); ++iter )
    std::cout << iter->GetSomeText();
}

就我而言，这似乎使用多态实现了几乎相同的效果，或者可能不是(？)。

struct ObjectInterface {
  virtual ~ObjectInterface() {}
  virtual std::string GetSomeText() const = 0;
};

struct MyObject3 : public ObjectInterface {
  std::string GetSomeText() const { return "MyObject3"; } };

struct MyObject4 : public ObjectInterface {
  std::string GetSomeText() const { return "MyObject4"; } };

void UsePolymorphism() {
  typedef std::vector<ObjectInterface*> ObjVect;
  typedef ObjVect::const_iterator ObjVectIter;

  ObjVect objVect;
  objVect.push_back( new MyObject3 );
  objVect.push_back( new MyObject4 );

  for( ObjVectIter iter = objVect.begin(); iter != objVect.end(); ++iter )
    std::cout << (*iter)->GetSomeText();

  for( ObjVectIter iter = objVect.begin(); iter != objVect.end(); ++iter )
    delete *iter;
}

最后是一起测试以上所有内容。

int main() {
  UseTypeErasure();
  UsePolymorphism();
  return(0);
}

Answer 1

C++风格的基于虚拟方法的多态性:

1. 您必须使用类来保存您的数据。
2. 构建每个类时都必须考虑到您特定的多态性。
3. 每个类都有一个共同的二进制级依赖关系，这限制了编译器创建每个类的实例。
4. 您要抽象的数据必须明确描述一个接口(interface)，该接口(interface)描述您的需求。

基于 C++ 样式模板的类型删除(使用基于虚拟方法的多态性进行删除):

1. 你必须使用模板来谈论你的数据。
2. 您正在处理的每个数据 block 都可能与其他选项完全无关。
3. 类型删除工作在公共(public)头文件中完成，这会增加编译时间。
4. 每种删除的类型都有自己的实例化模板，这会使二进制大小膨胀。
5. 您要抽象的数据不必写成直接取决于您的需求。

现在，哪个更好？好吧，这取决于在您的特定情况下上述事情是好是坏。

作为一个明确的例子，std::function<...>使用类型删除，这允许它获取函数指针、函数引用、在编译时生成类型的一大堆基于模板的函数的输出、具有 operator() 的无数仿函数和 lambda。所有这些类型都彼此无关。而且因为它们与拥有 virtual operator() 无关。 , 当它们在 std::function 之外使用时context 他们所代表的抽象可以被编译掉。如果没有类型删除，您将无法做到这一点，而且您可能不想这样做。

另一方面，仅仅因为一个类有一个名为 DoFoo 的方法。 ，并不意味着他们都做同样的事情。有了多态性，它不仅仅是任何DoFoo您正在打电话，但 DoFoo从特定的界面。

至于您的示例代码...您的GetSomeText应该是 virtual ... override在多态的情况下。

没有必要仅仅因为您使用类型删除而引用计数。没有必要因为使用多态就不用引用计数。

您的Object可以换行T*就像你如何存储 vector在另一种情况下是原始指针的 s，手动销毁它们的内容(相当于必须调用 delete)。您的 Object可以包装 std::shared_ptr<T> ，在另一种情况下，您可以拥有 vector的 std::shared_ptr<T> .您的 Object可以包含 std::unique_ptr<T> ，等价于具有 std::unique_ptr<T> 的 vector 在另一种情况下。您的 Object的ObjectModel可以从 T 中提取复制构造函数和赋值运算符并将它们暴露给 Object , 为您的 Object 提供完整的值语义，对应于 vector的 T在你的多态情况下。