Je veut avoir une liste d'elements differents, par exemple de string bool et int.
J'ai donc ma classe GenericValue, utilisant polymorphisme (pour etre manipule comme simplement "Generic" ), et template pour eviter d'ecrire une classe fille par type que je mets dedans.
 

 
Donc l'idee est que je mets mes elements dans un vector disont.

 
Donc comme ca, ca marches.
Mais, si je veux mettre l'object lui meme dans mon vector et non un pointeur plus possible:
 

 
Compile pas, car il veut instancier Generic qui est virtuel pure, pour remplir le vector de valeur par defaut.
Seulement je veux que le destructeur de GenericValue<T> soit appele lors de la destruction d'un Generic, donc il me faut ce virtual pure.
 
Suis-je oblige du coup d'utiliser que des pointeurs sur Generic et jamais directement de reference?
Ou dois-je par exemple agrandir d'un mon vector pour y ajouter directement une instance de GenericValue<T> ? (mais dans ce cas il me semble que quand je redimm le vector d'un il cherche quand meme a creer une instance defaut de Generic)

Tu ne peut pas mettre dans un vecteur des objets de classe différentes, chaque classe peut avoir des objet de taille différente (dans ton cas spécifique comme les Generic<truc> ne contiennent qu'un pointeur, la taille de l'objet ne dépends pas du type truc), du coup les "cases" du vecteur devraient avoir des tailles différentes.  
 
Or derrière le vecteur y'a un simple tableau ala C, dans lequel toutes les cases font la même taille (c'est obligatoire, pour indexer la case n d'un tableau tu fais avancer un pointeur de n*(taille de la case)).

Merci de ta reponse
cependant je ne comprend pas quand tu dis:

 
Justement ici un GenericValue<string> a la meme taille qu'un GenericValue<int>, mais le compilo ne le sait pas en avance?
 
Je peux pas non plus avoir un vector<GenericValue>() vu que GenericValue<T> utilises un template.
 
Je pourrais utiliser un pointeur sur void pour eviter le template, mais je pourrais plus faire mon delete (car sur void*) dans mon destructeur.
 
 
Je sens que je vais devoir garder mes pointeurs, et donc gerer manuellement la memoire quand on vide cette liste.

Le polymorphime ça passe par les pointeurs ou les références. Comme les conteneurs STL sont orientés valeur, ça ne peut pas marcher.
 
Pour ce que tu fais en particulier, va voir chez boost (any, variant, etc).
 
Et des shared_ptr surtout

boost::variant

l'idee est d'avoir un truc un peu comme boost::variant en plus simple et sans utiliser aucune lib genre boost
 
merci des conseils tout de meme, je vais garder comme ca et utiliser pointeur seulement et donc ecrire un peu de code pour la memoire du coup

bah se priver de boost pour ecrire du caca est tout sauf productif