[LONG] Compatibilité std::string

Bonsoir,

J'ai quelques soucis de cohabitation de la classe "std::string" avec
le reste de mon code.

Soit le code suivant (non modifiable) :

#include <string>

// Classe abstraite pour tous les objets manipulés
struct node
{
virtual ~node() { }
};

// Classe abstraite pour une valeur
struct value : public node
{
};

// Classe abstraite pour un paramètre
struct param : public node
{
virtual const value& getValue() const = 0;
virtual void setValue(const value& val) = 0;
};

// Définition d'un paramètre générique (pour éviter d'avoir
// à réécrire une classe pour chaque type de valeur)
template <class TYPE>
struct genericParam : public node
{
const value& getValue() const
{ return (m_value); }
void setValue(const value& val)
{ m_value = dynamic_cast <TYPE&>(val); }

private:

TYPE m_value;
};

// Types de valeurs possibles
struct date : public value { };
struct charset : public value { };

// Types de paramètres possibles
struct dateParam : public genericParam <date> { };
struct charsetParam : public genericParam <charset> { };

J'aimerais ajouter un paramètre de type 'string' :

struct stringParam : public genericParam <std::string> { };

Evidemment, le code suivant ne compile pas ("std::string" n'hérite pas de
la classe "value") :

int main()
{
stringParam prm;
prm.getValue();
}

In member function `const value& genericParam<TYPE>::getValue() const
[with TYPE = std::string]': (...)
error: invalid initialization of reference of type 'const value&' from
expression of type 'const std::string'

Dès lors, pour résoudre mon problème, plusieurs solutions s'offrent à moi :

* créer une nouvelle classe "myString" héritant de la classe "std::string"
et de la classe "value" (héritage multiple) :

class myString : public std::string, public value

==> Abandonner l'idée car "std::string" n'est pas prévue pour être
dérivée (pas de destructeur virtuel).

* réécrire une classe "myString" implémentant toutes les fonctionnalités
de std::string (en gros, réinventer la roue...) :

==> Un peu lourd, solution de dernier recours.

* écrire une classe adapteur :

struct stringAdapter : public value
{
stringAdapter() { }
stringAdapter(const std::string& str) : m_str(str) { }

operator std::string() const { return (m_str); }

stringAdapter& operator=(const std::string& str) { /* ... */ }

// etc...

private:

std::string m_str;
};

struct stringParam : public genericParam <stringAdapter> { };

==> Fonctionne mais je ne trouve pas ça terrible (comprendre "propre")
ni pratique du point de vue de l'utilisation...

Qu'en pensez-vous ?

Voyez-vous d'autres solutions à me proposer ? (sachant que je cherche à ne
pas modifier les classes présentées en première partie : node, value, etc.)

Merci d'avance pour vos réponses.

Vincent

--
vmime, une bibliothèque C++ sous licence GPL pour parser et générer
des messages au format MIME : http://www.sourceforge.net/projects/vmime/