En C++, quel est le type d'un std::map<>::iterator
?
Nous savons qu'un objet it
de type std::map<A,B>::iterator
a un operator ->
surchargé qui retourne un std::pair<A,B>*
et que le std::pair<>
a un first
et second
membre.
Mais, à quoi correspondent ces deux membres et pourquoi devons-nous accéder à la valeur stockée dans la carte sous la forme it->second
?
Je suis sûr que vous savez qu'un _std::vector<X>
_ stocke tout un tas d'objets X
, n'est-ce pas? Mais si vous avez un _std::map<X, Y>
_, il enregistre en réalité un tas de _std::pair<const X, Y>
_ s. C'est exactement ce qu'est une carte: elle associe les clés et les valeurs associées.
Lorsque vous parcourez un _std::map
_, vous parcourez tous ces _std::pair
_ s. Lorsque vous déréférencez l'un de ces itérateurs, vous obtenez un _std::pair
_ contenant la clé et sa valeur associée.
_std::map<std::string, int> m = /* fill it */;
auto it = m.begin();
_
Ici, si vous faites maintenant _*it
_, vous obtiendrez le _std::pair
_ pour le premier élément de la carte.
Maintenant, le type std::pair
vous donne accès à ses éléments via deux membres: first
et second
. Donc, si vous avez un _std::pair<X, Y>
_ appelé p
, _p.first
_ est un objet X
et _p.second
_ est un objet Y
.
Ainsi, vous savez maintenant que le déréférencement d'un itérateur _std::map
_ vous donne un _std::pair
_, vous pouvez ensuite accéder à ses éléments avec first
et second
. Par exemple, _(*it).first
_ vous donnera la clé et _(*it).second
_ vous donnera la valeur. Celles-ci sont équivalentes à _it->first
_ et _it->second
_.
Le type des éléments d'un std::map
(qui est également le type d'une expression obtenue en déréférencant un itérateur de cette carte) dont la clé est K
et la valeur V
est std::pair<const K, V>
_ - la touche const
vous évite d'interférer avec le tri interne des valeurs de la carte.
std::pair<>
a deux membres nommés first
et second
(voir ici ), avec une signification assez intuitive. Ainsi, étant donné un itérateur i
vers une certaine carte, l'expression:
i->first
Ce qui équivaut à:
(*i).first
Fait référence à l'élément premier (const
) de l'objet pair
pointé par l'itérateur - c'est-à-dire qu'il fait référence à un clé dans la carte. Au lieu de cela, l'expression:
i->second
Ce qui équivaut à:
(*i).second
Fait référence à l'élément deuxième de la pair
- c'est-à-dire à la valeur correspondante sur la carte.