Question

我一直在研究C ++ 11的一些新功能，我注意到的是声明变量的双符号，例如T&& var。

首先，这只野兽叫什么？我希望谷歌允许我们搜索这样的标点符号。

究竟是什么意思？

乍一看，它似乎是一个双重引用（就像C风格的双指针T** var），但我很难想到一个用例。

Answer 1

宣布rvalue reference（标准提案文档）。

以下是对rvalue references的介绍。

以下是对Microsoft标准库developers之一的rvalue引用的深入了解。

注意： MSDN上的链接文章（“Rvalue参考：VC10中的C ++ 0x功能，第2部分”）是对Rvalue引用的非常清晰的介绍，但是Rvalue引用在C ++ 11标准草案中曾经是真的，但对于最后一个则不然！具体来说，它在各个点上说rvalue引用可以绑定到lvalues，它曾经是真的，但是被改变了。（例如int x; int＆amp;＆amp; rrx = x;不再编译在GCC中） - drewbarbs 2014年7月13日在16:12

C ++ 03引用（现在称为C ++ 11中的左值引用）之间的最大区别在于它可以像临时一样绑定到rvalue而不必是const。因此，这种语法现在是合法的：

T&& r = T();

右值参考主要提供以下内容：

移动语义。现在可以定义移动构造函数和移动赋值运算符，它采用右值引用而不是通常的const-lvalue引用。移动的功能类似于副本，除非它没有义务保持源不变;实际上，它通常会修改源，使其不再拥有移动的资源。这对于消除无关副本非常有用，尤其是在标准库实现中。

例如，复制构造函数可能如下所示：

foo(foo const& other)
{
    this->length = other.length;
    this->ptr = new int[other.length];
    copy(other.ptr, other.ptr + other.length, this->ptr);
}

如果这个构造函数是临时传递的，那么复制将是不必要的，因为我们知道临时将被销毁;为什么不利用临时已分配的资源？在C ++ 03中，没有办法阻止副本，因为我们无法确定我们是否临时传递。在C ++ 11中，我们可以重载一个移动构造函数：

foo(foo&& other)
{
   this->length = other.length;
   this->ptr = other.ptr;
   other.length = 0;
   other.ptr = nullptr;
}

注意这里的重大区别：移动构造函数实际上修改了它的参数。这将有效地将临时“移动”到正在构建的对象中，从而消除不必要的副本。

移动构造函数将用于临时和非const左值引用，这些引用使用std::move函数显式转换为rvalue引用（它只执行转换）。以下代码都调用f1和f2的移动构造函数：

foo f1((foo())); // Move a temporary into f1; temporary becomes "empty"
foo f2 = std::move(f1); // Move f1 into f2; f1 is now "empty"

完美转发。右值引用允许我们正确转发模板化函数的参数。以此工厂功能为例：

template <typename T, typename A1>
std::unique_ptr<T> factory(A1& a1)
{
    return std::unique_ptr<T>(new T(a1));
}

如果我们调用factory<foo>(5)，则该参数将推断为int&，即使foo的构造函数采用int，也不会绑定到文字5 }。好吧，我们可以改为使用A1 const&，但是如果foo通过非const引用获取构造函数参数呢？要制作真正通用的工厂功能，我们必须在A1&和A1 const&上重载工厂。如果工厂采用1参数类型，那可能没问题，但是每个额外的参数类型会将必要的重载乘以2。这很快就无法维护。

rvalue引用通过允许标准库定义可以正确转发lvalue / rvalue引用的std::forward函数来解决此问题。有关std::forward工作原理的详细信息，请参阅this excellent answer。

这使我们能够像这样定义工厂函数：

template <typename T, typename A1>
std::unique_ptr<T> factory(A1&& a1)
{
    return std::unique_ptr<T>(new T(std::forward<A1>(a1)));
}

现在，当传递给T的构造函数时，参数的rvalue / lvalue-ness被保留。这意味着如果使用rvalue调用factory，则使用rvalue调用T的构造函数。如果使用左值调用工厂，则使用左值调用T的构造函数。由于一个特殊规则，改进的工厂功能起作用：

当函数参数类型为。时表单T&&，其中T是模板参数和函数参数是A类型的左值，类型A&是用于模板参数推导。

因此，我们可以像这样使用工厂：

auto p1 = factory<foo>(foo()); // calls foo(foo&&)
auto p2 = factory<foo>(*p1);   // calls foo(foo const&)

重要的右值参考属性：

对于重载决策，左值更喜欢绑定到左值引用，右值更喜欢绑定到右值引用。因此，为什么临时工具更喜欢在复制构造函数/赋值运算符上调用移动构造函数/移动赋值运算符。
右值引用将隐式绑定到rvalues和临时转换结果的临时值。即float f = 0f; int&& i = f;格式良好，因为float可以隐式转换为int;引用将是转换结果的临时值。
命名的右值引用是左值。未命名的右值引用是右值。这一点非常重要，可以在std::move

foo&& r = foo(); foo f = std::move(r);

Answer 2

它表示右值参考。除非另外明确生成，否则Rvalue引用仅绑定到临时对象。它们用于在某些情况下使对象更加高效，并提供称为完美转发的工具，这极大地简化了模板代码。

在C ++ 03中，你无法区分不可变左值的副本和右值。

std::string s;
std::string another(s);           // calls std::string(const std::string&);
std::string more(std::string(s)); // calls std::string(const std::string&);

在C ++ 0x中，情况并非如此。

std::string s;
std::string another(s);           // calls std::string(const std::string&);
std::string more(std::string(s)); // calls std::string(std::string&&);

考虑这些构造函数背后的实现。在第一种情况下，字符串必须执行复制以保留值语义，这涉及新的堆分配。但是，在第二种情况下，我们事先知道传递给构造函数的对象是立即销毁的，并且它不必保持不变。在这种情况下，我们可以有效地交换内部指针而不执行任何复制，这实际上更有效。移动语义有益于任何具有昂贵或禁止复制内部引用资源的类。考虑std::unique_ptr的情况 - 现在我们的类可以区分临时和非临时，我们可以使移动语义正常工作，以便unique_ptr无法复制但可以移动，这意味着std::unique_ptr可以合法地存储在标准容器中，排序等，而C ++ 03的std::auto_ptr则不能。

现在我们考虑另一种使用右值参考 - 完美转发。考虑将引用绑定到引用的问题。

std::string s;
std::string& ref = s;
(std::string&)& anotherref = ref; // usually expressed via template

无法回忆起C ++ 03对此的看法，但在C ++ 0x中，处理rvalue引用时的结果类型至关重要。对类型T的右值引用（其中T是引用类型）成为类型T的引用。

(std::string&)&& ref // ref is std::string&
(const std::string&)&& ref // ref is const std::string&
(std::string&&)&& ref // ref is std::string&&
(const std::string&&)&& ref // ref is const std::string&&

考虑最简单的模板函数 - min和max。在C ++ 03中，您必须手动重载const和非const的所有四种组合。在C ++ 0x中，它只是一个重载。结合可变参数模板，可实现完美转发。

template<typename A, typename B> auto min(A&& aref, B&& bref) {
    // for example, if you pass a const std::string& as first argument,
    // then A becomes const std::string& and by extension, aref becomes
    // const std::string&, completely maintaining it's type information.
    if (std::forward<A>(aref) < std::forward<B>(bref))
        return std::forward<A>(aref);
    else
        return std::forward<B>(bref);
}

我没有退回返回类型，因为我不记得它是如何随意完成的，但是min可以接受左值，右值，常量值的任意组合。

Answer 3

T&& 用于类型扣除的术语（例如用于完美转发）通俗地称为转发参考。 “通用参考”一词由Scott Meyers in this article创造，但后来改变了。

那是因为它可能是r值或l值。

例如：

// template
template<class T> foo(T&& t) { ... }

// auto
auto&& t = ...;

// typedef
typedef ... T;
T&& t = ...;

// decltype
decltype(...)&& t = ...;

可以在以下答案中找到更多讨论：Syntax for universal references

Answer 4

右值引用是一种类似于普通引用X＆amp;的类型，有几个例外。最重要的一点是，当涉及函数重载解析时，左值更喜欢旧式左值引用，而右值更喜欢新的右值引用：

void foo(X& x);  // lvalue reference overload
void foo(X&& x); // rvalue reference overload

X x;
X foobar();

foo(x);        // argument is lvalue: calls foo(X&)
foo(foobar()); // argument is rvalue: calls foo(X&&)

那么什么是右值？任何不是左值的东西。一个左值一个表达式，指的是一个内存位置，并允许我们通过＆amp ;;来获取该内存位置的地址。运营商。

首先通过一个例子来理解rvalues的成就几乎更容易：

 class Sample {
  int *ptr; // large block of memory
  int size;
 public:
  Sample(int sz=0) : ptr{sz != 0 ? new int[sz] : nullptr}, size{sz} 
  {}
  // copy constructor that takes lvalue 
  Sample(const Sample& s) : ptr{s.size != 0 ? new int[s.size] :\
      nullptr}, size{s.size}
  {
     std::cout << "copy constructor called on lvalue\n";
  }

  // move constructor that take rvalue
  Sample(Sample&& s) 
  {  // steal s's resources
     ptr = s.ptr;
     size = s.size;        
     s.ptr = nullptr; // destructive write
     s.size = 0;
     cout << "Move constructor called on rvalue." << std::endl;
  }    
  // normal copy assignment operator taking lvalue
  Sample& operator=(const Sample& s)
  {
   if(this != &s) {
      delete [] ptr; // free current pointer
      ptr = new int[s.size]; 
      size = s.size; 
    }
    cout << "Copy Assignment called on lvalue." << std::endl;
    return *this;
  }    
 // overloaded move assignment operator taking rvalue
 Sample& operator=(Sample&& lhs)
 {
   if(this != &s) {
      delete [] ptr; //don't let ptr be orphaned 
      ptr = lhs.ptr;   //but now "steal" lhs, don't clone it.
      size = lhs.size; 
      lhs.ptr = nullptr; // lhs's new "stolen" state
      lhs.size = 0;
   }
   cout << "Move Assignment called on rvalue" << std::endl;
   return *this;
 }
//...snip
};

构造函数和赋值运算符已经重载了带有右值引用的版本。 Rvalue引用允许函数在编译时分支（通过重载解析）条件＆＃34;我是在左值还是右值上调用？＆＃34;。 这使我们能够创建更高效的构造函数和赋值运算符，从而移动资源而不是复制它们。

编译器在编译时自动分支（取决于是否为左值或右值调用它），选择是否应该调用移动构造函数或移动赋值运算符。

总结：rvalue引用允许移动语义（和完美转发，在下面的文章链接中讨论）。

一个易于理解的实用示例是类模板 std :: unique_ptr 。由于unique_ptr维护其底层原始指针的独占所有权，因此无法复制unique_ptr。这将违反他们对独家所有权的不变性。所以他们没有复制构造函数。但他们确实有移动构造函数：

template<class T> class unique_ptr {
  //...snip
 unique_ptr(unique_ptr&& __u) noexcept; // move constructor
};

 std::unique_ptr<int[] pt1{new int[10]};  
 std::unique_ptr<int[]> ptr2{ptr1};// compile error: no copy ctor.  

 // So we must first cast ptr1 to an rvalue 
 std::unique_ptr<int[]> ptr2{std::move(ptr1)};  

std::unique_ptr<int[]> TakeOwnershipAndAlter(std::unique_ptr<int[]> param,\
 int size)      
{
  for (auto i = 0; i < size; ++i) {
     param[i] += 10;
  }
  return param; // implicitly calls unique_ptr(unique_ptr&&)
}

// Now use function     
unique_ptr<int[]> ptr{new int[10]};

// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(\
           static_cast<unique_ptr<int[]>&&>(ptr), 10);

cout << "output:\n";

for(auto i = 0; i< 10; ++i) {
   cout << new_owner[i] << ", ";
}

output:
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,

static_cast<unique_ptr<int[]>&&>(ptr)通常使用 std :: move

完成

// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(std::move(ptr),0);

一篇优秀的文章解释了所有这些以及更多（如rvalues如何允许完美转发以及这意味着什么）有很多很好的例子，是Thomas Becker的C++ Rvalue References Explained。这篇文章很大程度上依赖于他的文章。

Stroutrup等人的简短介绍是A Brief Introduction to Rvalue References。人

T＆amp;＆amp; （双＆符号）是指C ++ 11？

4 个答案: