[c++] Type erasure and accessors

Question

Hi, I used type erasure pattern in C++, i.e I hide a template class with an abstract class

class Base{

  virtual ~Base(){}

 //pure virtual methods...
};

template<typename T>
class Derived : Base{

Derived<T>(){}
~Derived(){}

//public methods...

private :
vector<T> datas;

};

problem : if I want to retrieve or modify datas, I have to use the Base class

how do I défine the accessors getDatas() and SetDatas(vector datas) ?

Answer 1

You cannot define a SetData( vector ) since std::vector needs a type, and obiously you cannot define SetData( std::vector< T > ) in the Base if you have no definition for T.

So if you really need this and think this is the way to go, you'll have to look into type dispatching (or make a hack using void*). Boost uses type dispatching in some places, else google provides examples.

edit simple example of what it can look like; not really type dispatching but more straightforward

class Base
{
public:
  template< class T >
  bool SetData( const std::vector< T >& t )
  {
    return SetData( static_cast< const void* >( &t ), typeid( t ) );
  }

protected:
  virtual bool SetData( const void*, const std::type_info& ) = 0;
};

template< class T >
class Derived : public Base
{
protected:
  bool SetData( const void* p, const std::type_info& info )
  {
    if( info == typeid( std::vector< T > ) )
    {
      const std::vector< T >& v = *static_cast< const std::vector< T >* >( p );
      //ok same type, this should work
      //do something with data here
      return true;
    }
    else
    {
      //not good, different types
      return false;
    }
  }
};

Answer 2

Ultimately, the user of the class must know what T is in order to work with datas in your derived type, even if they are accessing it through the base type.

You may be able to set up a somewhat generic interface with a void*, but the user of your class will still have to match up a each class instance to the specific type, T. If T is int, users will have to know that collection is based on int.

If you want to store any type in the vector, without worrying about which instance is which type, you could make T void*. If you do this, you could even skip the template<typename T> part of derived. It could become a non-template class.

Answer 3

You're trying to implement type-erasure and then asking how you can make clients operate on the types that you're erasing. The pattern that you're deploying here is only appropriate if the derived classes of Base have operations in common that can be called without reference to the concrete type of data that they store. If there are no such common operations and the only semantically useful things for clients to do through your Base interface involve using the concrete types of the derived classes, then you won't be able to use this design.