Vector de templates

Bonjour,

J'ai un problème concernant les templates. Je voudrais pouvoir stocker des pointeurs vers des objets templates hétérogènes dans un vector de la stl, mais je n'ai pas l'impression que cela soit possible...

Pour être un peu plus compréhensible, j'ai une classe template MaClasse :

Code:

---

1 2 3 4 5 6 7 8 9 10

template <typename T> class MaClasse : public Base { protected: T & value_;   public: MaClasse(const T & inValue) : value_(inValue) {} ... }

---

et j'aimerais pouvoir créer un vector de pointeurs de MaClasse, autrement dit avoir quelque chose comme

Code:

---

1 2 3 4 5 6 7

std::vector<MaClasse*> vec; int i = 10; string s = "toto";   vec.push_back(new MaClasse<int>(i)); vec.push_back(new MaClasse<string>(s));

---

La seule solution que j'ai trouvé, c'est d'utiliser un vector de Base *, mais ca ne m'arrange pas trop puisque d'autres classes dérivent de Base, et je ne veux pas d'elles dans mon vector.

Merci d'avance pour vos idées !

ton besoin n est pas tres clair ...

en tout cas une syntaxe telle quelle n est pas possible .


tu peux toujours inserer un nouvelle classe de base

class InserableBase : public Base {};

template<typename T> class MaClass : public InserableClass ....


vector<InserableClass *> ...


sinon, tu peux voir ce qui ce fait du cote boost::any , mais n empechera pas alors de bloquer des insertion

Ta base commune c'est Base, pas MaClasse.
std::vector<Base*> vec;

Je cromprend pas comment tu arrive a compiler ton code.
Tu declare une classe template donc pour l'utiliser tu doit la déclarer comme ceci :

Code:

---

MaClasse<int> m;

---

Donc pour définir un vecteur:

Code:

---

std::vector<MaClasse<double>> vec;

---

Non non, ce code ne compile pas, c'était juste pour expliquer ce que je voudrais avoir.

En fait, mon but est d'avoir un vector d'objets hétérogènes, pouvant contenir à la fois des objets de types de base (int, float, string) et des instances de classes. J'avais pensé à utiliser un vector<void *>, mais je ne pouvais alors pas récupérer le type de la classe pour le déréférencement du pointeur, mes objets pointés étaient inutilisables. Je me suis donc dit qu'utiliser une classe template pour stocker des références à ces objets pouvaient être une bonne idée, de cette façon le type était connu et je pouvais appeler des méthodes sans problèmes sur les objets contenus dans mon vector.

A priori je vais donc être obligé de passer par un vector<Base *>, je l'encapsulerais dans une classe pour empêcher les insertions non voulues.

Tu peux aussi faire le même principe que les VARIANT : Un gros union prenant en charge certains types (pas d'objet complexe par valeur), et un champ avec une énumération indiquant le type en cours...

si tu veux faire un container qui peut contenir n importe quoi , tu peux utiliser boost::any !!!

std::vector<boost::any> v;

v.push_back(any(3));

v.push_back(any(3.14));

v.push_back(any(new MaClass));

...

ton vecteur contiendra n importe quoi ... apres (de memoire du peut faire quelque chose comme)

any a = 3;

any_cast<int> (a) <-- te retourne 3 (ou lance une exception si a ne contient pas de donnee de type entier .

Comment ca marche ? (ca donne quelquechose comme ...)


class any {

private:

class content {

public:

content(const type_info & ti) : my_type(ti){}

virtual ~content(){}

const type_info &
};

template<typename T> class content_impl : public content {

public:

template<typename T> content_impl(T t) : content(typeid(T)) , value(t){}

T value;
};

public:

template<typename T> any(T t) : my_data(new content_impl<T>(t)){}

private:

content * my_data;

};


en gros any est un pointeur sur des donnees quelconques, et connait le type_info des donnees sur lesquels il pointe.

note : j espere un jour envoye une lib que je suis en train d ecrire sur le sujet

L'inconvénient de any, c'est qu'il utilise l'allocation dynamique pour tous les types, y compris un simple entier...

Quand l'ensemble des types est parfaitement connu : c'est boost::variant qu'il faut utiliser. On a la garantie qu'il ne contiendra que les types spécifiés.

http://www.boost.org/doc/html/variant.html

Citation:

---

Envoyé par Médinoc

L'inconvénient de any, c'est qu'il utilise l'allocation dynamique pour tous les types, y compris un simple entier...

---

absolument , c 'est le prix de la modularite (avec un cast plus sure que static_cast)


effectivement, apres la precedente piqure de rappel , boost::variant correspond probablement plus au besoiun

note : test a verifier !!!


void * operator new (size_t t){

printf("allocation de %d octets\n",t);

return malloc(t);
};

sous linux(gcc) , quand on fait quelquechose comme

Code:

---

1 2 3

for (int i = 0 ;i < 100 ; ++i)   new MaClass;

---

on s appercoit que les allocations sont pas aussi nombreuses que ce que l on attend (100) , mais de taille > sizeof(MaClass).

Ceci signifierai (a verifier) que le compilateur est capable d '"amortir" les allocations . Donc meme si any force une allocation , le cout n est pas necessairement prohibitif a l usage

Effectivement, après m'être renseigné sur variant, il s'avère que cela correspond exactement à ce dont j'ai besoin. Il me suffit de créer une interface dont hériterons les classes que j'accepte dans mon vector, et je peux alors créer le vecteur suivant :

Code:

---

std::vector<boost::variant< MonInterface*, int*, bool*, float*, std::string*> >

---

et utiliser un visiteur générique pour effectuer mes opérations sur les objets du vecteur. Et du coup je n'ai plus besoin de la classe template MaClasse.

Merci bien pour cette solution ! :merci:

Es-tu sûr que tu as besoin de pointeurs pour ton variant ?

J'ai besoin de pointeurs pour utiliser le polymorphisme. Du coup j'utilise aussi des pointeurs d'entier, de flottant etc pour pouvoir écrire un visiteur générique, par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10

class increment : public boost::static_visitor<> { public:   template <typename T> void operator()(T & operand) const { (*operand)++; } };

---

(Je n'ai pas testé, mais je pense que ça doit marcher...:question: )

T'as pas besoin de pointeurs pour les int/float/std::string.

Spécialise plutôt ton visiteur pour les pointeurs vers ton interface, et laisse le reste de manière générique.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class visiteur : public boost::static_visitor<> { public: void operator()(MonInterface* pI) const { // traitement }   template <typename T> void operator()(T & operand) const { // les autres types } };

---

PS : tu devrais faire un typedef pour ton variant...

Le fait d'utiliser la pile pour stocker l'objet pose d'autres problèmes.
Pour l'opérateur=, si les types ne concordent pas, il faut détruire l'ancien objet puis copier le nouveau.
Si la copie lève une exception, il faudrait pouvoir remettre l'ancienne valeur. Or, cette ancienne valeur a priori on l'a plus.
Il faut donc avoir un stockage double de l'objet, avec un booléen indiquant dans quel stockage est l'objet. (l'un des deux stockages est dans boost.variant à base d'allocation dynamique)