Discussion :

[ChPr]

Bonjour à tourtes et à tous,

Le titre n'est pas vraiment clair

Je crée un programme dans lequel j'ai un bon nombre de boutons qui ont été déclarés séparément, pas dans un tableau.

Certains de ces boutons ont un paramètre, appelons-le "groupe" ayant la même valeur.

Je voudrais pouvoir balayer l'ensemble des boutons et noter ceux qui une valeur particulière du paramètre "groupe". Comment fait-on ?

Mon idée est d'attacher à chaque objet, à sa création, un pointeur par lequel je peux ensuite l'adresser et ainsi voir son contenu ... mais je suis un super débutant en C++ et je ne sais pas vraiment comment faire.

Merci de votre aide.

Pierre

[Astraya]

Bonjour,

Sais tu parcourir l'ensemble de tes listes dans une boucle?
Que sont ces listes? des C-Array ( type var[] ) ou des vectors? (std::vector) ou un autre conteneur ?
De quel type sont tes listes? as tu la définition de la/les classe(s) de ces listes?

Un peu de code pour éclaircir ta question s'il te plait

Merci

[ChPr]

Voici le code :

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
int noBtn = 0;
 
class Bouton {
public:
  int groupe;
  void init(int);
};
 
Bouton *lstBtn = new Bouton[20]; // tableau de 20 pointeurs sur les boutons
 
void Bouton::init(int g) {
  groupe = g;
  lstBtn[noBtn] = this; // ça, ça me donne une erreur
  ++noBtn;
}

Ce que je voudrais, est qu'à chaque fois que j'instancie un bouton, il se crée un pointeur sur ce bouton, ce pointeur faisant partie d'une liste.

l'instruction :

Code :

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

  lstBtn[noBtn] = this; // ça, ça me donne une erreur

me donne une erreur. Si je mets &this, c'est pareil.

Quelle est la bonne instruction qui me permettra de créer un pointeur sur le bouton ?

Ayant ce pointeur, quelle est l'instruction qui permet d'accéder à un membre de la classe ?

Merci de votre aide.

Pierre

[Iradrille]

Code :

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

Bouton *lstBtn = new Bouton[20]; // tableau de 20 pointeurs sur les boutons

Hello,

Ceci n'est pas un tableau de pointeur, mais un tableau de Bouton.
Si noBtn et lstBtn sont des variables globales, c'est un problème.

Sinon pour un tableau de Bouton.

Code :

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

1
2
3
4
5
6
7
8
9
10
std::vector<Bouton> lstBtn;
lstBtn.push_back(Bouton(/*...*/)); // ajout d'un bouton
lstBtn.size(); // retourne le nombre de boutons
 
// ou en passant par des pointeurs
 
typedef std::unique_ptr<Bouton> btn_ptr;
std::vector<btn_ptr> lstBtn;
lstBtn.push_back(btn_ptr(new Bouton(/*...*/)); // ajout d'un bouton
lstBtn.size(); // retourne le nombre de boutons

Qu'un bouton s'ajoute tout seul à la liste est bizarre, c'est plus à l'entité qui va gérer ces boutons (la fenêtre par exemple) qui devra "posséder" et gérer ces boutons. C'est donc à elle de les ajouter à la liste.

Pour effectuer un traitement seulement sur les boutons d'un groupe particulier, tu peux ensuite faire quelque chose du genre

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
// g++ -std=c++0x -o main main.cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
 
class Bouton {
public:
	int groupe;
	std::string name;
 
	Bouton(int g, const std::string& n): groupe(g), name(n) { }
};
 
int main() {	
	std::vector<Bouton> lstBtn = {
		Bouton(0, "a"), // groupe 0
		Bouton(5, "b"), // groupe 5
		Bouton(1, "c"), // groupe 1
		Bouton(5, "d"), // groupe 5
		Bouton(5, "e")  // groupe 5
	};
 
	// affiche le nom de chaque bouton du groupe 5
	std::for_each(lstBtn.begin(), lstBtn.end(), [](Bouton& b) {
		if(b.groupe == 5) {
			std::cout << b.name << std::endl;
		}
	});
	return 0;
}

[ChPr]

Merci Iradrille pour cette proposition. Étant débutant en C++, je vais étudier un peu tout cela.

Pour autant, n'y a-t-il pas un méthode avec des pointeurs ... qui pointent sur les objets créés ... et utiliser ces pointeurs pour accéder à un membre de l'objet pointé ?

Cordialement.

Pierre

[Iradrille]

C'est sensiblement la même chose avec des pointeurs.

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
// g++ -std=c++0x -o main main.cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <memory>
 
class Bouton {
public:
	int groupe;
	std::string name;
 
	Bouton(int g, const std::string& n): groupe(g), name(n) { }
};
 
int main() {
	typedef std::unique_ptr<Bouton> bouton_ptr;
	bouton_ptr a(new Bouton(0, "a")); // groupe 0
	bouton_ptr b(new Bouton(5, "b")); // groupe 5
	bouton_ptr c(new Bouton(1, "c")); // groupe 1
	bouton_ptr d(new Bouton(5, "d")); // groupe 5
	bouton_ptr e(new Bouton(5, "e")); // groupe 5
 
	std::vector<bouton_ptr> lstBtn;
	lstBtn.push_back(std::move(a));
	lstBtn.push_back(std::move(b));
	lstBtn.push_back(std::move(c));
	lstBtn.push_back(std::move(d));
	lstBtn.push_back(std::move(e));
 
	// affiche le nom de chaque bouton du groupe 5
	std::for_each(lstBtn.begin(), lstBtn.end(), [](bouton_ptr& b) {
		if(b->groupe == 5) {
			std::cout << b->name << std::endl;
		}
	});
	return 0;
}

Jete un oeil à la doc de unique_ptr et shared_ptr, pour voir ce qui correspond à tes besoins.