je ne maîtrise pas très bien les tuples

Version imprimable

Bonjour

je voudrai faire une liste dont les élément soient des std::tuple<bien_immobilier,int>.
Mais après j'ai du mal à accéder à ce int:

Code:

1
2
3
4
5
revenus.cpp: In function ‘int main()’:
revenus.cpp:17:34: error: no match for ‘operator[]’ (operand types are ‘__gnu_cxx::__alloc_traits<std::allocator<std::tuple<bien_immobilier, int> >, std::tuple<bien_immobilier, int> >::value_type’ {aka ‘std::tuple<bien_immobilier, int>’} and ‘int’)
   17 |   std::cout<<revenus_joueur[0][0][1]<<std::endl;
      |                                  ^
m

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <array>
#include <vector>
#include <iostream>
 
enum bien_immobilier{maison,appartement};
 
typedef std::tuple<bien_immobilier,int>ligne_revenus;
 
int main(){
  std::vector<ligne_revenus>revenus;
  std::array<std::vector<ligne_revenus>,6>revenus_joueur;
  ligne_revenus un_revenu=std::make_tuple(maison,250);
  ligne_revenus un_autre=std::make_tuple(appartement,150);
  revenus.push_back(un_revenu);
  revenus.push_back(un_autre);
  revenus_joueur[0]=revenus;
  std::cout<<revenus_joueur[0][0][1]<<std::endl;
}

j'ai trouvé:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <array>
#include <vector>
#include <iostream>
 
enum bien_immobilier{maison,appartement};
 
typedef std::tuple<bien_immobilier,int>ligne_revenus;
 
int main(){
  std::vector<ligne_revenus>revenus;
  std::array<std::vector<ligne_revenus>,6>revenus_joueur;
  ligne_revenus un_revenu=std::make_tuple(maison,250);
  ligne_revenus un_autre=std::make_tuple(appartement,150);
  revenus.push_back(un_revenu);
  revenus.push_back(un_autre);
  revenus_joueur[0]=revenus;
  std::cout<<std::get<1>(revenus_joueur[0][1])<<std::endl;
}

Code:

1
2
$ ./a.out
150

si ça peut aider quelqu'un...

30/09/2025, 22h12
Bousk

Je sais pas combien te coûtent tes espaces, mais en ajouter aide à la lisibilité et éviter ce genre d'erreurs.
Aussi ton choix de structures me semble au moins suspect.
30/09/2025, 22h40
emmesse

Une ligne de revenus c'est un bien immobilier accompagné du loyer de son locataire.
L'erreur que j'ai commis est d'avoir utilisé [] à la fin au lieu de std::get<> au début

ça marche

Code:

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
#include <array>
#include <vector>
#include <iostream>
 
enum bien_immobilier{maison,appartement};
 
typedef std::tuple<bien_immobilier,int>ligne_revenus;
 
int main(){
  std::vector<ligne_revenus>revenus;
  std::array<std::vector<ligne_revenus>,6>revenus_joueur;
  ligne_revenus r1=std::make_tuple(maison,1);
  ligne_revenus r2=std::make_tuple(appartement,2);
  ligne_revenus r3=std::make_tuple(maison,3);
  ligne_revenus v1=std::make_tuple(maison,5);
  ligne_revenus v2=std::make_tuple(maison,6);
  revenus.push_back(r1);
  revenus.push_back(r2);
  revenus.push_back(r3);
  revenus_joueur[0]=revenus;
  revenus.clear();
  revenus.push_back(v1);
  revenus.push_back(v2);
  revenus_joueur[1]=revenus;
  std::cout<<"joueur 1:"<<std::endl;
  for(auto t:revenus_joueur[0])
    std::cout<<std::get<1>(t)<<" ";
  std::cout<<std::endl;
  std::cout<<"joueur 2:"<<std::endl;
  for(auto t:revenus_joueur[1])
    std::cout<<std::get<1>(t)<<" ";
  std::cout<<std::endl;
}

Code:

1
2
3
4
5
6
$ g++ *cpp
$ ./a.out
joueur 1:
1 2 3 
joueur 2:
5 6

Coucou

Pourquoi souhaites-tu utiliser des tuples au lieu d'utiliser une structure dédiée ? Un tuple est une structure très générique, mais elle ne porte aucune sémantique. La preuve : tu as dû nous dire que le "int" était un loyer. Avec une structure, tu peux nommer le champ et tout le monde sait ce que c'est.

Je te conseille aussi d'utiliser une "enum class" plutôt qu'une simple "enum" : https://stackoverflow.com/questions/...-should-i-care

Ton code devient alors :
Code:

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 #include <array> #include <iostream> #include <vector> enum class BienImmobilier{maison,appartement}; struct LigneRevenus { BienImmobilier bien_immobilier; int loyer; }; int main() { std::vector<LigneRevenus> revenus; std::array<std::vector<LigneRevenus>, 6> revenus_joueur; const auto r1 = LigneRevenus(BienImmobilier::maison, 1); const auto r2 = LigneRevenus(BienImmobilier::appartement, 2); const auto r3 = LigneRevenus(BienImmobilier::maison, 3); const auto v1 = LigneRevenus(BienImmobilier::maison, 5); const auto v2 = LigneRevenus(BienImmobilier::maison, 6); revenus.push_back(r1); revenus.push_back(r2); revenus.push_back(r3); revenus_joueur[0] = revenus; revenus.clear(); revenus.push_back(v1); revenus.push_back(v2); revenus_joueur[1] = revenus; std::cout << "joueur 1:" << std::endl; for (auto t : revenus_joueur[0]) std::cout << t.loyer << " "; std::cout << std::endl; std::cout << "joueur 2:" << std::endl; for (auto t : revenus_joueur[1]) std::cout << t.loyer << " "; std::cout << std::endl; }
Techniquement, ça fait la même chose. Mais ton code devient bien plus compréhensible, parce que la sémantique est plus explicite.

Il y a plein de façon de rendre la sémantique plus explicite. Il y a bien sûr les types utilisés, mais aussi les fonctions pour faire des actions. Tu peux par exemple fournir des fonctions pour créer tes lignes de revenus (c'est un peu artificiel ici, mais ça illustre le propos) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 struct LigneRevenus { BienImmobilier bien_immobilier; int loyer; static LigneRevenus pourMaison(int loyer) { return LigneRevenus{BienImmobilier::maison, loyer}; } static LigneRevenus pourAppartement(int loyer) { return LigneRevenus{BienImmobilier::appartement, loyer}; } };
Note enfin tu peux directement créer le tableau et les vecteurs avec les éléments, sans passer par des push_backs(). Et depuis C++17, tu peux aussi compter sur la déduction automatique des types pour les templates. Ton code pourrait donc ressembler à ça :
Code:

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 #include <array> #include <iostream> #include <vector> enum class BienImmobilier { maison, appartement }; struct LigneRevenus { BienImmobilier bien_immobilier; int loyer; static LigneRevenus pourMaison(int loyer) { return LigneRevenus{BienImmobilier::maison, loyer}; } static LigneRevenus pourAppartement(int loyer) { return LigneRevenus{BienImmobilier::appartement, loyer}; } }; int main() { std::array revenus_joueurs{ std::vector{ LigneRevenus::pourMaison(1), LigneRevenus::pourAppartement(2), LigneRevenus::pourMaison(3)}, std::vector{ LigneRevenus::pourMaison(5), LigneRevenus::pourMaison(6), }}; std::cout << "joueur 1:" << std::endl; for (auto t : revenus_joueurs[0]) std::cout << t.loyer << " "; std::cout << std::endl; std::cout << "joueur 2:" << std::endl; for (auto t : revenus_joueurs[1]) std::cout << t.loyer << " "; std::cout << std::endl; }

26/04/2026, 11h23
emmesse

désolé pour la réponse tardive, je n'avais pas remarqué la présence de la réponse.
@Bktero, j'aime beaucoup ce code, je l'adopte.
sinon le champ loyer et le paramètre loyer, c'est la même variable?(il me semble que non)
si j'ai bien compris, le paramètre loyer est utilisé comme champ de structure, structure qui est retourné avec le paramètre loyer qui devient un champ dans la structure retournée?
Sinon, peut-on mettre enum class BienImmobilier et struct ligneRevenu dans un hpp séparé?