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

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

需要注意的是，您也可以使用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);
}

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

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

map< const key, const val> Map;

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

const_cast< T >Map[]=val;

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

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

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

关于std::map还有一点需要注意:

关联(nonExistingKey);将在map中创建一个新条目，键指向初始化为默认值的nonExistingKey。

当我第一次看到它时(当我的头撞到一个讨厌的遗留bug时)，这把我吓坏了。没想到会这样。对我来说，这看起来像一个get操作，我没有预料到“副作用”。当从你的地图获取时，更倾向于map.find()。

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

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

如果你的应用程序是速度关键，我会建议使用[]操作符，因为它创建了原始对象的总共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;
}