Discussion :

[Sky_Saxon]

Bonjour,

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

Par exemple :

Code :

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

1
2
3
4
ucstring variable1;
ucstring variable2;
ucstring variable3;
...

Pour cela je concatène deux string :

Code :

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

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,...".

[Invité]

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

[koala01]

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 :

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

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 qu'est-ce donc
2. fromUtf8, c'est pas du java, ca

[jfouche]

@ 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 :

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

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

[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 : 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

[koala01]

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

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 (de prime abord, cela correspondrait à une chaine de caractères "C style" manipulant l'utf )

[Pragmateek]

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".

[jfouche]

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

[Sky_Saxon]

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

Code :

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

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 );
		}

[Pragmateek]

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.

[koala01]

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