c++将实例复制构造到映射中

Question

下面是一个带有简单类 Foo 的代码，该类已实例化，然后插入到地图中。 我不明白将 foo 插入 fooMap 时如何调用复制构造函数。

#include <stdlib.h>
#include <stdio.h>

#include <map>
#include <iostream>

using namespace std;

class Foo {
    public:

        //default constructor
        Foo() {
            name_ = string("Undefined") + suffix();
            cout << "Constructing Foo '"<< name_ << "'" << endl;
        };

        //constructor with arg
        Foo(const char* name): name_(name) {
            cout << "Constructing Foo '" << name << "'" << endl;
        };

        //default const copy-constructor
        Foo(const Foo &foo) {
            name_ = foo.get_name() + suffix();
            cout << "Copying const Foo '" << foo.get_name() << "' into Foo '" << name_ << "'" << endl;
        }

        //default destructor
        ~Foo() {
            cout << "Destroying Foo '" << name_ << "'" << endl;
        }

        //getting name
        const string get_name() const {
            return name_;
        };

        //setting name
        void set_name(string new_name){
            name_ = new_name;
        }

        //suffix for name
        string suffix() {
            static int cmp=0;
            char ch[2];
            sprintf(ch,"%d",cmp++);
            return string(ch);
        }

    private:
        string name_;
};

int main() {

    typedef map<string, Foo> FooMapType;
    FooMapType fooMap;

    cout << "1:\n";
    Foo foo("bar");

    cout << "\n2:\n";
    fooMap["bar"] = foo;

    cout << "\n3:\n";
    cout << fooMap["bar"].get_name() << endl;
    foo.set_name("baz");

    cout << "\n4:\n";

输出是：

1:
Constructing Foo 'bar'

2:
Constructing Foo 'Undefined0'
Copying const Foo 'Undefined0' into Foo 'Undefined01'
Copying const Foo 'Undefined01' into Foo 'Undefined012'
Destroying Foo 'Undefined01'
Destroying Foo 'Undefined0'

3:
bar

4:
Destroying Foo 'baz'
Destroying Foo 'bar'

但我期望 foo 复制构造函数被调用，导致输出：

Copying const Foo 'bar' into Foo 'Undefined0'

Answer 1

您正在执行赋值操作，而不是在 fooMap["bar"] = foo; 行中进行复制构造，覆盖 Foo &operator=(const Foo&) 来查看发生的情况。

默认构造是创建您要进行分配的初始项目。

您看到的副本可能是地图实现的内部 - 将其放入树中的适当位置。数量超出了我的预期。

Answer 2

map::operator[] 返回对值成员的引用，因此以下语句：

fooMap["bar"] = foo;

可以解释为：

Foo& fooRef = fooMap["bar"]; // (1)
fooRef = foo;                // (2)

在 (1) map::operator[] 中执行并且在 (2) Foo::operator= 中。

如果映射中不存在给定的键，map::operator[] 会创建一个新元素 - 一对由提供的键和使用默认构造函数构造的值对象组成。 （在您的示例中，键类型为 std::string ，值类型为 Foo ）。如果给定的键存在，它只返回对值对象的引用。

第 (2) 行通过其引用更改值。

如果你看一下 map::operator[] 的实现（我在这里提供了微软的一个，来自 VS2010 附带的 STL 库），你可以看到它调用了 map::插入（）
在引擎盖下，为其提供临时对象 value_type ，该对象再次从临时对象 mapped_type 创建：

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

value_type 基本上是我上面提到的对和 在您的情况下，mapped_type 是 Foo 。
mapped_type() 通过调用其默认构造函数来创建临时对象。这与输出中的第二个默认构造函数匹配（第一个构造函数在创建局部变量 foo 时调用）。 value_type 的构造函数使用 mapped_type 的复制构造函数来创建其值成员的实例。这与 Foo 的复制构造函数的第一次调用相匹配。日志中还有此构造函数的另一个调用，为了找到其来源，我们需要更深入地研究 map::operator[]...实际上是 insert 它调用的方法：

template<class _Valty>
typename _STD tr1::enable_if<!_STD tr1::is_same<const_iterator, typename _STD tr1::remove_reference<_Valty>::type>::value, iterator>::type
insert(const_iterator _Where, _Valty&& _Val)
{   
   // try to insert node with value _Val using _Where as a hint
   return (_Insert(_Where, this->_Buynode(_STD forward<_Valty>(_Val))));
}

Map 被实现为一棵树，我们可以看到内部 _Insert 方法插入了一个新的树节点实例，该实例是使用 _Buynode() 创建的：

template<class _Valty>
_Nodeptr _Buynode(_Valty&& _Val)
{   
   // allocate a node with defaults
   _Nodeptr _Wherenode = _Buynode();
   ...
   _Cons_val(this->_Alval, _STD addressof(this->_Myval(_Wherenode)), _STD forward<_Valty>(_Val));
   ...
   return (_Wherenode);
}

树节点封装配对对象 - 地图的元素，所以它是创建涉及创建我们的对的另一个副本 - _Val，这是对 Foo 的复制构造函数进行另一次调用的地方。

map::operator[] 调用创建了两个包含 Foo 的临时对象，并且在返回时这些对象被销毁，因此您可以在输出中看到两个析构函数调用。

如果您实现 Foo::operator= 并在其中添加跟踪，您将能够看到该方法也被调用（第 (2) 行）。

如果您稍后将相同的键映射到其他某个 Foo 对象，则只会执行 Foo::operator= ，因为该键的映射元素已经创建，并且只有值是通过其引用改变。

Answer 3

这是个好问题，我也有同样的行为。我们（也许是全部？）STL 实现的细节创建默认对象，然后使用另一种方法来复制数据。

退后一步，可以看出，一旦调用了 insert（或者在您的情况下是operator[]）方法，原始对象的副本确实存在于映射中，这很可能就是全部标准承诺。

Answer 4

fooMap["bar"] = foo 产生默认构造、两个副本和一个赋值。

需要默认构造，因为键 "bar" 没有 string-foo 对。

第一个副本是由键 "bar" 和从刚刚创建的默认构造 foo 复制的值构造而成的对。

当该对被复制到地图中时，就会产生第二个副本。

然后，赋值将映射中的值赋给 foo。

在 C++11 中使用 R-Value 语义的 STL 实现可以提高效率。