Nelle mappe STL, è meglio usare map :: insert che []?

Qualche tempo fa, ho avuto una discussione con un collega su come inserire valori nelle mappe STL . Ho preferito map[key] = value; perché sembra naturale ed è chiaro da leggere mentre preferiva map.insert(std::make_pair(key, value))

Gliel'ho appena chiesto e nessuno dei due riesce a ricordare il motivo per cui l'inserto è migliore, ma sono sicuro che non fosse solo una preferenza di stile, bensì un motivo tecnico come l'efficienza. Il riferimento SGI STL dice semplicemente "A rigor di termini, questa funzione membro non è necessaria: esiste solo per comodità."

Qualcuno può dirmi quel motivo o sto solo sognando che ce n'è uno?

Quando scrivi

map[key] = value;

non c'è modo di sapere se hai sostituito il valuefor keyo se ne hai creato uno nuovo keycon value.

map::insert() creerà solo:

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;
}

Per la maggior parte delle mie app, di solito non mi interessa se sto creando o sostituendo, quindi uso la più facile da leggere map[key] = value.

I due hanno una semantica diversa quando si tratta della chiave già esistente nella mappa. Quindi non sono realmente direttamente comparabili.

Ma la versione dell'operatore [] richiede di costruire il valore per impostazione predefinita e quindi di assegnarlo, quindi se questo è più costoso della copia della costruzione, allora sarà più costoso. A volte la costruzione di default non ha senso, e quindi sarebbe impossibile usare la versione dell'operatore [].

Un'altra cosa da notare con std::map:

myMap[nonExistingKey];creerà una nuova voce nella mappa, impostata su nonExistingKeyinizializzata su un valore predefinito.

Questo mi ha spaventato a morte la prima volta che l'ho visto (mentre sbattevo la testa contro un insetto brutto lascito). Non me lo sarei aspettato. Per me, sembra un'operazione get, e non mi aspettavo "l'effetto collaterale". Preferisci map.find()quando arrivi dalla tua mappa.

Se l'hit prestazionale del costruttore predefinito non è un problema, per favore, per amore di Dio, scegli la versione più leggibile.

:)

insert è migliore dal punto di vista della sicurezza.

L'espressione map[key] = valueè in realtà due operazioni:

1. map[key] - creazione di un elemento della mappa con valore predefinito.
2. = value - copiando il valore in quell'elemento.

Un'eccezione può verificarsi nel secondo passaggio. Di conseguenza l'operazione verrà eseguita solo parzialmente (un nuovo elemento è stato aggiunto alla mappa, ma quell'elemento non è stato inizializzato con value). La situazione in cui un'operazione non è completa, ma lo stato del sistema viene modificato, viene chiamata operazione con "effetto collaterale".

insertoperazione fornisce una forte garanzia, significa che non ha effetti collaterali ( https://en.wikipedia.org/wiki/Exception_safety ). insertè completamente completato o lascia la mappa in uno stato non modificato.

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

Se deve essere inserito un singolo elemento, non ci sono cambiamenti nel contenitore in caso di eccezione (garanzia forte).

Se la tua applicazione è fondamentale per la velocità, ti consiglio di utilizzare l'operatore [] perché crea un totale di 3 copie dell'oggetto originale, di cui 2 sono oggetti temporanei e prima o poi distrutti come.

Ma in insert (), vengono create 4 copie dell'oggetto originale, di cui 3 sono oggetti temporanei (non necessariamente "temporanei") e vengono distrutti.

Ciò significa tempo extra per: 1. Allocazione di memoria di un oggetto 2. Chiamata di un costruttore supplementare 3. Chiamata di un distruttore supplementare 4. Deallocazione di memoria di un oggetto

Se i tuoi oggetti sono grandi, i costruttori sono tipici, i distruttori fanno molta liberazione delle risorse, i punti sopra contano ancora di più. Per quanto riguarda la leggibilità, penso che entrambi siano abbastanza equi.

Mi è venuta in mente la stessa domanda, ma non oltre la leggibilità ma la velocità. Ecco un codice di esempio attraverso il quale sono venuto a conoscenza del punto che ho citato.

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;
}

Ora in c ++ 11 penso che il modo migliore per inserire una coppia in una mappa STL sia:

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

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

Il risultato sarà una coppia con:

• Primo elemento (risultato prima), punta alla coppia inserita o punta alla coppia con questa chiave se la chiave esiste già.

• Secondo elemento (risultato.secondo), vero se l'inserimento è corretto o falso qualcosa è andato storto.

PS: Se non fai caso sull'ordine puoi usare std :: unordered_map;)

Grazie!

Un gotcha con map :: insert () è che non sostituirà un valore se la chiave esiste già nella mappa. Ho visto il codice C ++ scritto dai programmatori Java in cui si aspettavano che insert () si comportasse allo stesso modo di Map.put () in Java, dove i valori vengono sostituiti.

Una nota è che puoi anche usare Boost.Assign :

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);
}

Ecco un altro esempio, che mostra che operator[] sovrascrive il valore per la chiave se esiste, ma .insert non sovrascrive il valore se esiste.

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 ) ;

}

Questo è un caso piuttosto limitato, ma a giudicare dai commenti che ho ricevuto penso che valga la pena notare.

Ho visto persone in passato usare le mappe sotto forma di

map< const key, const val> Map;

per eludere i casi di sovrascrittura accidentale del valore, ma poi andare avanti scrivendo in alcuni altri bit di codice:

const_cast< T >Map[]=val;

La loro ragione per farlo, come ricordo, era perché erano sicuri che in questi certi frammenti di codice non avrebbero sovrascritto i valori delle mappe; quindi, andando avanti con il metodo più "leggibile" [].

In realtà non ho mai avuto problemi diretti con il codice che è stato scritto da queste persone, ma fino ad oggi mi sento fermamente convinto che i rischi - per quanto piccoli - non dovrebbero essere presi quando possono essere facilmente evitati.

Nei casi in cui hai a che fare con valori di mappe che non devono assolutamente essere sovrascritti, usa insert. Non fare eccezioni solo per la leggibilità.

Il fatto che la funzione std :: map insert()non sovrascriva il valore associato alla chiave ci consente di scrivere codice di enumerazione oggetti come questo:

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

È un problema piuttosto comune quando è necessario mappare diversi oggetti non univoci su alcuni ID nell'intervallo 0..N. Tali ID possono essere successivamente utilizzati, ad esempio, negli algoritmi grafici. Alternativa con operator[]sarebbe meno leggibile secondo me:

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