Dans les cartes STL, est-il préférable d'utiliser map :: insert que []?

Il y a quelque temps, j'ai eu une discussion avec un collègue sur la façon d'insérer des valeurs dans les cartes STL . J'ai préféré map[key] = value; parce que ça semble naturel et clair à lire alors qu'il préférait map.insert(std::make_pair(key, value))

Je viens de lui demander et aucun de nous ne peut se souvenir de la raison pour laquelle l'insert est meilleur, mais je suis sûr que ce n'était pas seulement une préférence de style mais plutôt une raison technique comme l'efficacité. La référence SGI STL dit simplement "Strictement parlant, cette fonction membre n'est pas nécessaire: elle n'existe que par commodité."

Quelqu'un peut-il me dire cette raison, ou est-ce que je rêve juste qu'il y en ait une?

Quand tu écris

map[key] = value;

il n'y a aucun moyen de savoir si vous avez remplacé le valuefor keyou si vous en avez créé un nouveau keyavec value.

map::insert() ne fera que créer:

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
// ...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

Pour la plupart de mes applications, je ne me soucie généralement pas de créer ou de remplacer, donc j'utilise le plus facile à lire map[key] = value.

Les deux ont une sémantique différente en ce qui concerne la clé déjà existante dans la carte. Ils ne sont donc pas vraiment directement comparables.

Mais la version de l'opérateur [] nécessite la construction par défaut de la valeur, puis l'attribution, donc si c'est plus cher que la construction de copie, alors ce sera plus cher. Parfois, la construction par défaut n'a pas de sens, et il serait alors impossible d'utiliser la version opérateur [].

Une autre chose à noter avec std::map:

myMap[nonExistingKey];créera une nouvelle entrée dans la carte, codée pour nonExistingKeyinitialisée à une valeur par défaut.

Cela m'a effrayé la première fois que je l'ai vu (tout en me cognant la tête contre un bug méchant). Je ne m'y serais pas attendu. Pour moi, cela ressemble à une opération get, et je ne m'attendais pas à «l'effet secondaire». Préférez map.find()lors de l'obtention de votre carte.

Si les performances du constructeur par défaut ne sont pas un problème, veuillez, pour l'amour de Dieu, opter pour la version plus lisible.

:)

insert est meilleur du point de vue de la sécurité d'exception.

L'expression map[key] = valueest en fait deux opérations:

1. map[key] - création d'un élément de carte avec la valeur par défaut.
2. = value - copier la valeur dans cet élément.

Une exception peut se produire à la deuxième étape. En conséquence, l'opération ne sera que partiellement effectuée (un nouvel élément a été ajouté à la carte, mais cet élément n'a pas été initialisé avec value). La situation où une opération n'est pas terminée, mais l'état du système est modifié, est appelée l'opération avec «effet secondaire».

insertl'opération donne une forte garantie, signifie qu'elle n'a pas d'effets secondaires ( https://en.wikipedia.org/wiki/Exception_safety ). insertest soit complètement terminé, soit il laisse la carte dans un état non modifié.

http://www.cplusplus.com/reference/map/map/insert/ :

Si un seul élément doit être inséré, il n'y a pas de changement dans le conteneur en cas d'exception (garantie forte).

Si votre application est critique en termes de vitesse, je vous conseillerai d'utiliser l'opérateur [] car elle crée au total 3 copies de l'objet d'origine dont 2 sont des objets temporaires et tôt ou tard détruits au fur et à mesure.

Mais dans l'insert (), 4 copies de l'objet d'origine sont créées dont 3 sont des objets temporaires (pas nécessairement "temporaires") et sont détruites.

Ce qui signifie du temps supplémentaire pour: 1. Une allocation de mémoire d'objets 2. Un appel de constructeur supplémentaire 3. Un appel de destructeur supplémentaire 4. Une désallocation de mémoire d'objets

Si vos objets sont grands, les constructeurs sont typiques, les destructeurs font beaucoup de libération de ressources, les points ci-dessus comptent encore plus. En ce qui concerne la lisibilité, je pense que les deux sont assez justes.

La même question m'est venue à l'esprit mais pas la lisibilité mais la vitesse. Voici un exemple de code grâce auquel j'ai appris le point que j'ai mentionné.

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

Maintenant, en c ++ 11, je pense que la meilleure façon d'insérer une paire dans une carte STL est:

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

Le résultat sera une paire avec:

• Premier élément (result.first), pointe vers la paire insérée ou pointe vers la paire avec cette clé si la clé existe déjà.

• Deuxième élément (result.second), vrai si l'insertion était correcte ou fausse si quelque chose s'est mal passé.

PS: Si vous ne vous souciez pas de la commande, vous pouvez utiliser std :: unordered_map;)

Merci!

Un gotcha avec map :: insert () est qu'il ne remplacera pas une valeur si la clé existe déjà dans la carte. J'ai vu du code C ++ écrit par des programmeurs Java où ils s'attendaient à ce que insert () se comporte de la même manière que Map.put () en Java où les valeurs sont remplacées.

Une remarque est que vous pouvez également utiliser Boost .

using namespace std;
using namespace boost::assign; // bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

Voici un autre exemple, montrant que operator[] remplace la valeur de la clé si elle existe, mais .insert ne remplace pas la valeur si elle existe.

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

C'est un cas assez restreint, mais à en juger par les commentaires que j'ai reçus, je pense que cela vaut la peine d'être noté.

J'ai déjà vu des gens utiliser des cartes sous forme de

map< const key, const val> Map;

pour éviter les cas d'écrasement accidentel de valeur, mais continuez à écrire dans d'autres bits de code:

const_cast< T >Map[]=val;

Si je me souviens bien, c'est parce qu'ils étaient sûrs que dans ces certains morceaux de code, ils n'écraseraient pas les valeurs de la carte; par conséquent, aller de l'avant avec la méthode plus «lisible» [].

En fait, je n'ai jamais eu de problème direct avec le code qui a été écrit par ces personnes, mais je pense fermement jusqu'à aujourd'hui que les risques - aussi petits soient-ils - ne devraient pas être pris lorsqu'ils peuvent être facilement évités.

Dans les cas où vous avez affaire à des valeurs de carte qui ne doivent absolument pas être écrasées, utilisez insert. Ne faites pas d'exceptions simplement pour la lisibilité.

Le fait que la fonction std :: map insert()n'écrase pas la valeur associée à la clé nous permet d'écrire du code d'énumération d'objet comme ceci:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

C'est un problème assez courant lorsque nous devons mapper différents objets non uniques à certains identifiants dans la plage 0..N. Ces identifiants peuvent être utilisés ultérieurement, par exemple, dans des algorithmes de graphe. Une alternative avec operator[]semblerait moins lisible à mon avis:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
}