déclarer un string a partir d'une variable

Bonjour,

Je désire déclarer une suite de variables, dont le dernier caractère du nom est incrémenté.

Par exemple :

Code:

---

1 2 3 4

ucstring variable1; ucstring variable2; ucstring variable3; ...

---

Pour cela je concatène deux string :

Code:

---

1 2 3 4 5 6 7 8 9 10

int NombreDeVariable = 5; int i = 0;   while (i<NombreDeVariable) { ucstring j.fromUtf8(i); // Converti int en ucstring ucstring test = "variable"; ucstring variable = test += j; // Concatenation i++;}

---

variable prend donc les valeurs : "variable1, variable2,...".
Le problème est que je ne sais pas comment déclarer une variable qui à pour nom (et non pas pour valeur) "variable1, variable2,...".

En gros, tu ne peux pas. Les noms de variables cela relève du code source, et ca disparait à l'exécution. Maintenant, tu peux faire un tableau de variables, genre

string variables[5];
ou
vector<string> variables;

que tu accèderas par leur indice.
variables[0] étant ce que tu voulais appeler variable1 (seule différence, les tableaux C et C++ sont en base zéro, mais tu peux aussi faire un tableau plus long d'une variable, et ne pas utiliser variables[0]).

Francois

Salut,

Le problème vient du fait que le caractère '1' ne vaut pas 1 en valeur binaire (c'est d'ailleurs valable pour tous les chiffres lorsque tu les considère comme faisant partie d'une chaine de caractères)...

De plus, les entiers de type int sont bien souvent codés sur un nombre de bit très largement supérieur au nombre de bits permettant le codage d'un char...

Il faut donc convertir ton entier en chaine avant de pouvoir faire quoi que ce soit.

Cette entrée de la FAQ t'indiquera comment faire ;)

Dans le cas qui t'intéresse, cela pourrait prendre la forme de

Code:

---

1 2 3 4 5 6 7 8

std::string pre="variable"; for(int i=0;i<5;++i) { stringstream ss; ss<<pre<<i; std::string final=ss.str(); std::cout<<final<<std::endl; }

---

PS

1. ucstring :question: qu'est-ce donc :question:
2. fromUtf8, c'est pas du java, ca :question:

@ Koala01 : Je ne pense pas que cela réponde à la question.

Tu pourrais faire un truc du genre (qui ne répond pas non plus completement à la question ;), car il faudrait trouver un moyen de mettre les indices en variables).

Code:

---

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

#include <iostream> #include <string>   #define DECLARE_VARIABLE(indice, valeur) std::string variable##indice = valeur   int main(int argc, char **argv) { DECLARE_VARIABLE(1, "toto"); DECLARE_VARIABLE(2, "titi");   std::cout << variable1 << std::endl; std::cout << variable2 << std::endl; return 0; }

---

Mais de toute façon, je n'aime pas trop les macros, et je pense que la réponse de François est plus adaptée.
--
Jérémie

Citation:

---

Envoyé par jfouche

Tu pourrais faire un truc du genre (qui ne répond pas non plus completement à la question ;), car il faudrait trouver un moyen de mettre les indices en variables).

---

Bah non, Jérémie, t'as pas réfléchi :aie: : Les macros sont résolues à la compilations, donc les noms de variable ne peuvent pas être définis dynamiquement grâce à une variable.
--
Jérémie

En fait, il faudrait voir le type des variables parce que j'avoue que j'ai un peu de mal à cerner le problème exact :aie:

Si les variables sont des classes ou des structures, il faut peut être se baser sur l'entrée de la FAQ qui traite de la conversion de n'importe quel objet en string, éventuellement adaptée sur base de celle qui traite de la surcharge de l'opérateur << pour les objets polymoprhes ;)

Et je ne sais toujours pas ce que peut être ucstring :D (de prime abord, cela correspondrait à une chaine de caractères "C style" manipulant l'utf :question:)

Citation:

---

Envoyé par fcharton

Maintenant, tu peux faire un tableau de variables, genre

string variables[5];
ou
vector<string> variables;

que tu accèderas par leur indice.
variables[0] étant ce que tu voulais appeler variable1

---

Ou sinon une map<string, void*> semble plus adaptée si la règle de formation des noms n'est pas que numérique.
Les clés seraient alors les noms des "variables" et les valeurs celles des "variables".

Citation:

---

Envoyé par seriousme

Ou sinon une map<string, void*> semble plus adaptée si la règle de formation des noms n'est pas que numérique.
Les clés seraient alors les noms des "variables" et les valeurs celles des "variables".

---

Bof, si on veut passer par une map, autant garder le type d'origine : map<string, ucstring>

En c++, void* est rarement une (bonne) solution. Cela dénote souvent un problème de conception.
--
Jérémie

Merci pour toutes vos réponse, finalement je me suis arrangé en utilisant un vecteur.

Code:

---

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

vector<ucstring> shardname; ucstring name; name.fromUtf8( row[0] ); // Name prend la valeur de la première ligne d'un requete SQL shardname.push_back( name );   for (int i=0;i<nbrow;i++) { row = mysql_fetch_row(result); // Descend d'un ligne dans le resultat de la requete SQL   name.fromUtf8( row[0] ); shardname.push_back( name ); }

---

Citation:

---

Envoyé par jfouche

Bof, si on veut passer par une map, autant garder le type d'origine : map<string, ucstring>

En c++, void* est rarement une (bonne) solution. Cela dénote souvent un problème de conception.
--
Jérémie

---

Si un seul type de variable est géré oui; mais dans le cas général, par exemple dans le cadre de la gestion des variables dans un interpréteur de langages dynamiques, le type void*, ou ses équivalents (boost::any en C++, object en C#, Object en Java et .Net ...) est tout à fait approprié, même nécessaire.

Citation:

---

Envoyé par seriousme

Si un seul type de variable est géré oui; mais dans le cas général, par exemple dans le cadre de la gestion des variables dans un interpréteur de langages dynamiques, le type void*, ou ses équivalents (boost::any en C++, object en C#, Object en Java et .Net ...) est tout à fait approprié, même nécessaire.

---

Je suis très loin d'être d'accord avec toi...

Les object (C#) et Object (javai, .NET) ont déjà une interface qui leur est propre (celle que l'on attend au minimum des objets que l'on manipule)...

Même boost any est orienté vers le fait que nous parlons de types ayant une sémantique de valeur ou du moins susceptibles d'être convertis l'un en l'autre, alors que void* peut représenter strictement tout et n'importe quoi...

Cela signifie que tu en viendrait facilement à faire cohabiter des cuillères avec des avions à réaction, alors qu'il n'y a, a priori, aucune propriété commune...

Et ca, c'est vraiment une très mauvaise idée et le signe réel que tu fais sans doute face à un très sérieux problème de conception ;)

Comprend moi bien: Je ne suis pas (tout à fait) opposé au fait de manipuler des void* en C, car c'est la seule possibilité qui nous est donnée de rejoindre d'une certaine manière le besoin de polymorphisme...

Mais cela va de paire avec l'obligation de cacher l'implémentation et de s'assurer en permanence de passer un pointeur sur le type adéquat afin d'éviter d'aller chatouiller la mémoire à un endroit mal choisi.

Dans les langages orientés objet de manière générale (tout comme dans les langages qui proposent le paradigme générique), il existe une multitude de solutions qui permettent d'éviter ce genre de problème, et il me semble des plus important de veiller à les utiliser ;)