“auto v = f()”和“auto&& v = f()”有什么区别？

Question

#include <vector>

using namespace std;

vector<int> f()
{
    return{};
}

// Update: Below is not compilable
void g(vector<int>)
{}

// Update: Below is the my initial intent.
/*
void g(const vector<int>&)
{}
*/

void g(vector<int>&&)
{}

int main()
{
    auto       v1 = f();
    auto&& v2 = f();

    g(forward<vector<int>>(v1));
    g(forward<vector<int>>(v2));
}

C++11 是否保证g(forward<vector<int>>(v1)) 会调用f(vector<int>) 或f(const vector<int>&) 和g(forward<vector<int>>(v2)) 会调用f(vector<int>&&)？

Answer 1

区别在于v1 是一个向量，而v2 是一个对向量的右值引用。

重载g 你所做的方式是一个非常糟糕的主意。如果参数是 cv 非限定右值，则调用将是不明确的，因为两个 g 都可以接受具有身份转换序列的右值。但是，可以接受一个重载采用T&，另一个采用T&&。

如果您要转发f() 的值类别，请不要将其复制/移动到v1 中。这会破坏价值类别信息。 v1 永远是左值。

此外，您没有正确使用std::forward。 v1 和 v2 都将被强制转换为右值引用，并且在这种情况下在重载决议下的行为方式相同。

std::forward 的正确用法如下所示：

void g(vector<int>&);
void g(vector<int>&&);
int main() {
    auto&& v1 = function_returning_lvalue_vector();
    auto&& v2 = function_returning_rvalue_vector();
    g(forward<decltype(v1)>(v1));  // calls lvalue overload
    g(forward<decltype(v2)>(v2));  // calls rvalue overload
}

Answer 2

有一个与返回值函数关联的对象，称为返回值。 f() 的返回值为vector<int>。

在 C++11 和 C++14 中，f() 按值返回：

• auto v1 = f(); 使用复制/移动构造函数从返回值初始化vector<int>，这将被称为v1。这是一个复制省略上下文。
• auto&& v2 = f(); 使名称 v2 指定返回值，并延长返回值的生命周期。

如果编译器确实实现了复制省略，那么这两个代码具有相同的效果。从 C++17 开始，使用所谓的“保证复制省略”，这两个代码将是相同的。

“相同”是指除decltype(identifier) 的结果之外的所有方面都相同，如下所述。

---

您的两个g 调用之间没有区别。在这两种情况下，参数都是std::vector 类型的左值。 表达式 v1 和 v2 不会“记住”它们最初是否是返回值对象。

std::forward 仅在给定模板参数时才有用，该参数是完美转发推导的结果（因此，可能是引用类型）。

建议使用decltype。 decltype(identifier) 是一个特殊情况，在应用了auto 扣除之后，它确实回想起了 标识符 是如何声明的。

• decltype(v1) 是 vector<int>
• decltype(v2) 是 vector<int> &&

但现在我们有了：

• std::forward<decltype(v1)> 是 vector<int> &&
• std::forward<decltype(v2)> 是 vector<int> &&

所以你仍然没有区分g 的两种不同形式。

事实上，正如 cmets 中所指出的，根本不可能调用 g。每个电话都会模棱两可。在重载决议中，直接引用绑定是一种身份转换； T 类型的 xvalue 参数与参数 T 和 T&& 一样匹配。 （类似地，T 类型的左值参数将与参数T 和T& 一样匹配）。

有可能重载g 以获得左值与右值重载。但是您也需要对v1 的初始化进行更改：

void g(vector<int> const &) {}
void g(vector<int> &&) {}

// ...
auto const& v1 = f();
auto&& v2 = f();

g( std::forward<decltype(v1)>(v1) );
g( std::forward<decltype(v2)>(v2) );