未调用 Move ctor

Question

我（又）做错了什么吗？

#include <iostream>
using std::cout;

struct Map
{
    Map()
    {
        cout << "Map()\n";
    }
    Map(const Map& pattern)
    {
        cout << "Map(const Map& pattern)\n";
    }
    Map(Map&& tmp)
    {
        cout << "Map(Map&& tmp)\n";
    }
};

Map createMap()
{
    return Map();
}

int main(int argc, char* argv[])
{
    //dflt
    Map m;
    //cpy
    Map m1(m);
    //move
    Map m2(Map(m1));//<<I thought that I create here tmp unnamed obj.
    Map m3(createMap());//<<---or at least here, but nope...
    return 0;
}

请参阅代码中的注释行

编辑[摘自FredOverflow答案]

int main() 
{ 
    std::cout << "default\n"; 
    Map m; 

    std::cout << "\ncopy\n"; 
    Map m1(m); 

    std::cout << "\nmove\n";
    Map m2((Map(m1))); 

    std::cout << "\nmove\n"; 
    Map m3(createMap()); 
}  

我得到输出：

default
Map()

copy
Map(const Map& pattern)

move
Map(const Map& pattern)//Here why not move ctor aswell as copy?

move
Map()
Map()
Map(Map&& tmp)

Answer 1

Map m3(createMap());//<<---or at least here, but nope...

您正在看到回报值优化的实际效果。在 C++ 中，编译器可以优化复制返回的对象，并让函数直接使用存储结果的调用者对象。也不需要调用移动构造函数。

让函数变得更复杂，这样编译器就无法使用优化，你会看到移动的实际情况。例如：

Map createMap()
{
    Map a, b;
    if (rand())
        return a;
    return b;
}

Answer 2

您正在声明一个函数，而不是一个对象：

T name (T(blah));

相当于：

T name(T blah);

可被识别为函数声明。您可以使用额外的括号：

Map m2 ((Map(m1)));

这称为最令人烦恼的解析。

Answer 3

我稍微修改了您的 main 例程以更好地理解输出：

int main()
{
    std::cout << "default\n";
    Map m;

    std::cout << "\ncopy\n";
    Map m1(m);

    std::cout << "\nmove\n";
    Map m2(Map(m1));

    std::cout << "\nmove\n";
    Map m3(createMap());
}

这是 g++ -fno-elide-constructors 的输出：

default
Map()

copy
Map(const Map& pattern)

move

move
Map()
Map(Map&& tmp)
Map(Map&& tmp)

正如其他人已经指出的那样，Map m2(Map(m1)); 确实是一个函数声明，因此您不会得到任何输出。第二步不被解释为函数声明，因为createMap不是类型名称。这里涉及两个移动构造函数。第一个移动将通过评估 Map() 创建的临时对象移动到通过评估 createMap() 创建的临时对象，第二个移动将 m3 从后者。这正是人们所期望的。

如果您通过编写 Map m2((Map(m1))); 来修复第一步，输出将变为：

move
Map(const Map& pattern)
Map(Map&& tmp)

同样，这并不奇怪。通过计算 Map(m1) 来调用复制构造函数，然后将该临时对象移动到 m2 中。如果您在不使用 -fno-elide-constructors 的情况下进行编译，则移动操作会消失，因为它们会被 RVO 或 NRVO 等更高效的优化所取代：

default
Map()

copy
Map(const Map& pattern)

move
Map(const Map& pattern)

move
Map()

我确信 Visual C++ 有一个类似于 < code>-fno-elide-constructors 您可以使用它来更好地理解移动语义。

Answer 4

该程序显示了预期的输出。

#include <iostream>
using std::cout;

struct Map
{
    Map()
    {
        cout << "Map()\n";
    }
    Map(const Map& pattern)
    {
        cout << "Map(const Map&)\n";
    }
    Map(Map&& tmp)
    {
        cout << "Map(Map&&)\n";
    }
};

Map createMap()
{
    Map m;
    return m;
}

int main(int argc, char* argv[])
{
    //dflt
    Map m;
    //cpy
    Map m1(m);
    //move
    Map m2 = createMap();//<<I thought that I create here tmp unnamed obj.
    std::cin.get();
    return 0;
}

请注意 createMap() 的更改。它不使用直接的临时值，而是使用命名的返回值。该程序显示了 Visual Studio 2010 上的预期输出。

Answer 5

Map createMap()
{
    return Map();
}

我认为编译器会对上述内容进行 RVO （返回值优化），因此不会创建任何临时对象。

如果将其更改为以下内容，您应该会看到您的移动向量被调用。

Map createMap()
{
    Map m;
    m.DoSomething(); // this should make the compiler stop doing RVO
    return m;
}

• 有些编译器执行 RVO，无论编译器设置如何（调试/发布模式） - 例如 bcc32。我有一种感觉 VC 也会一样。