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

Question

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

Je viens de lui poser la question et aucun de nous deux ne se souvient de la raison pour laquelle l'insert est meilleur, mais je suis sûr qu'il ne s'agit pas simplement d'une préférence de style, mais plutôt d'une raison technique telle que l'efficacité. Les Référence SGI STL dit simplement : "Strictement parlant, cette fonction membre n'est pas nécessaire : elle n'existe que pour des raisons de commodité".

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

Answer 1

Lorsque vous écrivez

map[key] = value;

il n'y a aucun moyen de savoir si vous remplacés les value pour key ou si vous créé une nouvelle key con 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 préoccupe généralement pas de savoir si je crée ou si je remplace, et j'utilise donc l'option plus facile à lire map[key] = value .

Answer 2

Les deux ont des sémantiques différentes en ce qui concerne la clé déjà existante dans la carte. Ils ne sont donc pas directement comparables.

Mais la version de l'opérateur[] nécessite la construction par défaut de la valeur, puis l'affectation, de sorte que si cela est plus coûteux que la construction par copie, alors ce sera plus coûteux. Parfois, la construction par défaut n'a pas de sens, et il serait alors impossible d'utiliser la version operator[].

Answer 3

Une autre chose à noter concernant les std::map :

myMap[nonExistingKey]; créera une nouvelle entrée dans la carte, dont la clé est nonExistingKey initialisé à une valeur par défaut.

J'ai eu une peur bleue la première fois que je l'ai vu (en me cognant la tête contre un méchant bug de l'héritage). Je ne m'y attendais pas. Pour moi, cela ressemble à une opération de récupération, et je ne m'attendais pas à cet "effet secondaire". Préférer map.find() lors de l'obtention de votre carte.

Answer 4

Si l'impact sur les performances du constructeur par défaut n'est pas un problème, s'il vous plaît, pour l'amour de Dieu, choisissez la version la plus lisible.

)

Answer 5

Si la vitesse de votre application est critique, je vous conseille d'utiliser l'opérateur [] car il crée au total 3 copies de l'objet original, dont 2 sont des objets temporaires qui seront tôt ou tard détruits.

Mais dans insert(), 4 copies de l'objet original 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. L'allocation de la mémoire d'un objet 2. Un appel de constructeur supplémentaire 3. Un appel supplémentaire au destructeur 4. Une désallocation de la mémoire des objets

Si vos objets sont grands, que les constructeurs sont typiques et que les destructeurs libèrent beaucoup 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 sur la lisibilité, mais sur la vitesse. Voici un exemple de code qui m'a permis de comprendre 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;
}