парадигмы — методы C ++: стирание типа против чистого полиморфизма

Каковы преимущества / недостатки двух методов по сравнению? И что еще более важно: почему и когда один должен использоваться поверх другого? Это просто вопрос личного вкуса / предпочтения?

В меру своих способностей, я не нашел ни одного поста, который бы явно касался моего вопроса. Среди многих вопросов, касающихся фактического использования полиморфизма и / или стирания типов, следующие, по-видимому, наиболее близки или кажутся таковыми, но на самом деле они также не касаются моего вопроса:

C ++ -& CRTP. Тип стирание против полиморфизма

Обратите внимание, что я очень хорошо понимаю обе техники. Для этого ниже приведен простой, автономный рабочий пример, который я с радостью удалю, если сочту это ненужным. Тем не менее, пример должен прояснить, что означают эти два метода по отношению к моему вопросу. Я не заинтересован в обсуждении номенклатур. Кроме того, я знаю разницу между полиморфизмом во время компиляции и во время выполнения, хотя я не считаю, что это имеет отношение к вопросу. Обратите внимание, что мой интерес меньше к различиям в производительности, если таковые имеются. Тем не менее, если бы существовал поразительный аргумент в пользу того или другого, основанного на производительности, мне было бы интересно прочитать его. В частности, я хотел бы услышать о конкретных примерах (без кода), которые действительно работали бы только с одним из двух подходов.

Рассматривая приведенный ниже пример, одним из основных отличий является управление памятью, которое при полиморфизме остается на стороне пользователя, а при стирании типов аккуратно убирается, что требует некоторого подсчета ссылок (или повышения). Сказав, что, в зависимости от сценариев использования, ситуация для примера полиморфизма может быть улучшена путем использования интеллектуальных указателей с вектором (?), Хотя для произвольных случаев это может оказаться непрактичным (?). Другим аспектом, потенциально в пользу стирания типа, может быть независимость общего интерфейса, но почему именно это будет преимуществом (?).

Код, приведенный ниже, был протестирован (скомпилирован & запустить) с MS VisualStudio 2008, просто поместив все следующие кодовые блоки в один исходный файл. Он также должен компилироваться с gcc в Linux, или я надеюсь / предполагаю, потому что я не вижу причин, почему бы и нет (?) 🙂 Я разбил / разделил код здесь для ясности.

Эти заголовочные файлы должны быть достаточными, верно (?).

#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);
}