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

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

我只是问他，我们俩都不记得插入效果更好的原因，但是我确信这不仅是样式偏好，还有技术上的原因，例如效率。在SGI STL参考只是说“严格地说，这个成员函数是不必要的：它的存在只是为了方便。”

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

当你写

map[key] = value;

无法判断是否替换了valuefor key或是否使用创建了新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。

对于地图中已存在的键，两者具有不同的语义。因此它们并不是真正可直接比较的。

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

另一件事要注意std::map：

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

当我第一次看到它时，这让我感到非常恐惧（同时将我的脑袋撞向一个残旧的错误）。没想到的。对我来说，这看起来像是get操作，而且我没想到会有“副作用”。不想map.find()从你的地图时获得。

如果默认构造函数的性能影响不成问题，那么出于对上帝的热爱，请使用可读性更高的版本。

:)

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

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

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

第二步可能会发生异常。结果，该操作将仅部分完成（将新元素添加到map中，但该元素未使用初始化value）。当操作未完成但系统状态被修改时的情况称为“有副作用”的操作。

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

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

如果要插入单个元素，则在发生异常的情况下容器中不会有任何更改（强烈保证）。

如果您的应用程序对速度有严格要求，我会建议您使用[]运算符，因为它会创建原始对象的总共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;
}

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

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

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

该结果将是具有一对：

• 第一个元素（result.first），指向插入的对，或者如果此键已经存在，则指向具有该键的对。

• 第二个元素（result.second），如果插入正确或错误，则为true，则出问题。

PS：如果您不关心订单，可以使用std :: unordered_map;）

谢谢！

map :: insert（）的一个陷阱是，如果密钥已经存在于映射中，它将不会替换值。我看过Java程序员编写的C ++代码，他们期望insert（）的行为与Java中替换值的Map.put（）相同。

请注意，您还可以使用Boost.Assign：

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

这是另一个示例，显示了如果存在键，则operator[] 覆盖键的值，如果存在，.insert 则不覆盖键的值。

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

}

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

我以前看过人们以以下形式使用地图

map< const key, const val> Map;

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

const_cast< T >Map[]=val;

我记得他们这样做的原因是因为他们确定在这些特定的代码位中它们不会覆盖映射值。因此，继续采用更具“可读性”的方法[]。

我从未真正从这些人编写的代码中遇到任何直接的麻烦，但是直到今天，我坚信直到可以轻易避免的风险（无论风险多么小）都不应被承担。

如果要处理绝对不能覆盖的映射值，请使用insert。不要仅仅为了可读性而设置例外。

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