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

Ho scoperto che hanno una chiave e più valori che sono unici.

La multimappa memorizza coppie di (chiave, valore) in cui sia la chiave che il valore possono apparire più volte.

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

Dipende dalla tua applicazione se i valori che si confrontano sono equivalenti o se desideri comunque memorizzarli separatamente. Forse contengono campi diversi ma non prendono parte al confronto per l'insieme.

A std::mapè un contenitore associativo, che ti consente di avere una chiave univoca associata al valore del tuo tipo. 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;
}

A std::multimapè uguale a a std::map, ma le tue chiavi non sono più uniche. Pertanto puoi trovare una gamma di articoli invece di trovare solo un oggetto unico. Per 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;
}

L' std::setè come unstd::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 schema.

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

map::insert

Poiché i mapcontenitori non consentono valori di chiave duplicati, l'operazione di inserimento verifica per ogni elemento inserito se esiste già un altro elemento nel contenitore con lo stesso valore di chiave, in tal caso l'elemento non viene inserito e il suo valore mappato non viene modificato in alcun modo.

d'altra parte

multimap::insert 

può inserire un numero qualsiasi di elementi con la stessa chiave.

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

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