我如何知道 std::map 插入成功还是失败？

Question

我在多线程应用程序中有一个映射，将名为 uuid 的类映射到指针。 我想知道插入操作是否成功或失败。

例如，

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

如果失败，它会抛出异常或其他异常吗？

Answer 1

事实上，带有提示参数的插入方法不会返回插入是否成功。检查插入是否实际发生的一种方法是检查插入前后地图的大小。如果相同，则插入失败（即密钥已经存在）。我知道这听起来很丑陋，但这是我能想到的最有效的方法。事实上，我认为没有令人信服的理由表明带有提示的插入不应像常规的非提示插入那样返回一对（包括布尔值）。但是，一旦在较旧的标准中指定了它，就很难更改，因为这是一个重大更改，而 C++ 社区大多对此表示不满。

原始（错误）答案

查看此链接

...返回一对，其中它的成员pair::first设置为一个迭代器，该迭代器指向新插入的元素或指向映射中已具有相同值的元素。如果插入了新元素，则对中的 pair::second 元素设置为 true；如果存在具有相同值的元素，则设置为 false。

该链接还包含一个示例

例如：

if(mp.insert(make_pair(key, value)).second == false)
{
   cout << "Insertion failed. Key was present"
}

Answer 2

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

result.second 包含你想要的内容

Answer 3

这取决于你所说的失败或成功是什么意思。

std::map::insert 当插入新元素时成功，否则返回一个指向已存在元素的迭代器。

如果没有足够的内存来插入新元素，std::map::insert 将失败并抛出 std::bad_alloc。

Answer 4

第一个插入成员函数
返回一个对，其 bool 组件
如果进行了插入则返回 true
如果地图已包含则为 false
其键具有等价元素的元素
排序中的值，以及其
迭代器组件返回地址
插入新元素的位置或
元素已经位于的位置。

访问 a 的迭代器组件
该成员返回的对 pr
函数，使用 pr.first，并且
取消引用它，使用 *(pr.first)。到
访问对 pr 的 bool 组件
由该成员函数返回，使用
pr.第二。

第二个插入成员函数，
提示版本，返回一个迭代器
指向新的位置
元素已插入到地图中。

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

Answer 5

是的，它会抛出 STL 中使用的异常之一，例如内存不足时。那是在失败的情况下。

或者您是否也有兴趣了解该元素是否已包含在实例中？

Answer 6

如果 insert() 尝试插入但失败，则抛出 std::bad_alloc ；如果它选择不插入，因为具有该键的值已经存在，那么它不会抛出。它只是返回一个指向现有元素的迭代器。

带有提示的 insert() 版本仅返回一个迭代器，与无提示版本不同，后者还返回值是否已插入或已存在的指示。

CPP Reference 建议使用 size() 的变化来确定插入是否成功。我们可以尝试类似的

// untested
template<class K, class V, class C, class A, class Element>
auto insert(std::map<K,V,C,A>& map,
            std::map<K,V,C,A>::const_iterator hint,
            Element&& element)
{
     auto const initial_size = map.size();
     auto const it = map.insert(hint, std::forward<Element>(element));
     auto const was_added = map.size() != initial_size;
     return std::pair{it, was_added};
}

实际上，对于问题中的示例（构造一个键值对），我们可能希望包装 emplace_hint() 成员函数，因此我们可以传递一对或单独的键和值：

// untested
template<class K, class V, class C, class A, class... Args>
auto emplace(std::map<K,V,C,A>& map,
             std::map<K,V,C,A>::const_iterator hint,
             Args&&... args)
{
     auto const initial_size = map.size();
     auto const it = map.emplace_hint(hint, std::forward<Args>(args)...);
     auto const was_added = map.size() != initial_size;
     return std::pair{it, was_added};
}

Answer 7

比较插入前和插入后地图的大小，以了解插入元素是否很慢（Debian 8中的map::size很慢：浏览完整地图）

可以知道是否在地图中插入或找到了一对使用提示插入后无需重新计算大小，使用提示插入方法。

使用提示方法插入另一对相同的第一个，以及您确定不在映射中的第二个（如 -1 表示正第二个整数的映射）。如果返回的迭代器具有这个不可能的值，则它是新插入的，如果不是，则它是在映射中找到的。然后返回的迭代器可能会被更改。
示例：在map中插入对p (2,4) 和p (6, 5)米 ((0, 1), (2, 3), (4, 5))。

int main (int argc, char* argv []) {
  std::pair<int, int> tmp [3] = {
    std::pair<int, int> (0, 1),
    std::pair<int, int> (2, 3),
    std::pair<int, int> (4, 5)
  };
  std::map<int, int> m ((std::pair<int, int>*) tmp, (std::pair<int, int>*) &tmp [3]);

  std::cout << "initial map == ";
  std::for_each (m.begin (), m.end (), [] (const std::pair<int, int>& 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<int, int> (2, 4) from second iterator" << std::endl;
    std::map<int, int>::iterator ihint (m.begin ()), k (ihint); ++ihint;
    std::pair<int, int> pfoo (2, -1);
    k = m.insert (ihint, pfoo);
    if (k->second == -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<int, int>& 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<int, int> (6, 5) from third iterator" << std::endl;
    std::map<int, int>::iterator ihint (m.begin ()), k (ihint); ++ihint; ++ihint;
    std::pair<int, int> pfoo (6, -1);
    k = m.insert (ihint, pfoo);
    if (k->second == -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<int, int>& p) {
    std::cout << p.first << "->" << p.second << "   ";
  });
  std::cout << std::endl;
}

输出：
初始映射 == 0->1 2->3 4->5

插入对 1 == std::pair; (2, 4) 来自第二个迭代器的

后在映射 m 中

一对具有这样的第一个在插入对 1 == 0->1 2->3 4->5

插入对 2 == std:: 对(6, 5) 从第三个迭代器

插入m

开始，该对在插入对 2 == 0->1 2->3 4->5 6->5 之后

Answer 8

根据 文档， std::map insert 返回一对两个值：“插入元素（或阻止插入的元素）的迭代器和当且仅当插入发生时设置为 true 的 bool 值。”

根据您用于映射的类型，您可以执行类似于上面建议的 Tristram 的操作，您可以在其中创建结果对。但是，如果您只想要其中一个值（例如，表明插入是否成功的布尔值），则类似这样的事情可能会更简单：

如果您只想要布尔值，则可以这样做

bool insert_completed = (mymap.insert({key,value})).second;

，或者如果您只想要迭代器，则可以这样做 这基本上是

auto inserted_iterator = (mymap.insert({key,value})).first;

说“嘿，我刚刚从 insert() 中得到了一对，我只关心该对中的一个，所以让我设置一些等于该块的变量”。

但是，请注意，这并不适用于 insert() 的每个版本。有些 insert 的返回值只是迭代器，有些不返回任何内容，甚至返回一个 insert_return_type，因此请检查文档以了解哪种特定情况与您正在编写的代码相关。