C++ Vecteur d'objets

Bonjours à tous !

J'ai un petit soucis qui me prend la tête depuis un moment et je n'arrive pas à comprendre d'où vient l'erreure

Alors voilà :
J'ai une classe Game qui va déclarer un vecteur qui contient une lise de pointeurs sur une autre classe Character

Dans le fichier game.hpp

Code:

---

1 2	vector<Character*> listePersos;

---

Dans le fichier game .cpp

Code:

---

1 2 3 4 5 6 7 8

Game::Game(){ // Ici je crée une entrée dans la liste this->listePersos.push_back(new Character());   //Et la je l'envois à un constructeur d'une autre class Menu* menu = new Menu(&this->listePersos); }

---

Dans le fichier menu.hpp

Code:

---

1 2	vector<Character*>* listePersos;

---

Dans le fichier menu.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Menu::Menu(vector<Character*>* listePersos){ this->listePersos = listePersos; }   // Plus loin dans une methode de cette classe int i;   if (listePersos->size() > 0){ for (i = 0; i < listePersos->size(); ++i){ if (listePersos[i]->estControlable()){ //Du code } } }

---

A la compilation j'obtiens les l'erreur suivante

Code:

---

1 2 3 4

error: base operand of ‘->’ has non-pointer type ‘std::vector<Character*>’ if (listePersos[i]->estControlable()) ^

---

j'ai aussi essayé en remplaçant

Code:

---

1 2	if (listePersos[i]->estControlable())

---

par

Code:

---

1 2	if (listePersos[i].estControlable())

---

et l'a j'obtiens ceci

Code:

---

1 2 3 4

error: ‘class std::vector<Character*>’ has no member named ‘estControlable’ if (listePersos[i].estControlable()) ^

---

J'ai simplifier le code pour vous éviter les paramètres inutiles, si vous avez besoin de plus d'informations n'hésitez pas !

Merci d'avance et bonne journée

En fait je ne comprend pas pourquoi il me dit que ‘estControlable’ n'est pas une methode de vector<Character*> alors que je suis sensé faire appel au pointeur Character contenu dedans
Pire encore sachant que l'attribut listePersos de la classe Menu est un pointeur sur vecteur, de ce fait je comprend encore moins la première erreur de compilations

Remplaces tout tes :

Code:

---

listePersos[i]->

---

Par :

Code:

---

(*listePersos)[i]->

---

listePersos est un pointeur, donc *listePersos pour accéder à l'objet qui est un vector, donc (*listePersos)[i] pour accéder à un élément, qui est un pointeur donc (*listePersos)[i]-> pour accéder à un membre.

Et pensez à utiliser des unique_ptr à la place des pointeurs nus.
http://fr.cppreference.com/w/cpp/memory/unique_ptr

Salut,

La première question que je voudrais poser c'est : pourquoi transmettre ton std::vector<Character *> par pointeur :question: Aurais tu peur qu'il puisse ne pas exister :question: le transmettre par référence (constante pour le fonctions qui n'ont pas vocation à modifier la liste des objets) t'éviterait bien des soucis ;)

Ensuite, Bacela n'a absolument pas tort : l'utilisation de pointeur intelligents (std::unique_ptr en tête) t'évitera surement quelques cheveux gris avant l'heure ;)

Enfin, j'ose espérer que tu as pris toutes les précautions nécessaire pour éviter la copie et l'affectation des objets de type Character (et de ses types dérivés) :question:

Merci à vous tous pour vos réponse.

Citation:

---

Flob90:listePersos est un pointeur, donc *listePersos pour accéder à l'objet qui est un vector, donc (*listePersos)[i] pour accéder à un élément, qui est un pointeur donc (*listePersos)[i]-> pour accéder à un membre.

---

En effet ça fonctionne, mais entre temps j'ai trouvé une solution plus lisible à mes yeux

Code:

---

1 2	listePersos->at(i)->estControlable();

---

qui fonctionne tout aussi bien.

Citation:

---

bacelar:
Et pensez à utiliser des unique_ptr à la place des pointeurs nus.
http://fr.cppreference.com/w/cpp/memory/unique_ptr

---

Je n'avais encore jamais entendu parlé de ce type pointeurs. Mais je me demande si ce là fonctionnerais dans mon cas. (voir la réponse en dessous)

Enfait pour te répondre koala01.
J'ai une classe Game qui instancie d'autres classe tels que la fenêtre, le gestionnaire de rendu graphique ect..
Le problème c'est que pour chaque classe instanciée je dois lui donner un pointeur sur une autre contenue dans Game.
Par exemple le gestionnaire de rendu à besoin d'un pointeur sur la fenêtre.

Ou pour cet exemple plus concret,
la classe Menu (qui gère le menu de sélection ex: la liste des personnages du joueur) à besoin d'un pointeur sur le vecteur listePersos, mais d'autres classes auront aussi besoin de ce vecteur.

Donc ma question est la suivante, est-il possible qu'une classe B instanciée dans la classe A, puisse accéder aux attributs et méthodes de la classe A ?

Par contre je n'ai pas bien compris ta dernière question :?

Bonjour,

Citation:

---

Envoyé par ashesClaw

Donc ma question est la suivante, est-il possible qu'une classe B instanciée dans la classe A, puisse accéder aux attributs et méthodes de la classe A ?

---

Voici comment faire :

B.h

Code:

---

1 2 3 4 5 6

struct A;//Declaration anticipée struct B { B(const A& a);//B prend comme parametre A const A& a;//On garde une reference ou un pointeur, const ou non, de la classe A };

---

B.cpp

Code:

---

1 2 3 4 5

#include "A.h"//On peut inclure A sans problème dans le cpp B::B(const A& a) : a(a) { a.foo(); }

---

A.h

Code:

---

1 2 3 4 5 6 7

#include "B.h" struct A { A() : b(*this) {}//On initialise B avec ce même A const B b; void foo() const {} };

---

Citation:

---

Envoyé par ashesClaw

Par contre je n'ai pas bien compris ta dernière question :?

---

Tes classes vont avoir des operateurs de copie et d'affectation mis par défaut :

Code:

---

1 2 3

A a; A a2(a);//affectation a = a2;//copie

---

Le problème est quand ces classes (entitée) contiennent des pointeurs, les copies ou affectation vont copier les pointeurs mais pas leurs contenus.
On peut s'assurer que ça n'arrive en ajoutant ces deux lignes à la classe :

Code:

---

1 2	EntityClassA(EntityClassAconst &) = delete; EntityClassA& operator=(const EntityClassA&) = delete;

---

Citation:

---

Envoyé par ashesClaw

Enfait pour te répondre koala01.
J'ai une classe Game qui instancie d'autres classe tels que la fenêtre, le gestionnaire de rendu graphique ect..
Le problème c'est que pour chaque classe instanciée je dois lui donner un pointeur sur une autre contenue dans Game.
Par exemple le gestionnaire de rendu à besoin d'un pointeur sur la fenêtre.

---

Mais, la question demeure :pourquoi travailler avec des pointeurs et non avec des réféences, si tu sais que, quoi qu'il arrive, l'objet transmis doit forcément exister :question:

Citation:

---

Ou pour cet exemple plus concret,
la classe Menu (qui gère le menu de sélection ex: la liste des personnages du joueur) à besoin d'un pointeur sur le vecteur listePersos, mais d'autres classes auront aussi besoin de ce vecteur.

---

Encore une fois, pourquoi par pointeur et non par référence :question:

Bien sur, cela signifie que tu devra initialiser les différents éléments dans un ordre bien précis (il faut que le tableau de Character* existe (sans forcément être remplis, ceci dit) avant de créer ton menu), mais les références sont là pour te simplifier la vie... profites-en ;)

Citation:

---

Donc ma question est la suivante, est-il possible qu'une classe B instanciée dans la classe A, puisse accéder aux attributs et méthodes de la classe A ?

---

Lorsque tu appelles le constructeur de ta classe B, il n'y a absolument rien qui t'empêche de lui fournir un des membres de la classe A comme paramètre ;)

Notes juste que, si tu décides de maintenir la référence vers le membre de la classe A dans la classe B sous la forme d'une référence, tu devras (obligatoirement) passer par les listes d'initialisation car une référence doit être définie lorsqu'elle est créée / déclarée. Mais comme les listes d'initialisation sont la bonne manière de travailler, tu fais d'une pierre deux coups :D

Citation:

---

Par contre je n'ai pas bien compris ta dernière question :?

---

Typiquement, les classes qui ont sémantique d'entité devraient être non copiable et non affectables afin de garantir l'"unicité référentielle" de chaque objet (comprend: tu ne peux jamais, à un instant T de ton programme, plusieurs instances d'une classe présentant exactement les mêmes valeurs car tu dois pouvoir identifier chacune des instances de manière unique et non ambigüe). Ta classe Character entre très clairement dans cette catégorie et devrait donc en respecter les règles ;) (voir l'entrée suivant le dernier lien donné pour savoir comment faire si tu ne peux pas utiliser C++11 ou supérieur ;))

Allez, je me dis qu'un petit exemple pourrait être vraiment sympa ;)

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

class B{ public: B(std::vector<Character*> const & allChars):allChars_(allChars){} void foo() const{ for(auto * it : allChars_){ it->print(); } } private: std::vector<Character*>const & allChars_; }; class A{ public: A():b_(allChars_){} void addChar(Character * toadd){ allChars_.push_back(toadd); } void doSomething() const{ b_.print() } private: std::vector<Character*> allChars_; B b_; }

---

Et voilà, B dispose du tableau de Character* déclaré das A, qui sera mis à jour automatiquement parce que c'est une référence), mais B ne peut pas modifier de lui-même le tableau parce que c'est une référence constante (on aurait pu déclarer une référence non constante, mais il faut avoir la certitude qu'il y ait du sens à permettre à la classe B de modifier ce tableau, et ca, c'est pas forcément gagné ;))

Citation:

---

Envoyé par ashesClaw

En effet ça fonctionne, mais entre temps j'ai trouvé une solution plus lisible à mes yeux

Code:

---

1 2	listePersos->at(i)->estControlable();

---

qui fonctionne tout aussi bien.

---

C'est pas tout à fait identique à l'opérateur[], y'a des tests faits en plus et une exception générée en cas d'out-of-bound.
La syntaxe identique serait listePersos->operator[](i)->estControlable(); ou, plus claire : (*listePersos)[i]->estControlable(); comme donné par Koala.

Citation:

---

Envoyé par ashesClaw

J'ai une classe Game qui instancie d'autres classe tels que la fenêtre, le gestionnaire de rendu graphique ect..
Le problème c'est que pour chaque classe instanciée je dois lui donner un pointeur sur une autre contenue dans Game.
Par exemple le gestionnaire de rendu à besoin d'un pointeur sur la fenêtre.

---

Ta conception n'est pas terrible, tu prends la chose à l'envers amha.
Généralement c'est l'appli qui ouvre la fenêtre et initialise un Game avec celle-ci. Game instancie tous les éléments nécessaires (soundmanager, network manager, renderer, ....). Ou bien initialisé à côté (le renderer par exemple, ne dépend pas de Game, pas plus que la fenêtre).
Et tu as un accesseur global typiquement GetGame() accessible.

8O Décidément koala01 tu m'as illuminé un monde sombre du C++.

Certes je connaissait les références, (en fait j'avais eu quelques soucis avec les référence et la librairie SFML => segfaults, mais je me dis maintenant que ça venait sûrement de moi :roll: ) mais je ne m'étais jamais penché à ce point sur le sujet .
J'ai réussi à mettre en place ton exemple, (et Dieu merci tu m'en as fait un, sans ça je n'aurais rien compris :aie: ).

Mais comme je n'aime pas écrire un code que je ne comprends pas à 100% (et là j'en suis assez loin) je voudrais être sûr de comprendre.

En reprenant ton exemple

-Premièrement :
Si j'ai bien compris

Code:

---

B(std::vector<Character*> const & allChars):allChars_(allChars)

---

ce qui est après les " : " est la liste d'initialisation, elle passe avant le constructeur, ce qui permet de définir les références à leur "création" si je puis dire.
ici l'attribut std::vector<Character*> allChars_ prend la valeur de ce qui est entre parenthèses allChars


-Deuxièmement :
Pourquoi avoir mit une liste d'initialisation à la classe A ?
sachant que je ne l'ai pas mit dans mon code et ce-là fonctionne.
mais pour le coup je ne comprends pas à quoi correspond cette liste

En tout cas merci beaucoup, tu m'as permis de simplifier mon code :mrgreen:

@koala01: Tu n'aurais pas oublié de mettre la référence constante dans ton code ?

Citation:

---

Envoyé par Flob90

@koala01: Tu n'aurais pas oublié de mettre la référence constante dans ton code ?

---

Oh shame on me!!! corrigé ;)

Citation:

---

Envoyé par ashesClaw

8O Décidément koala01 tu m'as illuminé un monde sombre du C++.

Certes je connaissait les références, (en fait j'avais eu quelques soucis avec les référence et la librairie SFML => segfaults, mais je me dis maintenant que ça venait sûrement de moi :roll: ) mais je ne m'étais jamais penché à ce point sur le sujet .
J'ai réussi à mettre en place ton exemple, (et Dieu merci tu m'en as fait un, sans ça je n'aurais rien compris :aie: ).

Mais comme je n'aime pas écrire un code que je ne comprends pas à 100% (et là j'en suis assez loin) je voudrais être sûr de comprendre.

En reprenant ton exemple

-Premièrement :
Si j'ai bien compris

Code:

---

B(std::vector<Character*> const & allChars):allChars_(allChars)

---

ce qui est après les " : " est la liste d'initialisation, elle passe avant le constructeur, ce qui permet de définir les références à leur "création" si je puis dire.
ici l'attribut std::vector<Character*> allChars_ prend la valeur de ce qui est entre parenthèses allChars

---

Exactement

Citation:

---

-Deuxièmement :
Pourquoi avoir mit une liste d'initialisation à la classe A ?
sachant que je ne l'ai pas mit dans mon code et ce-là fonctionne.
mais pour le coup je ne comprends pas à quoi correspond cette liste

---

Cela fonctionne parce que le membre de la classe B dans le code tel que tu l'a lu à l'origine était une valeur et non une référence (constante)... Je viens de modifier le code et, maintenant, tu remarqueras que seules les listes d'initialisation fonctionnent, à chaque fois pour la même raison : B::allChars_ doit être initialisé quand l'objet est construit.

Cela implique :

• que l'on ne peut pas attendre d'être dans le corps du constructeur de B pour initialiser B::allChars_
• que l'on ne peut pas attendre d'être dans le corps du constructeur de A pour affecter un objet de type B au membre b_
  [/QUOTE]

Citation:

---

En tout cas merci beaucoup, tu m'as permis de simplifier mon code :mrgreen:

---

De rien ;)

De manière générale, il faut savoir que tu devrais toujours privilégier l'utilisation des référence (en veillant à les rendre constantes chaque fois que faire se peut) à l'utilisation des pointeurs et qu'il n'y a que deux cas dans lesquels tu n'auras pas le choix et qu'il faudra bien utiliser les pointeurs :

• lorsqu'un membre peut ne pas exister (*)
• lorsque tu veux pouvoir récupérer un objet issu d'une hiérarchie de classe qui a été créé dans une autre fonction (**)

(*) ex : un lien vers un objet "parent" ou vers un objet "enfant" : il y a de fortes chances que nous trouvions un objet qui n'a pas de parent, ou d'autres qui n'ont pas d'enfants ;)
(**)On ne peut pas renvoyer une référence sur un variable locale à une fonction car la variable en question est détruite lorsque l'on quitte la portée de la fonction dans laquelle la variable est déclarée... On doit donc recourir à l'allocation dynamique de la mémoire et utiliser un pointeur. Le code suivant sera incorrect et mènera sans doute à une erreur de segmentation :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Character & foo(/* ... /){   if(test1){   Warrior item(/* .. */); // on crée un guerrier return item; // qu'on renvoie par référence ici } // mais il est détruit ici... la référence est de facto invalidée // arrivé ici, on crée d'office un magicien Wizzar wiz(/* ...*/); return wiz; // qu'on essaye de renvoyer ici } // mais qui sera détruit ici, et la référence sera invalidée int main'){ Character & item = foo(/* ... */); // on connait l'objet comme étant de type Character, mais la référence est invalide... /* ... */ return 0; }

---

Pour que cela fonctionne : pointeurs (de préférence intelligents) et allocation dynamique de la mémoire (ou make_shared, si tu dispose de C++11) seront les maîtres mots ;)

Avant toutes choses je voudrais vous remercier.
@Bousk: Je suis désolé je n'avais pas vu ton message avant.
Si j'ai bien compris

Code:

---

(*listePersos)[i]->estControlable()

---

générera un exception dans le cas où l'index i n'existe pas , alors que

Code:

---

listePersos->at(i)->estControlable();

---

générera un beau segfault.

Citation:

---

Ta conception n'est pas terrible, tu prends la chose à l'envers amha.
Généralement c'est l'appli qui ouvre la fenêtre et initialise un Game avec celle-ci. Game instancie tous les éléments nécessaires (soundmanager, network manager, renderer, ....). Ou bien initialisé à côté (le renderer par exemple, ne dépend pas de Game, pas plus que la fenêtre).
Et tu as un accesseur global typiquement GetGame() accessible.

---

Tu as tout à fait raison il faut que je m'organise, j'ai tendance à foncer tête baissée :aie:

Et surtout un grand merci à toi koala, pour avoir pris le temps de me faire tout un mini cours. :ave:
Tu m'as donné beaucoup de notions que je vais devoir explorer, apprendre et maîtriser.
Et oui je compile avec la norme C++11

Promis si tu es dans les environs de Paris je te paye une bière ! :chin:

Pour être franc je suis tout nouveau dans le monde du C++, j'ai déjà codé en C, en JS, fait de l'objet avec php. Mais je ne m'étais jamais vraiment mis au C++.
Quand je vois tout ce que permet ce langage, je sens qu'il va vraiment me plaire. :salive:

Citation:

---

Envoyé par ashesClaw

Si j'ai bien compris

Code:

---

(*listePersos)[i]->estControlable()

---

générera un exception dans le cas où l'index i n'existe pas , alors que

Code:

---

listePersos->at(i)->estControlable();

---

générera un beau segfault.

---

C'est précisément l'inverse.

Et encore, la segfault n'est pas garantie. C'est là tout le problème des comportement indéfinis, ça pourrait faire sortir des démons de ton nez à la place. Ou donner l'apparence de marcher, et faire une segfault plusieurs minutes plus tard. Ou une division par zéro.