std::map: est trouver(clé)-> - seconde plus rapide que l'opérateur []?

std::map<long, double> x;
x[5] = 1.2;

double y = x[5];
double z = x.find(5)->second;

De ces 2 missions s'exécutent plus rapidement que les autres? (en supposant que la clé est toujours présent sur la carte) Est-il des frais généraux associés à la référence de la variable d'itération lors x.find(5)->second ?

EDIT: Merci pour les réponses. Dans ma fonction en particulier, maintenant que je sais qu'il n'est pas plus lent, je vais probablement aller avec x.find(5)->second que j'ai besoin de marquer ma fonction const (la carte est une variable de membre) et la [] opérateur ne lui permet évidemment pas que (comme potentiellement modifie la carte est une clé est manquante).

OriginalL'auteur Laurent | 2011-02-20

c++map stl

A eu ce directement à partir de <map>:

mapped_type& operator[](const key_type& _Keyval)
    {   //find element matching _Keyval or insert with default mapped
    iterator _Where = this->lower_bound(_Keyval);
    if (_Where == this->end()
        || this->comp(_Keyval, this->_Key(_Where._Mynode())))
        _Where = this->insert(_Where,
            value_type(_Keyval, mapped_type()));
    return ((*_Where).second);
    }

iterator find(const key_type& _Keyval)
    {   //find an element in mutable sequence that matches _Keyval
    iterator _Where = lower_bound(_Keyval);
    return (_Where == end()
        || _DEBUG_LT_PRED(this->comp,
            _Keyval, _Key(_Where._Mynode()))
                ? end() : _Where);
    }

Il a l'air d'avoir le même. Devrait-il y avoir une différence entre:

iterator _Where = this->lower_bound(_Keyval);
return ((*_Where).second);

iterator i = x.find(5);
double d = (*i).second;

Je ne le pense pas.

OriginalL'auteur Marlon

12

Ce n'est pas la réponse à votre question, mais je tiens à souligner un problème avec la façon dont vous utilisez find.
```
double y = x[5];
double z = x.find(5)->second;
```
Je ne peux pas commenter sur ce qui est plus rapide. Mais je peux certainement dire que la première approche est sûr!

Que si la carte ne contient pas la clé donnée?

Dans la première approche, il créer une nouvelle pair avec le clé, et d'initialiser le valeur avec la valeur par défaut de double (qui est nulle), et le retourner.

Mais la deuxième approche? find sera de retour map::end si la clé n'est pas trouvée dans le conteneur, et vous êtes un déréférencement. Plantage du programme!

La façon correcte d'utiliser find est:
```
std::map<long, double>::iterator it;    
if ( (it = x.find(key)) != x.end() )
{
    double value = it->second;
}
```
La raison? Afin que je puisse les corriger moi-même.
Je n'ai pas downvote vous (en fait, je vous ai donné +1), mais une seule pensée, c'est qu'il peut-être très subjectif qui de la condition d'erreur des résultats est meilleure. Peut-être que vous ne voulez pas en silence créer de nouvelles valeurs dans la carte et préfère traiter avec une exception/comparer à map::end/whatever. Cela dépend de votre cas d'utilisation.
Je n'ai pas downvote vous, mais il n'a pas vraiment répondre à l'OP de la question.
Je n'ai pas downvote, mais je ne peux penser à un couple de raisons que quelqu'un peut avoir. (1) Dans ce cas, l'interlocuteur n'a-dire de supposer que la clé serait présent. (2) La question est de savoir sur qui est plus rapide, pas qui est "plus sûr". (3) Le cas de l'échec silencieux n'est pas nécessairement "plus sûr" que de ne pas spectaculaire. C'est de cette façon missiles accidentellement lancé.
Je ne le dis pas répondre à la question. J'ai d'expliquer le problème avec l'extrait de code.

OriginalL'auteur Nawaz
2

À la première affectation à l'aide de operator[] aurez à effectuer la même déréférencer pour récupérer la valeur qui est explicite dans find()->second. Vous pouvez le profil pour être sûr, mais la performance devrait être assez proche que vous devez utiliser le formulaire qui est plus clair dans votre code.

OriginalL'auteur Blastfurnace

Vous devez vous connecter pour publier un commentaire.