Utiliser l'objet au lieu d'un pointeur

Bonjour,

J'ai toujours programmé en C++ mais niveau gestion objets je suis vraiment à “l'ancienne” si je puisse dire.

Pour l'instant je fais comme suit :

Code:

---

1 2 3 4 5 6 7 8 9

classe crayon { int x; };   class plumier { vector<crayon>cray; };

---

Et donc j'utilise cray comme un tableau :

Code:

---

plumier.cray[pointeur].x;

---

J'ai vu certains faire

Code:

---

crayon *cray = new crayon; // Ou un truc dans ce style

---

Comment pourrais-je faire pour travailler avec cray.x au lieu de plumier.cray[pointeur].x de façon à ce que la classe plumier sache toujours combien de crayons ont été créés et qu'elle aie accès à eux ?

J'espère avoir été clair, sinon je veux bien expliquer avec d'autres mots. Suffit de le mentionner. J'aimerais partir sur de bonnes bases pour la suite.

Merci par avance.

Édit : La bonne réponse de A à Z :

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 crayon { int x; };   class plumier { vector<crayon*>cray;   void ajouterCrayon( crayon *arg ) { crayon.push_back( arg ); }   // la classe plumier a accès de cette façon : cray[pointeur]->x; };   //On crée un plumier plumier plum;   // Création de crayons crayon crayon1 = new crayon(); plum.ajouterCrayon( crayon1 );   crayon1->x = 20;

---

Salut,
Je ne comprend pas très bien ta question.
L'utilisation de vecteur comme conteneur de plusieurs objets est une bonne pratique. std::vector te permet d'avoir le nombre d'éléments contenus.
L'allocation dynamique est souvent plus délicate à mettre en oeuvre, puisqu'au final, il va s'agir de faire par toi même à peu de chose près ce que fait std::vector.
Peux-tu préciser quelle est ton questionnement ?

Bonjour,

Effectivement, la question n'est pas très claire, cependant...

Citation:

---

Envoyé par Happy

J'ai vu certains faire

Code:

---

crayon *cray = new crayon; // Ou un truc dans ce style

---

Comment pourrais-je faire pour travailler avec cray.x au lieu de plumier.cray[pointeur].x de façon à ce que la classe plumier sache toujours combien de crayons ont été créés et qu'elle aie accès à eux ?

---

Si tu utilises ''cray.x" directement c'est que "cray" est un objet alloué sans "new", donc de cette manière :

Code:

---

1 2 3

Crayon cray; // [...] cray.x

---

Si tu utilises "new", tu utiliseras non plus l'objet directement, mais un pointeur vers cet objet qu'on va utiliser de cette manière :

Code:

---

1 2 3

Crayon* pCray = new crayon (); // [...] pCray->x; // et non pCray.x

---

Après si tu dois utiliser un ensemble de "crayon", il te faudra tout de même à un moment ou un autre l'utiliser d'un indice...

Si ton plumier ne fait que wrapper un vector, ben.. utilise juste un vector et pas de classe plumier?

typedef std::vector< crayon > plumier;
?

Sinon dans ton plumier tu fais une methode getCrayon qui prend en paramètre un index et renvoit une référence (&) sur un crayon.

Je ne vois pas pourquoi tu veux utiliser des pointeurs (alloués avec new ). Quand il y en a pas besoin, mieux vaut s'en passer ( et j'ajouterais que c'est la plus moderne des méthodes ).

Bonjour et merci :D

Effectivement si on crée avec « new » on doit utiliser « -> » pour accéder. C'est ce que je voudrait. C'est donc une « référence? ». Faudra que j'approfondisse ça.

Pour une facilité de programmation il est plus aisé d'appeler directement la référence de l'objet :

Code:

---

1 2 3

crayon* pCray = new crayon (); // [...] pCray->x = 0; // et non pCray.x

---

Au lieu de (plumier contiendra bien plus de choses que le vecteur) :

Code:

---

1 2 3 4 5 6 7

plumier mPlumier;   mPlumier.cray[pointeur].x = 0;   // ou   mPlumier.poche.sous_poche.sousous_poche.cray[pointeur].x = 0;

---

Surtout si le vector<cray> ferait partie d'une sous sous classe.

En conclusion il faut que je cherche comment je peux faire avec & référence. Il faut donc finalement avoir quand même le vector dans ma classe plumier, si j'ai compris, pour avoir la liste de crayons créés. :)

Non une réference ce n'est pas un pointeur.

Une référence permet d'utiliser des objets sans faire de copies.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void function( Objet o ) { }   main() { Objet o; function( o ); }

---

Tu as une copie.

Code:

---

1 2 3 4

void function( Objet & o ) { }

---

Tu n'as pas de copies. Après il y a toute une subtilité avec les const etc, tu peux voir la FAQ

( tu n'as jamais fait de cours d'algorithmie?

Passage par référence et passage par valeur ? )

Et sinon:

Code:

---

1 2 3

Objet o; o.methode();

---

c'est la bonne façon de l'utiliser.

Code:

---

1 2 3 4

Objet * o = new Objet(); o->methode(); delete o;

---

Ceci n'est pas du C++, c'est du pseudo-Java. Les pointeurs ont une utilité, mais pas celle là.

Merci,

Cependant là n'est pas le soucis. :aie: Je me demande comment faire savoir à ma classe plumier qu'un crayon a été créé avec new de la classe crayon et surtout que les mises à jour de crayon->x soient connues par la classe plumier.

Pour illustrer mon problème confus, imaginons qu'on a créé deux crayons :

Code:

---

1 2 3 4 5

crayon *mCrayon1 = new crayon(); crayon *mCrayon2 = new crayon();   mCrayon1->x = 5; mCrayon2->x = 8;

---

Maintenant imaginons que ma classe plumier aie une fonction afficher_crayons() qui en réalité est une boucle, pour chaque crayon, l'afficher à sa position x respective.

Donc si je met à jour :

Code:

---

mCrayon2->x = 10;

---

Que la fonction afficher_crayons() affiche les crayons avec les mises à jour. :D

Tu peux utiliser des pointeurs effectivement et avoir un std::vector de pointeurs ( std::vector< Crayon * > ) qui te permettra d'utiliser les mêmes crayons.

Mais ce pose là la question de qui a la reponsabilité de faire un delete sur ce crayon.

Donc là tu as le choix, suivant ce que tu veux:

- Soit Plumier a cette responsabilité, ce qui veux dire qu'il faudrait qu'il ait aussi la responsabilité de les créer et de donner des références à qui veut modifier un de ses crayons ou de fournir des méthodes pour modifier ses crayons. C'est un cas où on utilise des références et pas de pointeurs.

- Soit tu ne sais pas qui a la responsabilité, et donc le mieux est d'utiliser des pointeurs intelligents, que l'on trouve dans l'exension au langage TR1 ou dans la bibliothèque boost::shared_ptr.
Dans ce cas, tu as un std::vector< boost::shared_ptr< Crayon >> et tu crées des boost::shared_ptr< Crayon >( new Crayon() ) à la place des crayons.

Je peux te donner des exemples des deux cas.

Mais il faudrait quand même que tu saches ce qu'est une référence, un pointeur ou un passage par valeur.

Merci bien ;)

Édit : La bonne réponse de A à Z :

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 crayon { int x; };   class plumier { vector<crayon*>cray;   void ajouterCrayon( crayon *arg ) { crayon.push_back( arg ); }   // la classe plumier a accès de cette façon : cray[pointeur]->x; };   //On crée un plumier plumier plum;   // Création de crayons crayon crayon1 = new crayon(); plum.ajouterCrayon( crayon1 );   crayon1->x = 20;

---