鉴于下面的代码,一切正常。为什么变量 d 是对 int 的引用?到底是怎么回事?
int main()
{
int a= 10;
int &&b = a+10; // b is int &&
auto c =b+10; // c is int
auto &&d = a; // d is int&
//int &&di = a; // error, as expected
return (0);
}
这与类型推导中的引用折叠规则有关。
A& & becomes A&
A& && becomes A&
A&& & becomes A&
A&& && becomes A&&
在引用折叠规则之上值得一提的是如何强制 d 成为右值引用。您可以为此使用 std::move :
int a =4;
auto &&d = std::move(a); // d is type &&
当然,在谈论整数时,右值引用是愚蠢的,因为按值传递同样有效。这对于强制移动语义优化很有用,比如如果您想在函数末尾插入一个复杂类型,该类型将超出范围......
vector<std::string> v;
void f()
{
string s;
foo(s); // do some kind of operation on s.
v.push_back(std::move(s)); // use push_back( &&) instead of push_back(const &);
}
类型扣除有一个特殊规则。在auto &&d = a;
“auto&&”中是对非 const 非易失类型的右值引用,而“a”是左值,则应用此特殊规则:“a”的类型被视为 int& 而不是 int。然后像往常一样选择“auto”的类型与“a”的类型相同,即int&。因此,根据 bames53 提到的参考折叠,“auto&&”的类型是 int&。
auto&&
调用完美转发。Asa
是类型的左值int
,d
是对 的左值引用int
。
您需要std::forward
结合使用auto&&
来获得您最可能想要的行为。请参阅以下示例代码:
#include <iostream>
template <class T>
void f(T&& x) {
std::cout << "R-value!" << std::endl;
}
template <class T>
void f(T& x) {
std::cout << "L-value!" << std::endl;
}
int get() {
return 0;
}
int main()
{
// Correct usage
{
std::cout << "Correct usage" << std::endl;
auto&& s = get();
f(std::forward<decltype(s)>(s)); // Prints: R-value!
std::cout << "----------------------------\n" << std::endl;
}
// Above code is robust to refactorings
{
std::cout << "After refactoring" << std::endl;
int i = 5;
auto&&s = i;
f(std::forward<decltype(s)>(s)); // Prints: L-value!
std::cout << "----------------------------\n" << std::endl;
}
// Forward is necessary, else l-value version is called.
{
std::cout << "Forgetting forward" << std::endl;
auto&& s = get();
f(s); // Prints: L-value!
std::cout << "----------------------------\n" << std::endl;
}
}
这里有一个自己运行的链接:http: //cpp.sh/8lducx