Templates oder abstracte Klasse

Hi,

ich habe folgende Situation.
Ich habe 3 Container Arten.

Array, List und Vector.

Alle haben die Methode

GetData( const Key& key  )

Nun habe ich eine Funktion die mit den Daten eines Containers arbeitet.
Wie ist es nun am geschicktesten, die Funktion zu machen.

So:

template< class T >
class Container
{
public:
    virtual ~Container() = 0;
    virtual T GetData( const Key& key );
};

template< class T >
class Array : public Container< T >;

template< class T >
class List : public Container< T >;

template< class T >
class Vector : public Container< T >;

template< class T >
void Function( Container< T >& container )
{
    container.GetData( key );
}

oder so:

template< class T >
class Array;

template< class T >
class List;

template< class T >
class Vector;

template< class T >
void Function( const T& container )
{
    container.GetData( key );
}

Beim ersten Beispiel geht man ja sicher, dass wirklich NUR Container angegeben
werden könne. Dafür trägt man die Polymorphie mit sich herum, was ein bischen Performance kostet?

Was ist besser bzw. üblicher?

( Die Funktion ist nur ein Beispiel, es geht nur darum, ob man mit
Vererbung oder Templates arbeiten sollte )

camper

Die erste Variante wird nur funktionieren, wenn man beim Funktionsaufruf den Templateparameter explizit angibt, da ein lvalue-List<T> eben kein Container<T> ist, sondern nur in ein solches konvertiert werden kann - da Container<T> ein deduzierbarer Kontext ist, aber für List,Array,Vector gerade kein Templateargument hergeleitet werden kann (bzw. für diesen Parameter die entsprechende Konvertierung unterdrückt wird).
Variante zwei kann man entsprechend anpassen, z.B.

template< class T, template<typename>class C>
typename enable_if<is_base_of<Container<T>,C<T> > >::type Function( const C<T>& container )
{
    container.GetData( key );
}