Discussion :

[AsmCode]

Bonjour, j'ai décidé de faire un vecteur d'union pour pouvoir stocker différent type de données pouvant être différent à chaque fois.

Mais je me demandais si il y aurait une façon de mettre l'affectation sur une seule ligne au lieu de faire avec des if

J'ai le type que je veux stocker dans une variable string, exemple: float

admettons que j'ai l'union suivante:

union Datatype {

int Int;
float Float;
string String;

}

et admettons que j'ai mon type de données dans une variable string comme mentionné ci-haut:

string typeDonnee = "Float";

Au lieu de faire:

if (typeDonne == "Float) vec[0].Float = 5.5;

..

je voudrais faire un truc du genre:

vec[0].typeDonnee = 5.5;

[Laurent Gomila]

Faut pas trop fantasmer, le C++ c'est pas un langage interprété. Pour le compilo, y a autant de rapport entre la chaîne "float" et le type float, qu'entre un escargot et une chemise

Question à trois sous : pourquoi ne pas utiliser boost::any ou un truc dans le genre ?

[AsmCode]

Faut pas trop fantasmer, le C++ c'est pas un langage interprété. Pour le compilo, y a autant de rapport entre la chaîne "float" et le type float, qu'entre un escargot et une chemise

Question à trois sous : pourquoi ne pas utiliser boost::any ou un truc dans le genre ?

Ah ? je ne connais pas, qu'est-ce que boost::any ?

[AsmCode]

J'ai pensé a une solution, dites-moi ce que ça vaut.

Je ferais une class Datatype dans lequel je mettrais un type union

et je redéfinirais l'opérateur = 3 fois pour chaque type de données.

De cette façon j'aurais un vecteur de Datatype et quand je ferais vec[0] = variable il mettrais la valeur dans le bon type automatiquement.

[Sylvain Togni]

Oublie les unions, il ne fonctionnent qu'avec les types POD, et string n'en est pas un.

[AsmCode]

ah zut, dans ce cas, je pourrais faire comme si c'était une union, j'ai qu'a faire 3 variables dans ma classe, string, int et float bon c'est pas idéal, mais c'est pas trop lourd non plus étant donné qu'il n'y a que 3 types et ce n'est pas un projet d'entreprise c'est que pour un travail d'école, alors je crois que ça fera l'affaire.

A moins qu'il y ait une meilleure suggestion ?

[droggo]

Ho,

Pour le compilo, y a autant de rapport entre la chaîne "float" et le type float, qu'entre un escargot et une chemise

Et encore, certaines chemises aussi sont baveuses

ok, je sors.

[loufoque]

C'est plutôt boost variant que tu veux.

[AsmCode]

J'ai une meilleure idée je vais faire un type Data mais avec une string et redéfinir l'opérateur <

ou Étant donné que c'est qu'une string ordinaire, peut-on redéfinir l'opérateur < pour les string sans faire une nouvelle classe ?

[koala01]

Salut,

Quelques remarques d'ordre générale:

-Dans la plupart des cas, il n'est pas intéressant d'allouer dynamiquement un conteneur de la STL...:

Crée le de manière tout à fait statique, que ce soit dans une fonction ou dans une classe, et

• passe le par référence (constante ou non) aux fonctions qui n'y ont pas accès
• renvoie-le par référence (constante ou non) si c'est le retour d'une fonction membre de la classe qui a acces au vecteur sans le modifier
• renvoie le de manière classique si c'est le retour d'une fonction dans laquelle il est créé (pour modification "temporaire", par exemple)

De la meme manière, les cas dans lesquels il est intéressant d'introduire un élément alloué dynamiquement dans un conteneur de la STL sont relativement limité également...

Si, pour pouvoir envoyer l'élément de ton conteneur à une fonction de bibliothèque, il apparait nécessaire de disposer d'un pointeur sur cet élément, de prendre "l'adresse" de l'élément en cas de besoin

L'une des raisons principales de cette deuxième remarque est qu'il suffit, pour supprimer un élément de ton conteneur (ou pour le vider) d'utiliser la fonction membre qui va bien (erase ou clear), alors qu'il faudra penser à travailler en deux temps avec des éléments alloués dynamiquement:

• libérer la mémoire pointée par l' (les)élément(s)
• supprimer l'(les)élément(s) avec la fonction membre qui va bien

Voici un code simple pour t'en convaincre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include <iostream>
#include <vector>
std::vector<int> CreateVector()
{
    std::vector<int> ret;
    for(int i=0;i<5;i++)
        ret.push_back(i);
    return ret;
}
void AffichVector(std::vector<int>& vect)
{
    for(unsigned int i=0;i<vect.size();i++)
        std::cout<<vect[i]<<"\t"<<&vect[i]<<std::endl;
}
void Ajoute5elem(std::vector<int>& vect)
{
    unsigned int taille=vect.size();
    unsigned int final=taille+5;
    for(unsigned int i=taille;i<final;i++)
        vect.push_back(i);
}
// ajoute un élément au vecteur
void AjouteValeur(std::vector<int>& vect, int val)
{
    vect.push_back(val);
}
int main()
{
    std::vector<int> vect=CreateVector();
	std::cout<<"premier affichage "<<std::endl;
	AffichVector(vect);
	std::cout<<"ajoute 5 elements"<<std::endl;
	Ajoute5elem(vect);
	std::cout<<"deuxième affichage"<<std::endl;
	AffichVector(vect);
	//ajoute d'autres éléments
    AjouteValeur(vect,100);//Remarque: aucune de ces trois valeurs
    AjouteValeur(vect,101);//n'existe réellement dans main ;)
    AjouteValeur(vect,102);//elles sont créées lors de l'appel de la fonction
                           //et cessent donc d'exister lorsque la fonction est
                           //quittée ;)
    std::cout<<"affichage final"<<std::endl;
	AffichVector(vect);
	return 0;
}

NOTA:j'ai utilisé un "simple" vector et un "simple" int, mais cela fonctionne tout aussi bien avec les conteneurs et/ou les éléments plus complexes

Si l'utilisation de pointeur doit etre envisagée dans un conteneur STL, ce sera beaucoup plus parce qu'on souhaite pouvoir vérifier que l'on accede bien à un élément donné alors que d'autres éléments peuvent avoir exactement les memes valeurs (comme clé dans une map, par exemple)