Discussion :

[emmesse]

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 :

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

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

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

[emmesse]

j'ai trouvé:

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

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

1
2
$ ./a.out
150

si ça peut aider quelqu'un...

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

[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

[emmesse]

ça marche

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

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

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

[Bktero]

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 :

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

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

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 :

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