Comment puis-je savoir si std::map insérer réussi ou échoué?

J'ai une carte, dans une application multithread mappage d'une classe appelée uuid de pointeur.
Ce que je veux savoir si une opération d'insertion réussi échoué.

par exemple

_mymap.insert(hint, MyMap::value_type(entry.uuid, itemptr));

T-il lever une exception ou quelque chose si elle ne parvient pas?

Essayé. Je ne pouvais pas trouvé d'exemples qui le montrent. Tous les exemples que supposer insérer réussit.

OriginalL'auteur Matt | 2011-02-24

  1. 14

    En fait de la méthode d'insertion qui prend un soupçon de paramètre ne retourne pas de savoir si l'insertion a réussi ou pas. Une façon de vérifier si l'insertion s'est réellement passé à vérifier la taille de la carte avant et après l'insertion. Si c'est la même chose, puis insérez-a échoué (c'est à dire la clé était déjà présent). Je sais que ça fait moche, mais c'est le moyen le plus efficace que je pouvais venir. En fait, je crois qu'il n'y a aucune raison que l'insert avec un soupçon ne doit pas renvoyer une paire (y compris le bool) tout comme le non-indicateur insérer ne. Mais une fois qu'il a été spécifiées dans une norme plus ancienne, il est très difficile de changer, puisque c'est une modification de rupture, dont le C++ pour la plupart de la communauté ressent.

    D'origine (mauvaise) réponse

    Voir ce lien

    ... retourne une paire, avec ses membres pair::first ensemble pour un itérateur pointant vers le nouvellement inséré l'élément ou de l'élément qui avaient déjà sa même valeur dans la carte. Le pair::second élément de la paire est définie sur true si un élément nouveau a été inséré ou false si un élément avec la même valeur existé.

    Le lien contient également un exemple

    Par exemple: 

    if(mp.insert(make_pair(key, value)).second == false)
{
   cout << "Insertion failed. Key was present"
}
    En fait, c'est incorrect. La méthode insert() avec un soupçon de paramètre ne renvoie pas une paire, mais seulement un itérateur.
    IMPORTANT: Si vous venez d'insérer un élément SANS l'indice de paramètre, utilisez la réponse dans le Voir ce lien. L'original de la réponse est incorrecte, car il est pour le cas où nous n'avons pas besoin de l'indice de paramètre, mais l'affiche de la question de l'indication. L'original de la réponse est PAS de mal, si nous n'avons pas besoin de l'indice, ce qui est souvent le cas.

    OriginalL'auteur Armen Tsirunyan

  2. 8
    typedef std::map<std::string, int> map;
map m;
std::pair<map::iterator,bool> result = m.insert(std::make_pair("hi", 42));

    résultat.deuxième contient ce que vous voulez

    OriginalL'auteur Tristram Gräbener

  3. 3

    Cela dépend de ce que tu veux dire par a échoué ou réussi.

    std::map::insert réussit lorsqu'il insère l'élément nouveau ou retourne un itérateur à un élément déjà existant.

    std::map::insertion échoue si il n'y a pas assez de mémoire pour insérer un nouvel élément et le jette std::bad_alloc.

    OriginalL'auteur FredV

  4. 2

    Oui, ce serait jeter de l'une des exceptions utilisé dans la STL, par exemple lorsque la mémoire est insuffisante. C'est en cas de échec.

    Ou avez-vous été également intéressés de savoir si l'élément était déjà contenue dans l'instance?

    OriginalL'auteur 0xC0000022L

  5. 1

    De la première insertion de la fonction membre
    renvoie une paire dont bool composant
    retourne true si l'insertion a été faite
    et false si la carte contient déjà des
    un élément dont la clé a un équivalent
    la valeur de la commande, et dont la
    itérateur composant renvoie l'adresse
    lorsqu'un nouvel élément est inséré ou
    lorsque l'élément se trouvait déjà.

    Pour accéder à l'itérateur composant d'un
    paire pr retourné par ce membre
    fonction, utiliser le pr.tout d'abord, et de
    déréférencement d'elle, l'utiliser *(pr.en premier lieu). Pour
    accéder au bool composant d'une paire de pr
    retourné par cette fonction membre, utilisez
    pr.seconde.

    L'insertion du deuxième fonction de membre de la
    indicateur de version, retourne un itérateur qui
    les points de la position où le nouveau
    l'élément est inséré dans la carte.

    Source: http://msdn.microsoft.com/en-us/library/81ac0zkz(v=vs. 80).aspx

    Ok, c'est assez difficile à comprendre. Pouvez-vous me donner un exemple. MS ne fait pas un que je peux voir.
    Je pense que ton lien est faux. Il pointe vers une page avec le titre "le Système de.Les Collections.Générique De L'Espace De Noms".
    Oui et je tiens à souligner que je suis en utilisant gcc sous linux. Espérons que tous les Lse sont créés égaux?
    Oh... Désolé! msdn.microsoft.com/en-us/library/81ac0zkz(v=vs. 80).aspx
    H: Oui, la STL est normalisée.

    OriginalL'auteur renanleandrof

  6. -1

    Insérer avec indication de la méthode d'une paire de la même première et d'une seconde que vous êtes sûr n'est pas dans la carte ( comme (size_t) -1 pour une carte de tailles par exemple ). Si l'itérateur renvoyé a cela s'avère impossible en valeur, il a été nouvellement insérée, si ce n'est qu'il a été trouvé dans la carte. L'itérateur renvoyé est alors modifié.
    Exemple : pour insérer des paires p (2, 4) et p (6, 5) dans la carte m ((0, 1), (2, 3), (4, 5)).

    int main (int argc, char* argv []) {
std::pair<size_t, size_t> tmp [3] = {
std::pair<size_t, size_t> (0, 1),
std::pair<size_t, size_t> (2, 3),
std::pair<size_t, size_t> (4, 5)
};
std::map<size_t, size_t> m ((std::pair<size_t, size_t>*) tmp, (std::pair<size_t, size_t>*) &tmp [3]);
std::cout << "initial map == ";
std::for_each (m.begin (), m.end (), [] (const std::pair<size_t, size_t>& p) {
std::cout << p.first << "->" << p.second << "   ";
});
std::cout << std::endl;
std::cout << std::endl;
{
//insertion of a pair of first already in map
std::cout << "insertion of pair 1 == std::pair<size_t, size_t> (2, 4) from second iterator" << std::endl;
std::map<size_t, size_t>::iterator ihint (m.begin ()), k (ihint); ++ihint;
std::pair<size_t, size_t> pfoo (2, (size_t) -1);
k = m.insert (ihint, pfoo);
if (k->second == (size_t) -1) {
std::cout << "\tthe pair was inserted" << std::endl;
k->second = 4;
}
else {
std::cout << "\ta pair with such a first was in the map" << std::endl;
}
}
std::cout << "m after insertion of pair 1 == ";
std::for_each (m.begin (), m.end (), [] (const std::pair<size_t, size_t>& p) {
std::cout << p.first << "->" << p.second << "   ";
});
std::cout << std::endl;
std::cout << std::endl;
{
//insertion of a pair of first not in map
std::cout << "insertion of pair 2 == std::pair<size_t, size_t> (6, 5) from third iterator" << std::endl;
std::map<size_t, size_t>::iterator ihint (m.begin ()), k (ihint); ++ihint; ++ihint;
std::pair<size_t, size_t> pfoo (6, (size_t) -1);
k = m.insert (ihint, pfoo);
if (k->second == (size_t) -1) {
std::cout << "\tthe pair was inserted" << std::endl;
k->second = 5;
}
else {
std::cout << "\ta pair with such a first in the map" << std::endl;
}
}
std::cout << "m after insertion of pair 2 == ";
std::for_each (m.begin (), m.end (), [] (const std::pair<size_t, size_t>& p) {
std::cout << p.first << "->" << p.second << "   ";
});
std::cout << std::endl;
}

    sorties :
    carte initiale == 0->1 2->3 4->5

    insertion de la paire 1 == std::pair (2, 4) à partir de la deuxième itérateur

    une paire avec un tel premier était dans la carte

    m après l'insertion de la paire 1 == 0->1 2->3 4->5

    insertion de la paire 2 == std::pair (6, 5) de la troisième itérateur

    la paire a été inséré

    m après l'insertion de la paire 2 == 0->1 2->3 4->5 6->5

    Comme ma réponse a été downvoted sans aucune explication, j'ai ajouté initiale de la construction de la carte, inséré deux paires (celui de la carte, qui n'est pas) et l'impression de l'indice résultats d'insertion. À l'aide de preincrementation, plus vite que la post-incrémentation. La carte j'utilise n'est plus appelé "carte", mais "m", alors il l'habitude de confondre les gens "using namespace std", mais juste "m". Modification de foo itérateur est effectuée dans le cas de l'insertion

    OriginalL'auteur Saint-Martin