Pourquoi ne puis-je stocker des références dans un std::map` en C++?

Je comprends que les références ne sont pas des pointeurs, mais un alias à un objet. Cependant, je ne comprends toujours pas exactement ce que cela signifie pour moi, en tant que programmeur, c'est à dire quelles sont les références sous le capot?

Je pense que la meilleure façon de comprendre ce serait de comprendre pourquoi il est je ne peut pas stocker une référence à une carte.

Je sais que je dois arrêter de penser de références comme syntaxiques suger sur les pointeurs, juste ne sais pas comment faire :/

Ne pense pas que de références que la restriction de pointeurs. Pensez à eux comme des alias pour les objets existants qui ne sont pas autorisés à être laissés ballants.

InformationsquelleAutor ng5000 | 2009-10-09

c++dictionary reference std stdmap

27

Ils façon dont je le comprends, les références sont mis en œuvre à titre indicatif sous le capot. La raison pour laquelle vous ne pouvez pas stocker dans une carte est purement sémantique; vous devez les initialiser une référence quand il est créé et vous ne pouvez pas le modifier par la suite plus. Ce n'est pas de maillage avec la façon dont une carte œuvres.
- Pensez-vous des références de prendre de la "mémoire"? Je sais que les pointeurs ne.
- oui, ils le font. Dans le code assembleur généré ils sont mis en œuvre comme des pointeurs.
- Il est explicitement spécifiée dans la norme si ils ont de stockage ou non. Généralement ils le font, mais parfois il peut être optimisé à l'écart.
InformationsquelleAutor Sebastiaan M
22

Vous devriez penser à une référence comme un "const pointeur vers un non-const objet":
```
MyObject& ~~ MyObject * const
```
En outre, une référence ne peut être construit comme un alias de quelque chose qui existe (ce qui n'est pas nécessaire pour un pointeur, bien que souhaitable en dehors de NULL). Cela ne garantit pas que l'objet va rester autour de (et en effet, vous pourriez avoir un noyau lors de l'accès à un objet par le biais d'un renvoi, si elle n'est pas plus), pensez à ce code:
```
//Falsifying a reference
MyObject& firstProblem = *((MyObject*)0);
firstProblem.do(); //undefined behavior

//Referencing something that exists no more
MyObject* anObject = new MyObject;
MyObject& secondProblem = *anObject;
delete anObject;
secondProblem.do(); //undefined behavior
```
Maintenant, il y a deux conditions pour un conteneur STL:
- T doivent être par défaut constructible (une référence n'est pas)
- T doit être cédé (vous ne pouvez pas réinitialiser une référence, si vous pouvez attribuer à son arbitre)
Donc, dans des conteneurs STL, vous devez utiliser des proxys ou des pointeurs.

Maintenant, à l'aide de pointeurs pourrait s'avérer problématique pour la gestion de la mémoire, de sorte que vous peut-être:
- utiliser des pointeurs intelligents (boost::shared_ptr par exemple)
- utiliser un conteneur spécialisé: Boost Pointeur Contenant De La Bibliothèque
NE PAS utiliser auto_ptr, il y a un problème avec affectation, car il modifie la main droite opérande.

Espère que cela aide 🙂
- Point mineur: Ce MyObject& firstProblem = *((MyObject*)0); est déjà un comportement indéfini (vous n'êtes pas initalizing la référence à un objet valide) et donc ce qui est, selon la norme C++, a permis de formater votre disque dur ou faire d'autres choses mauvaises pour vous. (Nasale démons, anyone?) Mais c'est un point mineur, et sinon, la vôtre est une excellente réponse. +1
- Un autre petit point: il me semble que par défaut-constructibility n'est pas une obligation (à l'exception de certaines méthodes utilisent par défaut construit instance de l'argument par défaut). (20.1.4.1) je pense que tu voulais dire copierconstructible.
- Exact, pour conteneur STL en général, il n'est pas nécessaire (conceptuellement). Pour une carte, et non pas à l'aide d'un Défaut Constructible valeur à invalider l'utilisation de l'abonnement de l'opérateur (-> operator[]) si... et personnellement, j'ai un message d'erreur dans VC++2008 si j'essaie d'utiliser un type qui n'est pas par défaut constructible: "erreur C2512: 'Spécial::Spécial": il n'y a pas de constructeur par défaut disponible"
InformationsquelleAutor Matthieu M.
7

L'importante différence à part le sucre syntaxique est que les références ne peuvent pas être modifiée pour faire référence à un autre objet que celui qu'ils ont été initialisés avec. C'est pourquoi ils ne peuvent pas être stockés dans les cartes ou dans d'autres contenants, parce que les conteneurs doivent être en mesure de modifier le type de l'élément qu'ils contiennent.

Comme une illustration de ceci:
```
A anObject, anotherObject;
A *pointerToA=&anObject;
A &referenceToA=anObject;

//We can change pointerToA so that it points to a different object
pointerToA=&anotherObject;

//But it is not possible to change what referenceToA points to.
//The following code might look as if it does this... but in fact,
//it assigns anotherObject to whatever referenceToA is referring to.
referenceToA=anotherObject;
//Has the same effect as
//anObject=anotherObject;
```
- Cela semble bon pour moi, sauf pour les "contenants doivent être en mesure de modifier le type de l'élément qu'ils contiennent." Cela donne l'impression que la carte doit être en mesure de modifier le type de données qu'elle stocke, alors que vraiment il a juste besoin d'être en mesure de changer le "élément" lui-même.
InformationsquelleAutor Martin B
3

en fait, vous pouvez utiliser des références dans une carte. je ne le recommande pas pour les gros projets car il pourrait causer bizarre erreurs de compilation mais:
```
    map<int, int&> no_prob;
    int refered = 666;
    no_prob.insert(std::pair<int, int&>(0, refered)); //works
    no_prob[5] = 777; //wont compile!!! 
    //builds default for 5 then assings which is a problem
    std::cout << no_prob[0] << std::endl; //still a problem
    std::cout << no_prob.at(0) << std::endl; //works!!
```
de sorte que vous pouvez utiliser la carte, mais il sera difficile de garantir qu'il sera utilisé correctement, mais je l'utilise pour les petits codes (généralement concurrentiel) codes

InformationsquelleAutor Eytan

Un conteneur qui stocke une référence a pour initialiser tous ses éléments lors de sa construction et, par conséquent, est moins utile.

struct container
{
   string& s_;           //string reference
};

int main()
{
   string s { "hello" };
   //container {};       //error - object has an uninitialized reference member
   container c { s };    //Ok
   c.s_ = "bye";
   cout << s;            //prints bye
}

Aussi, une fois initialisé, le stockage des éléments conteneur ne peut pas être modifié. s_ sera toujours reportez-vous à l'espace de stockage de s ci-dessus.

InformationsquelleAutor tcb

0

Ce post explique comment les pointeurs sont mises en œuvre sous le capot - http://www.codeproject.com/KB/cpp/References_in_c__.aspx, qui prend également en charge sebastians réponse.
- Il y a quelques erreurs avec le document référencé. Pour l'une des références ne sont pas nécessairement constants pointeurs (ils peuvent être mis en œuvre en ce sens). Voir jefito les commentaires en bas.
InformationsquelleAutor Chethan Ravindranath

Vous devez vous connecter pour publier un commentaire.