class key
{
   int i_;
public:

   key(int i) : i_(i) { cout << "key ctor\n"; }
   key(const key& rhs) : i_(rhs.i_) { cout << "key cctor\n"; }
   key& operator=(const key& rhs) { i_ = rhs.i_; cout << "key operator=\n"; return *this; }

   friend bool operator < (const key& lhs, const key& rhs) { return lhs.i_ < rhs.i_; }
};

class value
{
   int i_;
public:

   value(int i = 0) : i_(i) { cout << "value ctor\n"; }
   value(const value& rhs) : i_(rhs.i_) { cout << "value cctor\n"; }
   value& operator=(const value& rhs) { i_ = rhs.i_; cout << "value operator=\n"; return *this; }
};

...

map<key, value> m;
key k(1);
value v(2);

...

m[k] = v;

key ctor
value ctor
value ctor
key cctor
value cctor
key cctor
value cctor
value operator=

m.insert(make_pair(k, v));

key ctor
value ctor
key cctor
value cctor
key cctor
value cctor
key cctor
value cctor
key cctor
value cctor

m.insert(make_pair(boost::ref(k), boost::ref(v)));

key ctor
value ctor
key cctor
value cctor
key cctor
value cctor

B>Видимо это было давно — иначе откуда я об этом помню?

    mapped_type& operator[](const key_type& _Keyval)
        {    // find element matching _Keyval or insert with default mapped
        iterator _Where = this->lower_bound(_Keyval);
        if (_Where == this->end()
            || this->comp(_Keyval, this->_Key(_Where._Mynode())))
            _Where = this->insert(_Where,
                value_type(_Keyval, mapped_type()));
        return ((*_Where).second);
        }
    };

Library Defect Report #181

Discussion:
The claim has surfaced in Usenet that expressions such as

make_pair("abc", 3)

are illegal, notwithstanding their use in examples, because template instantiation tries to bind the first template parameter to const char (&)[4], which type is uncopyable.

I doubt anyone intended that behavior...

Proposed resolution:

In 20.2 [utility], paragraph 1 change the following declaration of make_pair():
template <class T1, class T2> pair<T1,T2> make_pair(const T1&, const T2&);

to:
template <class T1, class T2> pair<T1,T2> make_pair(T1, T2);

    iterator insert(const typename value_type::first_type &_First, const typename value_type::second_type& _Second);
// и трансформеры...
    template<typename T, int N>
    iterator insert(const T(&_First)[N], const typename  value_type::second_type& _Second) 
    { 
        return insert((const typename value_type::first_type)(_First),_Second);
    }
    template<typename T, int N>
    iterator insert(const  typename value_type::first_type &_First,const T(&_Second)[N]) 
    { 
        return insert(_First,(const  typename value_type::second_type )(_Second));
    }
    template<typename T1, typename T2, int N1, int N2>
    iterator insert(const T1(&_First)[N1],const T2(&_Second)[N2]) 
    { 
        return insert((const  typename value_type::first_type )(_First),(const  typename value_type::second_type )(_Second));
    }

C>Короче, кто-то поленился реализовать:

C>    iterator insert(const typename value_type::first_type &_First, const typename value_type::second_type& _Second);
C>// и трансформеры...
C>...
C>

C>А мы теперь с этим кривым и стандартным работаем...

template <class P>
pair<iterator, bool> insert(P&& x);

...
If P is instantiated as a reference type, then the argument x is copied from. Otherwise x is considered to be an rvalue as it is converted to value_type and inserted into the map. Specifically, in such cases CopyConstructible is not required of key_type or mapped_type unless the conversion from P specifically requires it