Quelle est la différence entre std :: multimap <key, value> et std :: map <key, std :: set <value>>

J'ai trouvé qu'ils avaient une clé et plusieurs valeurs uniques.

La multi-carte stocke des paires de (clé, valeur) où la clé et la valeur peuvent apparaître plusieurs fois.

Le map<key, set<value>>ne stockera chaque valeur qu'une seule fois pour une clé spécifique. Pour ce faire, il devra pouvoir comparer les valeurs, pas seulement les clés.

Cela dépend de votre application si les valeurs qui se comparent sont équivalentes ou si vous souhaitez quand même les stocker séparément. Peut-être qu'ils contiennent des champs différents mais qui ne participent pas à la comparaison de l'ensemble.

A std::mapest un conteneur associatif, qui vous permet d'avoir une clé unique associée à votre valeur de type. Par exemple,

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::multimapest égal à a std::map, mais vos clés ne sont plus uniques. Par conséquent, vous pouvez trouver une gamme d'articles au lieu de trouver un seul article unique. Par exemple,

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

Le std::setest comme un std::map, mais il ne stocke pas une clé associée à une valeur. Il stocke uniquement le type de clé et vous assure qu'il est unique dans l'ensemble.

Vous avez également le std::multiset, qui suit le même modèle.

Tous ces conteneurs fournissent un accès O (log (n)) avec leur find / equal_range.

map::insert

Étant donné que les mapconteneurs n'autorisent pas les valeurs de clé en double, l'opération d'insertion vérifie pour chaque élément inséré si un autre élément existe déjà dans le conteneur avec la même valeur de clé, si tel est le cas, l'élément n'est pas inséré et sa valeur mappée n'est en aucun cas modifiée.

d'autre part

multimap::insert 

peut insérer n'importe quel nombre d'éléments avec la même clé.

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

Ce dernier nécessite que les valeurs puissent être ordonnées (via operator<ou une fonction de comparaison), le premier ne le fait pas.