在STL映射中，使用map::insert比使用[]更好吗？

Question

前段时间和同事讨论了如何在STL中插入值地图。 我更喜欢 map[key] = value;，因为它感觉自然且易于阅读，而他更喜欢 map.insert(std::make_pair(key, value))。

我刚刚问过他，我们都不记得为什么插入更好，但我确信这不仅仅是风格偏好，还有效率等技术原因。 SGI STL 参考简单地说：“严格来说，这个成员函数是不必要的：它的存在只是为了方便。”

谁能告诉我这个原因，还是我只是梦想有一个？

Answer 1

当您编写时，

map[key] = value;

无法判断您是否替换了键的值，或者是否创建了新的键与值。

map::insert() 将仅创建：

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
// ...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

对于我的大多数应用，我通常不关心是创建还是替换，因此我使用更易于阅读的 map[key] = value。

Answer 2

当涉及到映射中已经存在的键时，两者具有不同的语义。 所以它们实际上并没有直接可比性。

但是operator[]版本需要默认构造值，然后赋值，所以如果这比复制构造更昂贵，那么它会更昂贵。 有时默认构造没有意义，然后就不可能使用operator[]版本。

Answer 3

std::map 需要注意的另一件事是：

myMap[nonExistingKey]; 将在地图中创建一个新条目，以 nonExistingKey 初始化为默认值。

当我第一次看到它时，这把我吓坏了（当我的头撞到一个令人讨厌的遗留错误时）。 没想到会这样。 对我来说，这看起来像是一个 get 操作，我没想到会有“副作用”。 从地图获取时首选 map.find()。

Answer 4

如果默认构造函数的性能影响不是问题，那么看在上帝的份上，请使用更具可读性的版本。

:)

Answer 5

insert 从异常安全的角度来看更好。

表达式 map[key] = value 实际上是两个操作：

1. map[key ] - 创建具有默认值的地图元素。
2. = value - 将值复制到该元素中。

第二步可能会出现异常。 结果，操作将仅完成部分（一个新元素已添加到映射中，但该元素未使用 value 进行初始化）。 当一个操作尚未完成，但系统状态被修改的情况，称为有“副作用”的操作。

insert 操作提供了强有力的保证，意味着它没有副作用（https: //en.wikipedia.org/wiki/Exception_safety）。 insert 要么完全完成，要么使地图处于未修改状态。

http://www.cplusplus.com/reference/map/map/insert/：

如果插入单个元素，发生异常时容器不会发生变化（强保证）。

Answer 6

如果您的应用程序对速度至关重要，我会建议使用 [] 运算符，因为它会创建原始对象的总共 3 个副本，其中 2 个是临时对象，迟早会被销毁。

但在 insert() 中，创建了原始对象的 4 个副本，其中 3 个是临时对象（不一定是“临时对象”）并被销毁。

这意味着额外的时间：
1. 一个对象的内存分配
2. 一次额外的构造函数调用
3. 一次额外的析构函数调用
4. 一个对象的内存释放

如果你的对象很大，构造函数是典型的，析构函数会释放大量资源，以上几点更重要。 关于可读性，我认为两者都足够公平。

我想到了同样的问题，但不是关于可读性而是关于速度。
这是一个示例代码，通过它我了解了我提到的这一点。

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

Answer 7

现在，在 c++11 中，我认为在 STL 映射中插入一对的最佳方法是：

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

结果 将是一对：

• 第一个元素 (result.first)，指向插入或指向的对
  如果键已存在，则为具有此键的对。

• 第二个元素 (result.second)，如果插入正确则为 true 或
  false 表示出了问题。

PS：如果您不关心顺序，您可以使用 std::unordered_map ；）

谢谢！

Answer 8

map::insert() 的一个问题是，如果键已存在于映射中，则它不会替换值。 我见过 Java 程序员编写的 C++ 代码，他们期望 insert() 的行为与 Java 中的 Map.put() 相同，其中值被替换。

Answer 9

需要注意的是，您还可以使用 Boost。分配：

using namespace std;
using namespace boost::assign; // bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

Answer 10

这是另一个示例，显示 operator[] 覆盖键的值（如果存在），但 .insert 不会覆盖< /strong> 值（如果存在）。

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

Answer 11

这是一个相当有限的案例，但从我收到的评论来看，我认为这是值得注意的。

我过去见过人们以 的形式使用映射来

map< const key, const val> Map;

避免意外值覆盖的情况，但随后继续编写其他一些代码：

const_cast< T >Map[]=val;

我记得他们这样做的原因是因为他们确信在这些代码中他们不会覆盖地图值的某些代码位； 因此，继续使用更“可读”的方法[]。

实际上，我从未因这些人编写的代码而遇到任何直接麻烦，但直到今天我仍然强烈地感觉到，当风险可以轻易避免时，无论风险多么小，都不应该冒风险。

如果您处理的地图值绝对不能被覆盖，请使用插入。 不要仅仅为了可读性而设置例外。

Answer 12

事实上，std::map insert() 函数不会覆盖与键关联的值，这使得我们可以编写如下的对象枚举代码：

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

当我们需要映射不同的非对象时，这是一个非常常见的问题 。 0..N 范围内某些 id 的唯一对象。 这些 id 稍后可以使用，例如在图形算法中。 在我看来，使用 operator[] 替代方案看起来可读性较差：

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
} 

Answer 13

insert() 和operator[] 已经很好了其他答案中已经解释过。 但是， 引入了 std::map 的新插入方法C++11 和 C++17 分别：

• C ++11 提供 emplace()正如 einpoklum 的评论中也提到的以及GutiMac 的回答。
• C++17 提供 insert_or_assign() 和 try_emplace()。

让我简单总结一下“新”插入方法：

• emplace(): 如果使用正确，此方法可以通过将元素构造为插入到位。 与 insert() 类似，只有在容器中不存在具有相同键的元素时才会插入元素。
• insert_or_assign()：此方法是 operator[] 的“改进”版本。 与 operator[] 不同，insert_or_assign() 不要求映射的值类型默认可构造。 这克服了Greg Rogers的回答中提到的缺点。
• try_emplace()：此方法是 emplace() 的“改进”版本。 与 emplace() 不同，如果由于映射中已存在键而导致插入失败，try_emplace() 不会修改其参数（由于移动操作）。

有关 insert_or_assign() 和 try_emplace() 的更多详细信息，请参阅我的回答此处。

Coliru 上的简单示例代码