Discussion :

[Happy]

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 :

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

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 :

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

plumier.cray[pointeur].x;

J'ai vu certains faire

Code :

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

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 :

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

[3DArchi]

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 ?

[Fabllot]

Bonjour,

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

J'ai vu certains faire

Code :

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

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 :

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

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 :

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

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

[nikko34]

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

[Happy]

Bonjour et merci

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 :

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

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 :

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

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.

[nikko34]

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

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

Code :

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

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 :

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

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 :

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

1
2
3
 
Objet o;
o.methode();

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

Code :

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

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

[Happy]

Merci,

Cependant là n'est pas le soucis. 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 :

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

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 :

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

mCrayon2->x = 10;

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

[nikko34]

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.

[Happy]

Merci bien

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

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