Confusion avec les références

Version imprimable

Voir 40 message(s) de cette discussion en une page

02/05/2006, 21h30
vdumont

Confusion avec les références
Bonjour, j'aimerais dans une fonction créer une variable (std::map) et j'aimerais lui affecté une map d'une autre classe.

J'aimerais que ce soit par référence et non une copie (car c'est une map qui peut être asser volumineuse) donc je dois faire quoi au juste?
Code:

1 2 std::map<int,std::vector<int> > m; //( & ou * ou rien?)
Code:

1 2 const std::map<int,std::vector<int> > & GetToDraw() { return &maptodraw; }
1. m = objet->GetToDraw() ???
2. *m = objet->GetToDraw() ???
3. &m = objet->GetToDraw() ???
Si vous pouviez m'aider a comprendre le mécanisme un peu aussi ;) Merci!
02/05/2006, 22h31
Rafy
Premierement Si tu utilise un std::map<int, std::vector<int> > alors quand tu vas insérer un vector dans le map alors ça va copier le vector... Je ne sais pas si tu étais conscient de ça...

Si tu retourne une référence, alors tu ne dois surement pas retourner l'adresse de maptodraw mais maptodraw.
Code:

1 2 return maptodraw;
et tu pourra faire :
Code:

1 2 m = objet->GetToDraw();
Le compilateur verra que ce tu retourne est une référence (c'est écrit dans la définition de la fonction) et alors il ne ferra pas de copie.
02/05/2006, 22h35
Swoög

Salut !

Alors, tout d'abord, la différence principale entre référence et pointeurs :

un pointeur peut être modifié (on peut changer l'objet pointé)
une référence NON : on désigne l'objet pointé à la création de la référence, et ensuite il est IMPOSSIBLE de le changer...

dans une classe, les références DOIVENT être initialisées dans le constructeur... cela sous-entends donc que dès la création de ton instance, tu connaisses la map à laquelle tu vas relier la map de ton instance...

Ensuite, ne perd pas de vue qu'une "référence sur une variable" ne représente pas "une variable de même valeur que la variable" mais bel et bien cette variable !

ce qui signifie que toute modification de la variable entraîne la même modification sur la référence, et inversement, tout simplement parce qu'elle partagent et désignent la même adresse mémoire !

Maintenant, si tu as bien saisie tout ça, et que tu souhaites toujours utiliser une référence, il te faut définir la fonction membre de la classe qui fournie la map ainsi :

Code:

map<int, vector<int> >& ClassFournisseuse::GetMap() { return The_Map; }

et ton constructeur de la classe recevante :

Code:

ClasseRecevante::ClasseRecevante(map<int, vector<int> >& map) : The_Map(map) { }

et dans le .h de la classe recevante, il faut déclarer The_Map ainsi :

Code:

map<int, vector<int> >& The_Map;

Bien sûr, il s'agit d'exemple...

tu peux également utiliser des références constantes, qui te permettent de n'accéder à la map qu'en lecture, dans ce cas, les trois bouts de code deviennent respectivement :

Code:

const map<int, vector<int> >& ClassFournisseuse::GetMap() { return The_Map; }

Code:

ClasseRecevante::ClasseRecevante(const map<int, vector<int> >& map) : The_Map(map) { }

Code:

const map<int, vector<int> >& The_Map;

Cepandant, sauf dans des cas très particulier où l'utilisation des références est réellement justifié (peut-être ta situation en fait-elle partie ;) ), je déconseillerais l'usage des références comme données membres d'une classe ;)

Si tu as d'autres questions sur le sujet, je serais heureux d'y répondre ;)

Pour ce qui est du mécanisme.
Les références te permettent d'éviter des copie dans les passages de paramètres et dans les valeurs de retour.
Si tu renvoie une référence, il n'y aura pas de copie de faite de ce que tu retourne.
Pour ce qui est du passage des arguments, la aussi, passer une référence ne donnera pas à la fonction une copie de l'objet mais l'objet directement.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Objet Fonction(void) { Objet* MonObjet = new Objet; return MonObjet; } int i = Fonction().GetSize(); //La ca va copier MonObjet pour lancer la methode GetSize Objet& Fonction2(void) { Objet* MonObjet = new Objet; return MonObjet; } Fonction().GetSize(); //La ca ne va pas copier, ca sera le getsize de MonObjet qui sera appelé
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void Fonction(const Objet MonObjet) { int i = MonObjet.GetSize(); } Objet UnObjet; Fonction(UnObjet); //Ca va copier UnObjet puis GetSize sera appelé sur la copie. void Fonction2(const Objet& MonObjet) { int i = MonObjet.GetSize(); } Objet UnObjet; Fonction2(UnObjet); // Ca va apeller le GetSize de UnObjet

Considérons le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
void Add1(int i, int j)
{
    cout << i;
    i = i + j;
    cout << i;
}
void Add2(int& i, int j)
{
    cout << i;
    i = i + j;
    cout << i;
}
int i = 4;
int j = 5;
cout << i;           // Retournera 4
Add1(i, j);           // Retournera 4 puis 9
cout << i;           // Retournera 4 (car Add1 aura travaillé sur une copie de i)
Add2(i, j);           // Retournera 4 puis 9
cout << i;           // Retournera 9 (car Add2 aura travaillé sur i et non sur une copie de i)

Merci pour vos réponses, j'y vois un peu plus clair.

Rafy: C'est correct dans mon cas que ce soit des copies du vector, en fait c'est exactement ce que je veux car je crée et insère les vecteurs dans la map à l'intérieur d'une fonction (donc les vecteurs n'existe plus lorsque je suis sortie de la fonction).

Le problème que j'ai maintenant est que depuis que j'utilise une référence constante je ne peux pas faire exemple
Code:

1 2 mIter = m.find(maillage+1);
Il me dit:

Citation:

135 no match for 'operator=' in 'mIter = (+m)->std::map<_Key, _Tp, _Compare, _Alloc>::find [with _Key = int, _Tp = std::vector<int, std::allocator<int> >, _Compare = std::less<int>, _Alloc = std::allocator<std::pair<const int, std::vector<int, std::allocator<int> > > >](((const int&)((const int*)(&((int)(maillage + 1u))))))'

Avant que j'utilise une référence constante ca fonctionnait pourtant...

Voici comment le code est fait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 void GL_MAILLAGE::OnPaint(wxCommantEvent& event) { //... const std::map<int,std::vector<int> > &m = p_frm->m_treeCtrl->GetToDraw(); const std::map<int,std::vector<int> >::iterator mIter; mIter = m.find(maillage+1); //... } Tree.h // ma fonction de retour: const std::map<int,std::vector<int> > &GetToDraw() { return todraw; } // ma variable map std::map<int,std::vector<int> > todraw;

Citation:
Envoyé par Rafy
Pour ce qui est du mécanisme.
Les références te permettent d'éviter des copie dans les passages de paramètres et dans les valeurs de retour.
Si tu renvoie une référence, il n'y aura pas de copie de faite de ce que tu retourne.
Pour ce qui est du passage des arguments, la aussi, passer une référence ne donnera pas à la fonction une copie de l'objet mais l'objet directement.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Objet Fonction(void) { Objet* MonObjet = new Objet; return MonObjet; } int i = Fonction().GetSize(); //La ca va copier MonObjet pour lancer la methode GetSize Objet& Fonction2(void) { Objet* MonObjet = new Objet; return MonObjet; } Fonction().GetSize(); //La ca ne va pas copier, ca sera le getsize de MonObjet qui sera appelé
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void Fonction(const Objet MonObjet) { int i = MonObjet.GetSize(); } Objet UnObjet; Fonction(UnObjet); //Ca va copier UnObjet puis GetSize sera appelé sur la copie. void Fonction2(const Objet& MonObjet) { int i = MonObjet.GetSize(); } Objet UnObjet; Fonction2(UnObjet); // Ca va apeller le GetSize de UnObjet
8O
Pour ton code, la Fonction et la Fonction2 sont fausses, tu fais trop de Java !
Si on tente de corriger ce que tu écris et qu'on ne veuille pas de fuite mémoire, on va créer une variable temporaire de type Objet. Eh bien, on ne pourra que la renvoyer par valeur, pas par référence.
Le deuxième bout de code fonctionne si GetSize() a bien un attribut constant.

03/05/2006, 15h15
Matthieu Brucher
Citation:
Envoyé par vdumont

Le problème que j'ai maintenant est que depuis que j'utilise une référence constante je ne peux pas faire exemple

Code:

1 2 mIter = m.find(maillage+1);

Il me dit:

Voici comment le code est fait:

Code:

1 2 const std::map<int,std::vector<int> >::iterator mIter;
Si tu déclares ton itérateur comme constant, ça va être difficile de lui assogner une nouvelle valeur ;)
03/05/2006, 15h22
vdumont
Oops mais j'avais rajouter const parce que ca ne fonctionnait pas avec le non-constant aussi :(

Je croyais que le const parcontre pour les itérateurs servaient à ce que on ne puisse pas modifier sur quoi l'itérateur pointe :aie:

Mais reste qu'avec
Code:

1 2 std::map<int,std::vector<int> >::iterator mIter;
Il plante toujours :(
03/05/2006, 15h24
loufoque
Citation:
Envoyé par vdumont

m = objet->GetToDraw() ???
*m = objet->GetToDraw() ???
&m = objet->GetToDraw() ???
Pourquoi objet est-il un pointeur ?
03/05/2006, 15h27
vdumont

Car je travail avec wxWidgets, ma classe MyFrame contient 2 objets pointeurs soient m_glCanvas et m_treeCtrl

Qui sont respectivement un canevas OpenGL et un TreeCtrl wxWidgets.

Le code est dans une fonction de ma classe GL_MAILLAGE (classe propriétaire de m_glCanvas)

Je dois cependant accéder à l'objet TreeCtrl donc

p_frm->m_treeCtrl->getToDraw(); // p_frm est le parent MyFrame*, m_treeCtrl l'objet.
03/05/2006, 15h48
Laurent Gomila

Citation:

Je croyais que le const parcontre pour les itérateurs servaient à ce que on ne puisse pas modifier sur quoi l'itérateur pointe

Pour ça, il faut déclarer un const_iterator.

:scarymov: J'avais complètement oublier le const_iterator, mais reste que j'arrive pas à trouver pourquoi je suis pas capable de compiler mon truc

Si je résume:

Code:

1
2
3
4
5
6
7
8
9
10
class MyTreeCtrl : public wxTreeCtrl 
{
   public:
     //...
     const std::map<int,std::vector<int> > &GetToDraw() { return todraw; }
   // ...
   private:
  std::map<int,std::vector<int> > todraw;
};

Code:

1
2
3
4
5
6
7
8
9
10
11
void GL_MAILLAGE::OnPaint(wxPaintEvent& event) 
{ 
          //...
          MyFrame* p_frm = (MyFrame*)this->GetParent(); 
          const std::map<int,std::vector<int> > &m = p_frm->m_treeCtrl->GetToDraw();       
          std::map<int,std::vector<int> >::iterator mIter;
 
          mIter = m.find(maillage+1);     // plante
        //...
}

03/05/2006, 15h56
Swoög

Salut !

tu as essayé un truc comme ça :

Code:

std::map<int,std::vector<int> >::const_iterator mIter;

? ;) ç'a peut-être plus de chance de marcher... (je dis ça comme ça...)
03/05/2006, 15h58
vdumont

:ave:

Merci! :yaisse2:

Dernière question: juste pour être sur que j'ai comprit:

- Ma map est constante, ce qui empêche de lui affecter une autre map par la suite? (Et par conséquence de complètement démolir la map qui est la source de la référence)

- Mon itérateur est constant, ce qui empêche de modifier les éléments à l'intérieur de la map?
03/05/2006, 16h00
Laurent Gomila

Citation:

Dernière question: est-il nécessaire de déclarer la map constante si l'itérateur lui est const_iterator?

Non, mais la réciproque est vraie par contre.
03/05/2006, 16h03
vdumont

Laurent tu as été très vite pour répondre car tout suite après voir envoyer mon poste je l'ai tout de suite éditer ahah

Mais:

- Ma map est constante, ce qui empêche de lui affecter une autre map par la suite ou de modifier des éléments à l'intérieur? Est-ce exact?

Exemple: je ne pourrais pas faire. MaMap["blablabla"] = 2; ni MaMap = UnAutreMap

- Mon itérateur est constant, ce qui empêche de modifier les éléments à l'intérieur de la map?

Exemple: je ne pourrais pas faire mIter->second = 5;
03/05/2006, 16h15
Swoög

Exactement vdumont, t'as tout compris là je pense ;)

en fait le fait que le conteneur (ici la map) soit constant induit le fait qu'il ne puisse fournir QUE des const_iterator, ce qui est sommes toutes logique ;)
03/05/2006, 16h47
vdumont

Merci à vous tous! :hola:

:)
03/05/2006, 16h48
Matthieu Brucher
Citation:
Envoyé par vdumont

Code:

1 2 const std::map<int,std::vector<int> >& GetToDraw() { return todraw;
Ca indique mieux que le type de retour est une référence, et non pas que GetToDraw en est une. Enfin, ça change rien puisque tu as résolu tes problèmes :D - que j'ai aussi souvent rencontré :aie::aie::aie::aie: -

Voir 40 message(s) de cette discussion en une page