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