Discussion :

[DEVfan]

Bonjour,

Pas de solution a priori dans le reste du forum. Pourtant ce que je souhaite faire me parait quelque chose de basique :

Objectif : créer un tableau de type choisi par l'utilisateur.

Idée de base :
_1) le template ... ca marche mais il faut préciser le type au moment de la création.
_2)une classe contenant un pointeur void* ... pour le polymorphisme.
Pb : comment donner l'argument dans le constructeur??
Je pourrais faire un mappage mais je serais limité à ma connaissance et ce n'est pas très intuitif. Le typeid ne connait que le nom du type mais le type est caché! Alors que faire?

Avez-vous une solution simple?

Merci d'avance et bon noël!

[Volune]

Bonjour,

Objectif : créer un tableau de type choisi par l'utilisateur.

C'est assez léger comme objectif.
Voici des solutions presques aléatoires pour y répondre, mais qui ne seront pas forcément adapté à ce que tu veux en faire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
const int taille = 12; void * tab[taille];
std::vector<void *> tab;
std::vector<boost::any> tab;
boost::ptr_vector<TypeDeBase> tab;

Il y a plusieurs questions pour tenter de préciser ton objectif :
- La taille du tableau est elle fixe ?
- Quand la taille du tableau est-elle connue ?
- Les objets contenus par le tableau sont ils tous du même type ?
- Quand connait-on le type de chaque élément du tableau ?
- Est-ce que le tableau doit gérer la durée de vie des objets qu'il contient ?
- ...

[Syrmonsieur]

En effet c'est problèmatique. Il faut lier le temps de compilation avec le temps d'execution.

Si le nombre de choix de type est fini, tu peut faire un template, l'instancier explicitement pour chacun des choix et faire une map entre, par exemple, le nom du type choisi et une fonction paramétrée par le type qui gerera la création, le remplissage et la gestion du tableau.
L'avantage est que tu conserve l'information de type.
En revanche tu génère beaucoup de code, et sans doute pour rien.
Enfin, c'est quand même très crade.

Regarde le code de boost. smart_cast pourra peut-être t'aider. Ce fichier est utilisé par boost::serialization et boost::archive, fais y aussi un tour (attention aux migraines)

Pour moins se prendre la tête, tu peut prendre une solution plus runtime et imposer que le type soit dérivé d'une classe de base polymorphique. Mais si j'ai bien compris ta question, ton but est de stocker un type quelconque...

Enfin est-ce que tu en as vraiment besoin ? pourquoi veut tu faire ça ?

[DEVfan]

"C'est assez léger comme objectif."
->oui je sais c'est pour ça que je m'étonne de n'avoir rien trouvé.

"const int taille = 12; void * tab[taille]; std::vector<void *> tab; std::vector<boost::any> tab; boost::ptr_vector<TypeDeBase> tab;"
->Oui ok mais le type est figé une fois le type donné.


"Il y a plusieurs questions pour tenter de préciser ton objectif :
- La taille du tableau est elle fixe ?
- Quand la taille du tableau est-elle connue ?
- Les objets contenus par le tableau sont ils tous du même type ?
- Quand connait-on le type de chaque élément du tableau ?
- Est-ce que le tableau doit gérer la durée de vie des objets qu'il contient ?"

->La taille du tableau est dynamique : connu lors de la construction ou d'un rezise
->Oui, les objets sont tous du même type.
->le type est connu lors de la construction et peut-être changé lors d'un équivalent resize.
->comprends pas la dernière question.

Redéfinition de l'objectif :
créer un tableau de type choisi par l'utilisateur, manipulé par la suite sans s'en préoccuper, mais de type modifiable.

ex :
Création d'un tableau d'int 4, 4 :
_mon_tableau *ptr=new mon_tableau(int,4,4); ->peut pas faire, j'peux pas passer un type. Pourtant c'est ce que je voudrais faire.
_mon_tableau<int> *ptr2=new mon_tableau<int>(4,4) -> faisable mais pas ce que je veux.

...Par la suite, mon_tableau *ptr3=new mon_tableau(typeid(ptr),n,n);

Que dire?

[Syrmonsieur]

"...Par la suite, mon_tableau *ptr3=new mon_tableau(typeid(ptr),n,n);"

Oui, d'accord, mais après ? tu veut faire quoi du contenu ?
ça sert à quoi ?

[Volune]

->Oui ok mais le type est figé une fois le type donné.

void* et boost::any, c'est pas trop ce que j'appelle figé comme type. M'enfin ...

Oui, d'accord, mais après ? tu veut faire quoi du contenu ?
ça sert à quoi ?

Je plussoie les questions
D'aileurs tu compte le remplir comment ton tableau ?
Qu'est-ce qui t'empèche de le remplir avec un type pas accepté par ce tableau ?

[DEVfan]

Je commence à explorer la STL mais alors le boost... j'connais pas trop!

Mais le pb n'est pas là. Si c'est comme un void*, on peut donner le type qu'on veut. Cependant on ne peut le faire qu'en direct :
_void* bidule; ... bidule=new int[5]; (par exemple...bidon)... c'est du code brut quoi!

Ce que je voudrais, c'est pouvoir faire :
_Maclasse *bidule; ... bidule=new Maclasse(type,...); ... c'est du code aussi mais le type étant un paramètre, un utilisateur du programme pourrait créer n'importe quel objet. Dans un premier temps, à partir de type connu (int, double, char, etc.). Dans un deuxième temps, à partir d'une classe qui liste des objets précédents.

Pour mathématiser :
_n types de base connu
+
_1 classe générique d'un type paramétré
+
_1 classe de construction par aggrégation (ou liste)
=>1 infinité de type.
(C'est l'idée d'un template sans être obligé de définir l'objet)

suis-je assez clair?
Merci d'avance.

[coyotte507]

Moi ce que je pense, c'est que tu dois auparavant connaitre dans le code brut tous les types possibles, et faire une fonction qui convertit le tableau en fonction d'une commande rentrée par l'utilisateur. En effet une fois le code chiffré, comment pourrait-il associer à un texte clair une classe dont le nom est chiffré?

[loufoque]

Pourquoi t'utilises pas directement un std::vector<T> où T est ton type ?

[DEVfan]

Parce que justement, je peux pas le générer dynamiquement. (Le type de l'objet n'est pas défini...enfin si pendant l'application)

Et je voudrais passer l'information en tant que paramêtre...

[Alp]

Je te conseille d'aller voir du côté du design pattern Factory.
En gros tu veux pouvoir créér des objets à partir de ... disons une chaîne de caractères. Hé bien ce design pattern te permettra de créér des objets à partir d'une chaine, ou d'un indice, enfin de quelque chose que tu aura fixé.
Si tu mets par la suite les objets créés dans un vector, ça devrait aller.

Bonne chance

[loufoque]

Est-ce que les différentes possibilités des types sont connues à la compilation ?

[DEVfan]

Non...
Donc pas de factory je pense.
Par contre, entre temps, j'ai eu le temps de réfléchir :

L'application en question aurait besoin
_d'une liste de map contenant <un indice,un pointeur vers un objet créé de type ...bah pointé>
_d'une classe TYPE contenant une liste d'objet référencé dans la map (par défault, int, float, double, etc.) [avec surchage obligatoire de == et !=]

Quand une combinaison de type est généré, on teste sont typeid dans la map et si ça n'existe pas, on fait une copie de l'objet qu'on stocke dans un contener du map et on demande éventuellement un nom à l'utilisateur si on veut associé un nom à l'indice du map... du coup un multi-map <indice,*type,string>.

Qu'en pensez-vous? (hormis qu'il manque le code...)

[loufoque]

Objectif : créer un tableau de type choisi par l'utilisateur.

Qui est l'utilisateur ?
Un programmeur qui utilise ta fonction ?
Un utilisateur du programme, qui ne peut donc fournir que des identifiants sous forme de chaîne ?

Premier cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

creer_tableau<le_type>();

Deuxième cas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

creer_tableau("le_type");

Dans le deuxième cas il te faut un tableau associatif effectivement.
Mais quoi en valeur ? C'est ça le problème.
À part du duck-typing, je vois pas trop ce que tu peux faire...

Peut-être une astuce avec la visitation générique de boost.variant ?

[DEVfan]

ET bien c'est un utilisateur humain a priori sinon, je me casserais pas la tête.

Dans l'esprit, ce que je veux faire, c'est un peu comme du lego... l'utilisateur connait les pièces de bases et à travers certains outils, il peut les assembler. Une fois le bloc monté (ou un étage comme en élec), il s'agit d'une nouvelle "pièce" du puzzle (et il n'y a pas de plan). Cette objet possède des règles similaires aux objets de base. Voilà l'architecture de base de mon idée.
Cela serait sans doute faisable en VHDL-AMS mais, j'ai pas envie d'acheter une licence et le côté modulaire du C++ me paraîssait adapté.

Ai-je toujours l'esprit d'un canard?

[Jean-Marc.Bourguet]

Tu parles de VHDL. As-tu regarde SystemC?

[DEVfan]

Euh, j'suis pas qq1 qui renouvelle sans cesse son langage de programmation, donc je fais avec ce qu'on m'a un minimum appris.
Ca je connais pas...donc j'vais un jeter un coup d'oeil!

...


Oui, c'est inspiré de VHDL en effet.
Mais en quoi ça favorise le codage pour ce que j'ai proposé?
Le VHDL fait bien Lego mais pour un utilisateur de programmation... moi, ce que je souhaite la même chose pour un individu lambda.
C'est comme si je voulais un jeu de Lego avec autant d'élément de base voulu et qui update ces éléments de base par avec des assemblages déterminés par l'utilisateur.

Qu'en pensez-vous?