Klassen von STL-Containern ableiten

Hallo,

ist es eigentlich üblich eine Klasse von einer STL-Containerklasse abzuleiten
(z.b. von std::string) um seine eigenen Zusatzfunktionen zu implementieren,
oder sollte man lieber den string zum Member machen und die Methoden des STL-Containers wrappen?

Beispiel:

class MyString : public std::string
{
   MyString() {}

   void toLower();
   void toUpper();
};

oder:

class MyString
{
   MyString() {}

   void toLower();
   void toUpper();

   size_t size() const
   {
      return m_str.size();
   }

private:
   std::string m_str;  
};

Gibst es bei der ersten Variante probleme z.B. mit virtuellen Destruktoren?

Wie löst ihr solche Aufgaben?

Freue mich über Antworten.
Gruß

DrGreenthumb

STLNewbee schrieb:

Wie löst ihr solche Aufgaben?

void toupper(string&);
void tolower(string&);

Problem beim Ableiten ist, dass die STL-Klassen keine virtuelle Destructoren haben und somit deine abgeleiteten nicht aufgerufen werden. Wenn du also auf deinen Destructor verzichten kannst, dann kannst du ableiten. Ansonsten müsstest du die zweite Variante nehmen.

Shade Of Mine

ich würde es mit layering lösen. also std::string member in meiner klasse.
uU auch private vererbung - das ist ja quasi das selbe.

public ableiten hat dann sinn, wenn man manchmal doch den 'alten' std::string braucht (zB wegen kompatibilitaet zu einer bestimmten API...)

allerdings muss man dann aufpassen, dass man die strings nicht polymorph verwendet - was man aber sowieso nie machen würde, da es sich um 'value objekte' handelt.

Marc++us

Problem beim Ableiten von STL-Klassen ist auch, daß diese ja so einige 100 (naja) Konstruktoren haben, die müßte man für volle Kompatibilität alle nachbilden. Ist ein ziemlich mühsames Geschäft.

Demnach ist wohl eine Orientierung an <algorithm> sinnvoll und daher diese Erweiterung ganz ähnlich in globale Funktionen packen.