Qual è la differenza tra std :: multimap <key, value> e std :: map <chiave, std :: set <value>>

Question

Ho scoperto che hanno una chiave e più valori che è univoco.

Answer 1

Il multimap memorizza coppie di (chiave, valore) in cui sia la chiave che il valore possono apparire diverse volte.

map<key, set<value>> memorizzerà ogni valore solo una volta per un tasto specifico. Per fare ciò, dovrà essere in grado di confrontare i valori, non solo le chiavi.

Dipende dall'applicazione se i valori che si equivalgono sono equivalenti o se si desidera memorizzarli separatamente. Forse contengono campi diversi ma non prendono parte al confronto per il set.

Answer 2

Quest'ultimo richiede che i valori possano essere ordinati (tramite operator< o una funzione di confronto), il primo no.

Answer 3

map::insert 

Poiché map contenitori non consentono valori di chiave duplicati, le verifiche di funzionamento inserimento di ciascun elemento inserito anche un altro elemento esiste già nel contenitore con lo stesso valore di chiave in tal caso, l'elemento non è inserita e la sua mappato il valore non è cambiato in alcun modo.

invece

multimap::insert 

possibile inserire un numero qualsiasi di elementi con la stessa chiave.

http://www.cplusplus.com/reference/stl/map/
http://www.cplusplus.com/reference/stl/multimap/

Answer 4

Un std::map è un contenitore associativo, che permette di avere una chiave univoca associato al tuo tipo di valore. Per esempio,

void someFunction() 
{ 
    typedef std::map<std::string, int> MapType; 
    MapType myMap; 

    // insertion 
    myMap.insert(MapType::value_type("test", 42)); 
    myMap.insert(MapType::value_type("other-test", 0)); 

    // search 
    auto it = myMap.find("test"); 
    if (it != myMap.end()) 
     std::cout << "value for " << it->first << " is " << it->second << std::endl; 
    else 
     std::cout << "value not found" << std::endl; 
} 

Un std::multimap è uguale a un std::map, ma le chiavi non sono più unici. Pertanto puoi trovare una gamma di articoli invece di trovare solo un oggetto unico. Ad esempio,

void someFunction() 
{ 
    typedef std::multimap<std::string, int> MapType; 
    MapType myMap; 

    // insertion 
    myMap.insert(MapType::value_type("test", 42)); 
    myMap.insert(MapType::value_type("test", 45)); 
    myMap.insert(MapType::value_type("other-test", 0)); 

    // search 
    std::pair<auto first, auto second> range = myMap.equal_range("test"); 
    for (auto it = range.first; it != range.second; ++it) 
     std::cout << "value for " << it->first << " can be " << it->second << std::endl; 
} 

Il std::set è come un std::map, ma non sta memorizzando un tasto associato a un valore. Memorizza solo il tipo di chiave e ti assicura che è univoco all'interno del set.

Hai anche il std::multiset, che segue lo stesso modello.

Tutti questi contenitori forniscono un accesso O (log (n)) con il loro find/equal_range.