Discussion :

[IlGi256]

Bonjour,
Je souhaiterai créer une fonction afin de générer des noms uniques de vector persistent.
Ces vectors seront éffacés via une autre fonction.
Chaque appel de la fonction doit créer un nom unique de vector.
Cet appel doit pas être écrasé par l'appel suivant.

Exemple :
Appel 1 :
+ Création d'un vector Liste_0 et de son contenu
Appel 2 :
+ Création d'un vector Liste_1 et de son contenu
Appel ... :

Le problème c'est que le nom des variables en C++ est statique et que chaque variable doit être déclarée avec un nom défini d'avance.

Peut-on crééer une fonction génératrice de nom unique aux vector C++ ?
Sur d'autres languages cela se fait !

Sur la base d'un code d'exemple ci dessous, j'ai ténté sur un autre code, de créeer un nom unique via une macro pour un vector.
J'ai bien le vector sans erreur, mais je n'arrive pas à exploiter.

Code vector persistent classique

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
 
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <utility>
 
using std::cout;
using std::end;
using std::string;
using std::atoi;
using std::to_string;
using std::vector;
using std::pair;
using std::make_pair;
using std::sort;
 
int main(){
 
     int64_t I64_V1D_Taille{};
 
     static vector<int64_t>Liste{};
 
     I64_V1D_Taille = Liste.size();
 
     cout << I64_V1D_Taille << end;
 
     Liste.clear();
 
}

Tentative de création d'un nom unique avec une macro

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
 
 
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <utility>
 
using std::cout;
using std::end;
using std::string;
using std::atoi;
using std::to_string;
using std::vector;
using std::pair;
using std::make_pair;
using std::sort;
 
#define CONCAT(a, b) CONCAT_INNER(a, b)
#define CONCAT_INNER(a, b) a ## b
 
#define UNIQUE_NAME(base) CONCAT(base, __COUNTER__)
 
int main(){
 
     int64_t I64_V1D_Taille{};
 
     static vector<int64_t>UNIQUE_NAME(Liste){};//fonctionne
 
     /*I64_V1D_Taille = UNIQUE_NAME(Liste).size(); //error C2065: 'Liste3': undeclared identifier*/
 
     //cout << I64_V1D_Taille << end;
 
}

[Bktero]

Tu ne peux pas créer des noms dynamiquement. D'ailleurs, comment pourrais-tu t'en servir dans du code sans les connaitre à l'avance ?

Tu pourrais nous expliquer pourquoi tu veux faire ça ? On pourra t'aider à trouver une autre solution.

[dalfab]

Oui, que cherches tu à faire?

Le code que tu as trouvé, génère bien des noms uniques. C'est une utilisation "extrême" des macros. Mais ils sont tellement uniques qu'on ne peut citer les noms qu'une fois!

Code :

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

1
2
3
4
5
static vector<int64_t> UNIQUE_NAME(Liste){};  // définit Liste1
static vector<int64_t> UNIQUE_NAME(Liste){};  // définit Liste2
static vector<int64_t> UNIQUE_NAME(Liste){};  // définit Liste3, on a créé 3 variables différentes.
 
I64_V1D_Taille = UNIQUE_NAME(Liste).size();   // erreur, Liste4 n'existe pas!!

[bacelar]

Si le "nom", c'est pour distinguer une "Liste" d'une autre, leur adresse devraient largement suffire.

[foetus]

Si le "nom", c'est pour distinguer une "Liste" d'une autre, leur adresse devraient largement suffire.

Comment prends-tu l'adresse de ton vecteur à la définition ?

[kaitlyn]

Salut tour le monde,

Un vecteur de vecteur

Code :

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

1
2
3
4
5
6
7
vector<vector<int>> v;
{
    vector<int> tmp {1,2,3};
    v.push_back(tmp);
}
cout<< v.size()<< '\n';
cout<< v.at(0).size(); // ou v[0].size() quand opportun

[Bousk]

Ça sent le mytho problème de vouloir créer des trucs et vouloir les distinguer par leur nom quand la solution serait d'utiliser une std::map<std::string, std::vector<int64_t>>

[kaitlyn]

Comme toi, j'ai pensé direct au std::map mais si c'est pour appeler les vecteurs unique_nom_1, unique_nom_2... et l'absence d'un besoin clairement défini je lui ai préféré le std::vector qui colle mieux aux intentions des codes présentés.

[foetus]

1 vecteur ou 1 map ne change rien sans explication c'est impossible, le développeur ne peut pas manipuler 1 tableau qui sera connu à la compilation
Et comme je le disais avant, on ne peut pas récupérer l'adresse du tableau à la définition

Qu'on stocke 1 nom ou 1 indice, on n'a pas le lien entre son tableau et cet élément (... à moins de toujours utiliser le dernier avec 1 variable [globale/ statique/ ...])
Sinon éventuellement , coder 1 classe qui gère la collection de tableaux, et qui te retourne 1 index/ 1 nom que tu stockes, pour ensuite l'utiliser ... 1 truc ultra classique.

À moins que quelqu'un propose 1 solution

[kaitlyn]

Sinon éventuellement , coder 1 classe qui gère la collection de tableaux, et qui te retourne 1 index/ 1 nom que tu stockes, pour ensuite l'utiliser ... 1 truc ultra classique.

Je comprends pas pourquoi tu compliques les choses, tu as l'embarras du choix en containers dans la STL.

Voilà ce que demande le 'posteur' original

Je souhaiterai créer une fonction afin de générer des noms uniques de vector persistent.
Ces vectors seront éffacés via une autre fonction.
Chaque appel de la fonction doit créer un nom unique de vector.
Cet appel doit pas être écrasé par l'appel suivant.

Exemple :
Appel 1 :
+ Création d'un vector Liste_0 et de son contenu
Appel 2 :
+ Création d'un vector Liste_1 et de son contenu
Appel ... :

et voici ce que j'avais proposé

Code :

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

1
2
3
4
5
6
7
8
9
vector<vector<int64_t>> list;
list.push_back(appel_fonction_qui_retourne_un_vecteur());
list.push_back(appel_fonction_qui_retourne_un_vecteur());
//...
cout<< list.size()<< '\n';
cout<< list[0].size()<< '\n';
list[0].clear();
cout<< list[1].size()<< '\n';
//...

Là, il me semble que tout y est.

Après, le reste de son message c'est le problème Y de la solution qu'il a imaginé pour résoudre X, c'est tout.