insert()和operator[]之间的区别已经在其他答案中很好地解释了。然而，c++ 11和c++ 17分别引入了新的std::map插入方法:

c++ 11提供了emplace()，在einpoklum的评论和GutiMac的回答中也提到过。 c++ 17提供了insert_or_assign()和try_emplace()。

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

emplace(): When used correctly, this method can avoid unnecessary copy or move operations by constructing the element to be inserted in place. Similar to insert(), an element is only inserted if there is no element with the same key in the container. insert_or_assign(): This method is an "improved" version of operator[]. Unlike operator[], insert_or_assign() doesn't require the map's value type to be default constructible. This overcomes the disadvantage mentioned e.g. in Greg Rogers' answer. try_emplace(): This method is an "improved" version of emplace(). Unlike emplace(), try_emplace() doesn't modify its arguments (due to move operations) if insertion fails due to a key already existing in the map.

有关insert_or_assign()和try_emplace()的更多详细信息，请在这里看到我的回答。

Coliru上的简单示例代码

事实上，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可以稍后使用，例如，在图算法中。在我看来，使用操作符[]的替代选项看起来可读性较差:

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

当你写作的时候

map[key] = value;

没有办法知道你是否替换了value for 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。

下面是另一个例子，如果键值存在，操作符[]会覆盖键值，但是.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 ) ;

}

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

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

Map [key] -创建一个默认值的Map元素。 = value—将值复制到该元素中。

第二步可能发生异常。因此，该操作将只完成部分(一个新元素被添加到map中，但该元素没有初始化值)。当一个操作没有完成，但系统状态被修改时，这种情况被称为有“副作用”的操作。

插入操作提供了强有力的保证，意味着它没有副作用(https://en.wikipedia.org/wiki/Exception_safety)。插入要么完全完成，要么使映射处于未修改状态。

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

如果要插入单个元素，则在异常情况下容器中不会有任何更改(强保证)。

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

我以前见过有人用地图的形式

map< const key, const val> Map;

为了避免意外重写值的情况，然后继续写一些其他的代码:

const_cast< T >Map[]=val;

我记得他们这么做的原因是因为他们确信在这些特定的代码中他们不会覆盖map值;因此，继续使用更“可读”的方法[]。

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

在处理绝对不能重写的映射值的情况下，请使用insert。不要仅仅为了可读性而破例。