Discussion :

[vdumont]

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 :

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

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

Code :

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

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!

[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 :

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

1
2
 
return maptodraw;

et tu pourra faire :

Code :

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

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.

[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 :

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

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

et ton constructeur de la classe recevante :

Code :

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

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 :

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

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 :

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

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

Code :

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

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

Code :

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

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

[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 :

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

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 :

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

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

[Rafy]

Considérons le code suivant :

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

[vdumont]

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 :

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

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

Il me dit:

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 :

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

[Matthieu Brucher]

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 :

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

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 :

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

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

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.

[Matthieu Brucher]

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 :

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

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

Il me dit:

Voici comment le code est fait:

Code :

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

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

[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


Mais reste qu'avec

Code :

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

1
2
 
std::map<int,std::vector<int> >::iterator mIter;

Il plante toujours

[loufoque]

1. m = objet->GetToDraw() ???
2. *m = objet->GetToDraw() ???
3. &m = objet->GetToDraw() ???

Pourquoi objet est-il un pointeur ?

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

[Laurent Gomila]

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.

[vdumont]

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 :

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

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 :

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

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

[Swoög]

Salut !

tu as essayé un truc comme ça :

Code :

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

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

? ç'a peut-être plus de chance de marcher... (je dis ça comme ça...)

[vdumont]

Merci!


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?

[Laurent Gomila]

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.

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

[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

[vdumont]

Merci à vous tous!

[Matthieu Brucher]

Code :

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

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 - que j'ai aussi souvent rencontré -