从函数（按值传递）和隐式移动规则返回类的命名对象？

Question

当您从函数（按值传递）返回类的对象（不是特定的类）时，我很难理解会发生什么 在这段代码中： 示例 1

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class test {
public:
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test( const test& z) {
        printf(" test( const test&z)\n");
    }
    test(test&& s)noexcept{
            printf(" test(test&& s)\n");          
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}

输出：

 test()
 test(test&& s)

前面的输出让我明白了在函数 (Some_thing()) 的作用域中创建了两个对象。第一个是一个左值对象，我们在函数的第一行（ Some_thing ( ) ）中创建它并给它一个名称（ i ）所以构造函数test ( ) 被调用。 而第二个是右值对象所以调用了构造函数test ( test&& s )。

但是当我删除了这个构造函数test(test&& s)noexcept并改变了这个构造函数

test( const test& z)

进入

test( test& z)

然后再次运行代码：

示例 2

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class test {
public:
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test( test& z) {
        printf(" test( test&z)\n");
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}

输出：

 test()
 test( test&z)

虽然我预计这段代码不会编译，因为没有构造函数将test&& 或const test& 作为参数

当我尝试在前面的代码中添加一行时，test(test&& z) = delete

示例 3

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class test {
public:
    test(test&& z) = delete;
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test( const test& z) {
        printf(" test( test&z)\n");
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
  Some_thing();
    return 0;
}

我试图编译它，但它没有编译，也没有运行

那么EXAMPLE 2是如何编译运行的？？？？？？以及如何使用构造函数test( test&z) 而不是 test(test&& z)??????

（我的意思是test( test&z)不是test( const test&z)所以不能用test( test&z)代替test(test&& z)）

编辑： 此代码编译并运行： 示例 4

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class test {
public:
    test(test&& z) = delete;
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test(const test& z) {
        printf(" test( test&z)\n");
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};

int main()
{
    test u;
    test r(u);
    return 0;
}

输出：

 test()
 test( test&z)

Answer 1

你的程序的行为可以在Automatic move from local variables and parameters的帮助下理解：

如果表达式是一个（可能带括号的）id 表达式，它命名一个变量，其类型为

• 非易失性对象类型或

• 对对象类型的非易失性右值引用（C++20 起）

并且声明了变量

• 在体内或

• 作为参数

  最里面的封闭函数或 lambda 表达式，

然后重载决议选择用于初始化返回值的构造函数，或者对于 co_return，选择 promise.return_value() 的重载（C++20 起）执行两次 ：

• 首先好像表达式是一个右值表达式（因此它可以选择移动构造函数），然后

• 如果第一次重载解决失败或

• 它成功了，但没有选择移动构造函数（形式上，所选构造函数的第一个参数不是对（可能是 cv 限定的）表达式类型的右值引用）（C++20 前）

• 然后重载解析像往常一样执行，表达式被视为左值（因此它可以选择复制构造函数）。

现在，让我们根据具体情况将其应用于您的代码 sn-p。

示例 1

在这种情况下，由于移动 ctor 可用且可行，因此满足条件“首先好像表达式是右值表达式”，因此选择了移动 ctor，我们得到了上述输出。

class test {
public:
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test( const test& z) {
        printf(" test( const test&z)\n");
    }
    test(test&& s)noexcept{
            printf(" test(test&& s)\n");          
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}

---

示例 2

在这种情况下，由于您提供了复制 ctor test::test( test&)，编译器不会为我们合成移动 ctor。请注意，没有合成的移动 ctor 与删除的移动 ctor 不同。因此条件 “如果第一次重载解析失败” 得到满足（因为没有移动 ctor），然后第二次执行重载解析，现在将选择提供的复制 ctor，因此提到的输出。

class test {
public:
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test( test& z) {
        printf(" test( test&z)\n");
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}

---

示例 3

在这种情况下，您已明确删除移动 ctor。也就是说，您的意图是，如果有人尝试使用 move ctor，那么它应该会失败。因此，在这里，当第一次发生重载解决方案时，选择了移动 ctor，但是由于您已明确将其标记为已删除，因此立即失败并因此出现错误。

class test {
public:
    test(test&& z) = delete;
    test(int y) {
        printf(" test(int y)\n");
    }
    test() {
        printf(" test()\n");
    }
    test( const test& z) {
        printf(" test( test&z)\n");
    }
    test& operator=(test e) {
        printf(" test& operator=( test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
  Some_thing();
    return 0;
}