Pour le moment, ma solution consiste à parcourir la carte pour résoudre ce problème.
Je vois qu'il y a un upper_bound
méthode qui peut rendre cette boucle plus rapide, mais existe-t-il un moyen plus rapide ou plus succinct?
La fin:
m.rbegin();
Maps (et les ensembles) sont triés, donc le premier élément est le plus petit et le dernier élément est le plus grand. Par défaut, les cartes utilisent std::less
, mais vous pouvez changer le comparateur et cela changerait bien sûr la position du plus grand élément. (Par exemple, utiliser std::greater
le placerait dans begin()
.
Gardez à l'esprit que rbegin
renvoie un itérateur. Pour obtenir la clé réelle, utilisez m.rbegin()->first
. Vous pourriez l'envelopper dans une fonction pour plus de clarté, bien que je ne sois pas sûr que cela en vaille la peine:
template <typename T>
inline const typename T::key_type& last_key(const T& pMap)
{
return pMap.rbegin()->first;
}
typedef std::map</* types */> map_type;
map_type myMap;
// populate
map_type::key_type k = last_key(myMap);
Les entrées dans un std :: map sont triées, donc pour un std :: map m (en supposant que m.empty()
est faux), vous pouvez facilement obtenir la plus grande clé: (--m.end())->first
Comme std :: map est un tableau associatif, on peut facilement trouver la plus grande ou la plus petite clé très facilement. Par défaut, la fonction de comparaison est un opérateur moins (<), donc la plus grande clé sera le dernier élément de la carte. De même, si quelqu'un a des exigences différentes, n'importe qui peut modifier la fonction de comparaison lors de la déclaration de la carte.
std :: map <clé, valeur, comparer <clé, valeur>>
Par défaut, compare = std :: less