右值引用的学习

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

左值引用和右值引用

在讲之前，我们先来看一下什么是左值和右值

左值和左值引用

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋
值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左
值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{// p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}

右值和右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引
用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能
取地址。右值引用就是对右值的引用，给右值取别名。由于右值通常不具有名字，我们也只能通过引用的方式找到它的存在。通常情况下，我们只能是从右值表达式获得其引用。比如：
T && a = ReturnRvalue();
这个表达式中，假设ReturnRvalue返回一个右值，我们就声明了一个名为a的右值引用，其值等于ReturnRvalue函数返回的临时变量的值。ReturnRvalue函数返回的右值在表达式语句结束后，其生命也就终结了，而通过右值引用的声明，该右值又“重获新生”，其生命周期将于右值引用类型变量a的生命周期一样。只要a还“活着”，该右值临时量将会一直“存活”下去。
所以相比于以下语句的声明方式：

T b = ReturnRvalue();

我们刚才的右值引用变量声明，就会少一次对象的析构及一次对象的构造。因为a是右值引用，直接绑定了ReturnRvalue返回的临时量，而b只是由临时值构造而成的，而临时量在表达式结束后会析构应而就会多一次析构和构造的开销。

double fmin(double x, double y)
{return x + y;
}int main()
{// 以下几个都是常见的右值double x = 1.1, y = 2.2;   // 字母常量10; x + y; // 表达式返回值double ret = fmin(x, y);  // 函数返回值// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);// 这里编译会报错：error C2106: “=”: 左操作数必须为左值/*10 = 1;x + y = 1;fmin(x, y) = 1;*/return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址。

左值引用与右值引用比较

先来回顾一下左值引用

int main()
{// 左值引用只能引用左值，不能引用右值。int a = 10;int& ra1 = a;   // ra1是a的别名//int& ra2 = 10;   // 编译失败，因为10是右值return 0;
}

我们思考一下下面2个问题：

左值引用可以引用右值吗？
右值引用可以引用左值吗？

通过上面的代码我们可以发现左值引用不能引用右值，那么为什么还要问这个问题了？其实我们可以引用右值，因为我们的测试还不够全面。可以看下面的情况：

// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;

常量左值

为什么加了const之后，就能引用右值了呢？这是因为字符常量具有常性，也就是不能被修改，如果我们使用引用来引用常量，那么我们就能通过引用来修改这个常量，这就违反了常量的特性。简单来说这是一个权限的放大，即“不能被修改变成了可以被修改”，所以加个const引用来限制。
在C++98标准中常量左值就是个“万能”的引用类型。它可以接受非常量左值、常量左值、右值对其进行初始化。而且在使用右值对其初始化的时候，常量左值引用还可以像右值引用一样将右值的生命期延迟。不过相比于右值引用所引用的右值，常量左值所引用的右值在它的“余生”中只能是只读的。相对地，非常量左值只能接受非常量左值对其进行初始化。看下面的代码。

// 常量左值引用
struct Copyable
{Copyable(){}Copyable(const Copyable& o){cout << "Copied" << endl;}
};Copyable ReturnRvalue() { return Copyable(); }
void AcceptVal(Copyable){}
void AcceptRef(const Copyable &){}int main()
{cout << "Pass by value: " << endl;AcceptVal(ReturnRvalue());  // 临时值被拷贝传入cout << "Pass by reference: " << endl;AcceptRef(ReturnRvalue());  // 临时值被作为引用传递
}

我们声明了一个结构体Copyable，该结构体的作用是在被拷贝到时候打印一句话Copied。而两个函数AcceptVal使用了值传递参数，而AcceptRef使用了引用传递。在以ReturnRvalue返回的右值为参数的时候，AcceptRef就可以直接使用产生的临时值（并延长生命周期），而AcceptVal则不能直接使用临时对象。
运行代码，结果如下：

Pass by value:
Copied
Copied
Pass by reference:
Copied

可以看到，由于使用了左值引用，临时对象被直接作为函数的参数，而不需要从中拷贝一次。在C++11中，同样的，可以使用以右值引用为参数声明如下函数void AcceptRvalueRef(Copyable &&) {}也同样可以减少临时变量拷贝到开销。进一步地，还可以再AcceptRvalueRef中修改该临时值（这个时候临时值由于被右值引用参数所引用，已经获得了函数时间的生命期）。不过修改一个临时值的意义通常不大。
在下表中，列出了在C++11中各种引用类型可以引用的值的类型。需要注意的是，只要能够绑定右值的引用类型，都能够延长右值的生命期。
请添加图片描述

[!note] 总结

  1. 左值引用只能引用左值，不能引用右值。
  2. 但是const左值引用既可引用左值，也可引用右值。

接下来看右值引用

int main()
{// 右值引用只能右值，不能引用左值。int&& r1 = 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a = 10;int&& r2 = a;  // 报错// 右值引用可以引用move以后的左值int&& r3 = std::move(a);return 0;
}

这里的move函数是C++11之后新出的一个函数，其作用是将一个左值强制转换成一个右值，类似强制类型转换，还有move并不会改变一个变量本身的左值属性，例如 int b = 1;double a = (double)b这句代码，本质上b还是一个整型类型，只是在这个表达式中，返回了一个double类型的b。

[!note] 总结

  1. 右值引用只能右值，不能引用左值。
  2. 但是右值引用可以move以后的左值。

右值引用的场景和意义

既然我们要知道右值引用的意义是什么，那么就需要先知道左值引用的优点和缺点是什么，有哪些场景要用到左值引用。

  1. 左值引用降低了内存使用和提高效率
string add_string(string& s1, string& s2)
{string s = s1 + s2;return s;
}int main()
{string str;string hello = "Hello";string world = "world";str = add_string(hello, world);return 0;
}

我们先来回顾一下非引用传参和引用传参的本质

  • 非引用传参：在函数调用时，非引用传参实际上是传递了实参的一个副本给形参。这意味着在函数内部对形参的任何修改都不会影响到原始的实参。非引用传参包括普通形参和指针形参，但指针形参传递的是地址的副本，而不是对象本身的副本。
  • 引用传参：引用传参则是将实参的引用（或别名）传递给形参。在函数内部对形参的操作实际上是对实参本身的操作，因此任何修改都会反映到原始的实参上。

所以引用传参不需要复制实参，而是直接操作实参本身，可以节省内存并提高效率。这对于大型对象或数据结构的传递尤为重要。而非引用传参需要复制整个对象或结构，这可能会导致较大的内存开销和较低的执行效率。
2. 左值引用解决了一部分返回值的拷贝问题

string& func()
{static string s = "hello world";return s;
}int main()
{string str1;str1 = func();return 0;
}

请添加图片描述

引用返回和非引用返回的区别：

  • 非引用返回：当函数的返回类型为非引用类型时，函数的返回值用于初始化在调用函数时创建的临时对象。这意味着，如果返回类型不是引用，在调用函数的地方会将函数返回值复制给临时对象。其返回值既可以是局部对象（在函数内部定义的对象），也可以是求解表达式的结果。这种复制过程可能会导致额外的内存开销和性能损失。
  • 引用返回：当函数返回类型为引用类型时，没有复制返回值。相反，返回的是对象本身（或更准确地说，是对对象的引用）。因此，返回引用类型通常更高效，因为它避免了不必要的复制操作。但是，需要注意的是，返回引用时必须确保引用的对象在函数返回后仍然有效。

从图中可以看出引用返回比非引用返回少了一次拷贝构造。这是因为返回值s指向的string是全局的，当出了函数作用域依然存在，因此我们可以传引用返回，不用拷贝构造给临时变量，节省了一次拷贝构造。
而在非引用返回函数当中，func函数依然返回hello world这个字符串，但是s是一个局部变量。出了函数作用域就会被销毁，那么如果str1要想接收到s，那么就会创建一个临时变量拷贝构造给它，然后临时变量再拷贝构造给str。
那么如果我们不想使用引用返回，还想减少一次拷贝，该如何实现呢？答案就是使用右值引用。先来看看有哪些情况下会产生可以被右值引用的左值：

  1. 当一个左值被move后，可以被右值引用
  2. C++会把即将离开作用域的非引用类型的返回值当成右值，这种类型的右值也称为将亡值

在C++11中，把右值分为纯右值和将亡值。

  • 纯右值就是内置类型的右值，讲的是用于辨识临时变量和一些不跟对象关联的值。比如非引用返回的函数返回的临时变量值就是一个纯右值。一些运算表达式，比如1+3产生的临时变量值，也是纯右值。而不跟对象关联的字母量值，比如：2、‘c’；、true，也是纯右值。
  • 将亡值就是C++11新增的跟右值引用相关的表达式，这样表达式通常是将要被移动的对象（移为他用），比如返回右值引用T&&的函数返回值、std::move的返回值或者转换为T&&的类型转换函数的返回值。回顾刚才的代码，变量s已经快要离开作用域了，马上就会被销毁，s销毁没有问题，但是字符串hello world是我们需要的。这种情况可以理解为：一个快要去世的病人，临走前说要把自己的器官捐赠给别人，当然也可以指定捐赠给他人。

同理，一旦左值得到了右值属性，相当于把自己的资源给别人，不希望自己的资源被系统释放，而是被合适的对象继承走。s即将被销毁，此时s就是一个右值了，右值的意思就是：这个变量的资源可以被迁移走。这句话非常非常重要！！！

<type_traits>头文件

有的时候，我们可能不知道一个类型是否是引用类型，以及是左值引用还是右值引用（在模板中比较常见）。标准库在<type_traits>头文件中提供了3个模板类：is_rvalue_reference、is_lvalue_reference、is_reference，可供我们进行判断。比如：

int main()
{cout << is_rvalue_reference<string&&>::value << endl;   //1cout << is_rvalue_reference<string&>::value << endl;    //0cout << is_lvalue_reference<string&>::value << endl;    //1cout << is_reference<string&>::value << endl;    //1
}

我们通过模板类的成员value就可以打印出string &&是否是一个右值引用了。配合类型推导符decltype，我们甚至还可以对变量的 类型进行判断。

移动语义

那么右值是如何把资源迁移走的呢？这就要学习右值引用的移动语义了：
拷贝构造函数中为指针成员分配新的内存再进行内容拷贝到做法在C++编程中几乎被视为是不可违背的。不过在一些时候，我们确实不需要这样的拷贝构造语义。我们先看下面的代码。

class HasPtrMem
{
public:HasPtrMem() :d(new int(0)){cout << "Construct: " << ++n_cstr << endl;}HasPtrMem(const HasPtrMem& h) :d(new int(*h.d)){cout << "Copy Construct: " << ++n_cptr << endl;}~HasPtrMem(){cout << "Destruct: " << ++n_dstr << endl;}int* d;static int n_cstr;static int n_dstr;static int n_cptr;
};int HasPtrMem::n_cstr = 0;
int HasPtrMem::n_dstr = 0;
int HasPtrMem::n_cptr = 0;HasPtrMem GetTemp()
{return HasPtrMem();
}int main()
{HasPtrMem a = GetTemp();
}

在代码中，我们声明了一个返回一个HasPtrMem变量的函数。为了记录构造函数、拷贝构造函数，以及析构函数调用的次数，我们使用了一些静态变量。在main函数中，我们简单声明了一个HasPtrMem的变量a，要求它使用GetTemp的返回值进行初始化。运行结果如下（未开启编译器优化）：

Construct: 1
Copy construct: 1
Destruct: 1
Copy construct: 2
Destruct: 2
Destruct: 3

首先在GetTemp函数中创建临时对象，调用HasPtrMem构造函数创建临时对象，输出Construct: 1，接着，GetTemp函数返回临时对象时进行拷贝构造，调用拷贝构造函数输出Copy construct: 1，临时对象离开GetTemp函数作用域，调用析构函数，输出Destruct: 1。再然后main函数中进行拷贝构造，将 GetTemp() 函数返回的对象拷贝给对象 a，调用拷贝构造函数，输出 Copy Construct: 2。GetTemp() 函数返回的对象离开 main 函数中赋值语句的作用域，调用析构函数，输出 Destruct: 2。最后main函数结束时析构对象a，输出Destruct: 3。
如果开启了编译器优化，那么GetTemp函数中创建的临时对象会直接作为对象a进行构造，不会发生拷贝构造。所以开启了编译器优化后，结果是：
请添加图片描述

接下来我以未开启优化来讲解。在代码中，类HasPtrMem只有一个int类型指针。而如果HasPtrMem的指针指向非常大的堆内存数据的话，那么拷贝构造的过程就会非常昂贵。可以想象，这种情况一旦发生，a的初始化表达式的执行速度将相当堪忧。
在main函数部分，按照C++的语义，临时对象将在语句结束后被析构，会释放它所包含的堆内存资源。而a在拷贝构造的时候，又会被分配堆内存。这样的一去一来似乎并没有太大的意义，那么我们是否可以在临时对象构造a的时候不分配内存，即不使用所谓的拷贝构造呢？
在C++11中，答案是肯定的，我们可以看下面的示意图：
请添加图片描述

上半部分可以看到从临时变量中拷贝构造变量ａ的做法，即在拷贝时分配新的堆内存，并从临时对象的堆内存中拷贝内容至a.d。而构造完成后，临时对象将析构，因此其拥有的堆内存资源会被析构函数释放。而下半部分则是一种“新”方法，该方法在构造时使得a.d指向临时对象的堆内存资源。同时我们保证临时对象对象不释放所指向的堆内存，那么在构造完成后，临时对象被析构，a就从中“偷”到了临时对象所拥有的堆内存资源。
在C++11中，这样的“偷走”临时变量中资源的构造函数，被称为“移动构造函数”。这样的“偷”的行为，则称为“移动语义”。可以理解为“移为己用”。通过下面的代码来看一看如何实现这样的移动语义。

class HasPtrMem
{
public:HasPtrMem() :d(new int(3)){cout << "Construct: " << ++n_cstr << endl;}HasPtrMem(const HasPtrMem& h) :d(new int(*h.d)){cout << "Copy Construct: " << ++n_cptr << endl;}HasPtrMem(HasPtrMem&& h) :d(h.d)  // 移动构造函数{h.d = nullptr;   // 将临时值的指针成员置为空cout << "Move construct: " << ++n_mvtr << endl;}~HasPtrMem(){delete d;cout << "Destruct: " << ++n_dstr << endl;}int* d;static int n_cstr;static int n_dstr;static int n_cptr;static int n_mvtr;
};int HasPtrMem::n_cstr = 0;
int HasPtrMem::n_dstr = 0;
int HasPtrMem::n_cptr = 0;
int HasPtrMem::n_mvtr = 0;HasPtrMem GetTemp()
{HasPtrMem h;cout << "Resource from " << __func__ << ": " << hex << h.d << endl;return h;
}int main()
{HasPtrMem a = GetTemp();cout << "Resource from " << __func__ << ": " << hex << a.d << endl;
}

对比刚才的代码，这个代码多了一个构造函数HasPtrMem(HasPtrMem &&)，这个就是移动构造函数。与拷贝构造函数不同的是，移动构造函数接受一个所谓的“右值引用”的参数。移动构造函数使用了参数h的成员d初始化了本对象的成员d（而不是像构造函数一样需要分配内存，然后将内容依次拷贝到新分配的内存中），而h的成员d随后被置为nullptr。这样就完成了移动构造的全过程。
代码运行结果如下（未开启优化）

Construct: 1
Resource from GetTemp: 0x603010
Move construct: 1
Destruct: 2
Move construct: 2
Destruct: 2
Resource from main: 0x603010
Destruct: 3

可以看到，这里没有调用拷贝构造函数，而是调用了两次移动构造函数，移动构造函数的结果是，GetTemp中的h的指针成员h.d和main函数中的a的指针成员a.d的值是相同的，即h.d和a.d都指向了相同的堆地址内存。该堆内存在函数返回的过程中，成功的逃避了被析构的命运，取而代之地，成为了赋值表达式中的变量a的资源。如果堆内存不是一个int长度的数据，而是以mbyte为单位的堆空间，那么这样的移动带来的性能提升是非常惊人的。

std::move()

在C++11中，标准库<utility>中提供了一个有用的函数std::move，这个函数的名字具有迷惑性，因为实际上move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而我们可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast<T&&>(lvalue);。
值得一提的是，被转化的左值，其生命期并没有随着左右值的转化而改变。来看下面的示例：

class Moveable
{
public:Moveable():i(new int(3)){}~Moveable() { delete i; }Moveable(const Moveable & m):i(new int(*m.i)){}Moveable(Moveable&& m) :i(m.i){m.i = nullptr;}int* i;
};int main()
{Moveable a;Moveable c(move(a));   // 会调用移动构造函数cout << *a.i << endl;
}

请添加图片描述

在代码中，我们为类型Moveable定义了移动构造函数。这个函数定义本身没有什么问题，但是调用的时候，使用了Moveable c(move(a));这样的语句。这里的a本来是一个左值变量，通过move后变成右值。这样一来，a.i就被c的移动构造函数设置为指针空值。由于a的生命周期实际要到main函数结束才结束，那么随后的表达式*a.i进行计算的时候，就会发生严重的运行时错误。
来看一看正确的代码。

class HugeMem
{
public:HugeMem(int size) :sz(size > 0 ? size : 1) {c = new int[sz];}~HugeMem() { delete[]c; }HugeMem(HugeMem&& hm) :sz(hm.sz), c(hm.c) {hm.c = nullptr;}int* c;int sz;
};class Moveable
{
public:Moveable() :i(new int(3), h(1024) {}~Moveable() { delete i; }Moveable(Moveable && m) :i(m.i), h(move(m.h))   // 强制转化为右值，以调用移动构造函数{m.i = nullptr;}int* i;HugeMem h;
};Moveable GetTemp()
{Moveable tmp = Moveable();cout << hex << "Huge Mem from " << __func__ << " @" << tmp.h.c << endl;// Huge Mem from GetTemp @0x603030return tmp;
}int main()
{Moveable a(GetTemp());cout << hex << "Huge Mem from " << __func__ << " @" << a.h.c << endl;// Huge Mem from GetTemp @0x603030return 0;
}

在代码中，我们定义了两个类型：HugeMem和Moveable，其中Moveable包含了一个HugeMem的对象。在Moveable的移动构造函数中，我们就看到了std::move函数的使用。该函数将m.h强制转化为右值，以迫使Moveable中的h能够实现移动构造。这里也可以使用std::move，是因为m.h是m的成员，既然m将存在表达式结束后被析构，其成员也自然会被析构，因此不存在上一个代码中生存期不对的问题。
那么如果不使用std::move(m.h)这样的表达式，而是直接使用m.h这个表达式会怎么样？这里的m.h引用了一个确定的对象，而且m.h也有名字，可以使用&m.h取到地址，因此是一个不折不扣的左值。不过这个左值确实会很快“灰飞烟灭”，因为拷贝构造函数在Moveable对象a的构造完成后也就结束了。那么这里使用std::move强制转为右值就不会有问题了。而且，如果我们不这么做，由于m.h是个左值，就会导致调用HugeMem的拷贝构造函数来构造Moveable的成员h。如果是这样，移动语义就没有能够成功地向类的成员传递。换言之，还是会由于拷贝而导致一定的性能上的损失。
事实上，为了保证移动语义的传递，在编写移动构造函数的时候，应该总是记得使用move转换拥有形如堆内存、文件句柄等资源的成员为右值，这样一来，如果成员支持移动构造的话，就可以实现其移动语义。而即使成员没有移动构造函数，那么接受常量左值的构造函数版本也会轻松地实现拷贝构造，因此也不会引起大的问题。

完美转发

完美转发，是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。比如：

template <typename T>
void IamForwording(T t) {IrunCodeActually(t); }

这个例子中，IamForwording是一个转发函数模板。而函数IrunCodeActually则是真正执行代码的目标函数。对于目标函数IrunCodeActually而言，它总是希望转发函数将参数按照传入Iamforwarding时的类型传递（即传入的是左值对象，IrunCodeActually就能获得左值对象，传入右值是也是一样），而不产生额外的开销，就好像转发者不存在一样。
这似乎是一件很容易的事情，但其实并不简单。在上面的例子中，在IamForwarding的参数中使用了最基本类型进行转发，该方法会导致参数在传给IrunCodeActually之前就产生了一次额外的临时对象拷贝。因此这样的转发只能说是正确的转发，但谈不上完美。
所以通常程序需要对是一个引用类型，引用类型不会产生额外的开销。其次，则需要考虑转发函数对类型的接收能力。因为目标函数可能需要既能够接受左值引用，又接受右值引用。那么如果转发函数只能接受其中的一部分，就无法做到完美转发。那么如果使用“万能”的常量左值类型呢？以常量左值为参数的转发函数会一些尴尬，比如：

void IrunCodeActually(int t) {}
template <typename T>
void IamForwording(const T& t) {IrunCodeActually(t); }

由于目标函数的参数类型是非常量左值类型，因此无法接受常量左值引用作为参数，这样一来，虽然转发函数的接受能力很高，但在目标函数的接受上却出了问题。那么我们可能就需要通过一些常量和非常量的重载来解决目标函数的接受问题。这在函数参数比较多的情况下，就会造成代码冗余，而且根据上面的表格中，如果我们的目标函数的参数是个右值引用的话，同样无法接受任何左值类型作为参数，间接的，也就导致无法使用移动语义。
那么C++11如何解决完美转发的问题的呢？实际上，C++11是通过“引用折叠”的新语言规则，并结合新的模板推导规则来完成完美转发。
在C++11以前，例如下面的语句：

typedef const int T;
typedef T& TR;
TR& v = 1;   // 该声明在C++98中会导致编译错误

其中TR& v = 1这样的表达式会被编译器认为是不合法的表达式，而在C++11中，一旦出现了这样的表达式，就会发生引用折叠，即将复杂的未知表达式折叠为已知的简单表达式，如下表。

TR的类型定义声明v的类型v的实际类型
T&TRA&
T&TR&A&
T&TR&&A&
T&&TRA&&
T&&TR&A&
T&&TR&&A&&

规则并不难记，因为一旦定义中出现了左值引用，引用折叠总是优先将其折叠为左值引用。而模板对类型的推导规则比较简单，当转发函数的实参是类型X的一个左值引用，那么目标参数被推导为X&类型，而转发函数的实参是类型X的一个右值引用的话，那么模板的参数被推导为X&&类型。结合以上的折叠规则，就能确定出参数的实际类型。进一步，我们可以把转发函数写成如下形式：

template <typename T>
void IamForwording(T&& t) 
{IrunCodeActually(static_cast<T && > (t)); 
}

我们不仅在参数部分使用了T &&这样的标识，在目标函数传参的强制类型转换中也使用了这样的形式。比如我们调用转发函数时传入了一个X类型的左值引用，可以想象，转发函数将被实例化为如下形式：

void IamForwording(X& && t) 
{IrunCodeActually(static_cast<X& && > (t)); 
}

引用折叠规则就是：

void IamForwording(X& t) 
{IrunCodeActually(static_cast<X&> (t)); 
}

对于一个右值而言，当它使用右值引用表达式引用的时候，该右值引用却是个左值，那么我们想在函数调用中继续传递右值，就需要使用move来进行左右值的转换。而move通常就是一个static_cast。不过在C++11中，用于完美转发的函数却不再叫做move，而是另外一个名字：forward。所以我们可以把转发函数写成这样：

template <typename T>
void IamForwording(T && t) 
{IrunCodeActually(forward(t)); 
}

move和forward在实际实现上差别并不大。来看一个完美转发的代码：

void RunCode(int&& m) { cout << "rvalue ref" << endl; }
void RunCode(int& m) { cout << "lvalue ref" << endl; }
void RunCode(const int&& m) { cout << "const rvalue ref" << endl; }
void RunCode(const int& m) { cout << "const lvalue ref" << endl; }template<typename T>
void PerfectForward(T&& t) { RunCode(forward<T>(t)); }int main()
{int a;int b;const int c = 1;const int d = 0;PerfectForward(a);          // lvalue refPerfectForward(move(b));    // rvalue refPerfectForward(c);          // const lvalue refPerfectForward(move(d));    // const rvalue ref
}

可以看到，所有的转发都被正确地送到了目的地。
完美转发的一个作用就是包装函数，这是一个很方便的功能，对上面的代码稍作修改，就可以用很少的代码记录单参数函数的参数传递状况。

template<typename T, typename U>
void PerfectForward(T&& t, U& Func)
{cout << t << "\tforwarded..." << endl;Func(forward<T>(t));
}void RunCode(double && m) {}
void RunHome(double && h) {}
void RunComp(double && c) {}int main()
{PerfectForward(1.5, RunComp);    // 1.5     forwarded...PerfectForward(8, RunCode);      // 8     forwarded...PerfectForward(1.5, RunHome);    // 1.5     forwarded...
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/80946.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

PHP黑白胶卷底片图转彩图功能 V2025.05.15

PHP黑白胶卷底片图转彩图功能 V2025.05.15

关于底片转彩图 传统照片底片是摄影过程中生成的反色图像&#xff0c;为了欣赏照片&#xff0c;需要通过冲印过程将底片转化为正像。而随着数字技术的发展&#xff0c;我们现在可以使用数字工具不仅将底片转为正像&#xff0c;还可以添加色彩&#xff0c;重现照片原本的色彩效…
阅读更多...
【Three.js基础学习】36.particles-morphing-shader

【Three.js基础学习】36.particles-morphing-shader

前言 通过着色器如何实现粒子之间动态切换 一、代码 script.js import * as THREE from three import { OrbitControls } from three/addons/controls/OrbitControls.js import { GLTFLoader } from three/addons/loaders/GLTFLoader.js import { DRACOLoader } from three/a…
阅读更多...
【PostgreSQL数据分析实战：从数据清洗到可视化全流程】附录-D. 扩展插件列表（PostGIS/PostgREST等）

【PostgreSQL数据分析实战：从数据清洗到可视化全流程】附录-D. 扩展插件列表（PostGIS/PostgREST等）

&#x1f449; 点击关注不迷路 &#x1f449; 点击关注不迷路 &#x1f449; 点击关注不迷路 文章大纲 附录D. PostgreSQL扩展插件速查表一、插件分类速查表二、核心插件详解三、安装与配置指南四、应用场景模板五、版本兼容性说明六、维护与优化建议七、官方资源与工具八、附录…
阅读更多...
【Linux】冯诺依曼体系结构和操作系统的理解

【Linux】冯诺依曼体系结构和操作系统的理解

目录 冯诺依曼体系结构一个例子来深入理解 初识操作系统操作系统的作用设计操作系统的目的操作系统之上和之下分别有啥 管理的精髓&#xff0c;先描述&#xff0c;再组织 冯诺依曼体系结构 我们知道&#xff0c;计算机这个东西发明出来就是帮助人们快速解决问题的。那如果我们想…
阅读更多...
kotlin @JvmStatic注解的作用和使用场景

kotlin @JvmStatic注解的作用和使用场景

1. JvmStatic 的作用 JvmStatic 是 Kotlin 提供的一个注解&#xff0c;用于在 JVM 上将伴生对象&#xff08;companion object&#xff09;中的方法或属性暴露为 Java 静态方法或字段。 作用对象&#xff1a;只能用在 companion object 中的函数或属性。效果&#xff1a; 在 …
阅读更多...
Redis实现-优惠卷秒杀(基础版本)

Redis实现-优惠卷秒杀(基础版本)

(一)全局唯一ID 一、全局ID生成器 可以看到在优惠卷订单表中的主键id并没有设置Auto increment自增长 假如未来订单量达到数亿单&#xff0c;单表无法保存如此多数据&#xff0c;就需要对其进行分表存储(分布式)。假如每张表都采用自增长&#xff0c;各自从1开始自增&#xf…
阅读更多...
c++STL——哈希表封装：实现高效unordered_map与unordered_set

c++STL——哈希表封装：实现高效unordered_map与unordered_set

文章目录 用哈希表封装unordered_map和unordered_set改进底层框架迭代器实现实现思路迭代器框架迭代器重载operator哈希表中获取迭代器位置 哈希表的默认成员函数修改后的哈希表的代码封装至上层容器 用哈希表封装unordered_map和unordered_set 在前面我们已经学过如何实现哈希…
阅读更多...
虹科应用 | 探索PCAN卡与医疗机器人的革命性结合

虹科应用 | 探索PCAN卡与医疗机器人的革命性结合

随着医疗技术的不断进步&#xff0c;医疗机器人在提高手术精度、减少感染风险以及提升患者护理质量方面发挥着越来越重要的作用。医疗机器人的精确操作依赖于稳定且高效的数据通信系统&#xff0c;虹科提供的PCAN四通道mini PCIe转CAN FD卡&#xff0c;正是为了满足这一需求而设…
阅读更多...
Yolov8的详解与实战-深度学习目标检测

Yolov8的详解与实战-深度学习目标检测

Yolov8的详解与实战- 文章目录 摘要 模型详解 C2F模块 Loss head部分 模型实战 训练COCO数据集 下载数据集 COCO转yolo格式数据集&#xff08;适用V4&#xff0c;V5&#xff0c;V6&#xff0c;V7&#xff0c;V8&#xff09; 配置yolov8环境 训练 测试 训练自定义数据集 Labelme…
阅读更多...
scons user 3.1.2

scons user 3.1.2

前言 感谢您抽出时间阅读有关 SCons 的内容。SCons 是一款下一代软件构建工具&#xff0c;或者称为 make 工具&#xff0c;即一种用于构建软件&#xff08;或其他文件&#xff09;并在底层输入文件发生更改时使已构建的软件保持最新状态的软件实用程序。 SCons 最显著的特点是…
阅读更多...
Java的多线程笔记

Java的多线程笔记

创建一个线程的方法有多种&#xff0c;比如可以继承Thread类或者实现Runnable接口&#xff0c;结论是实现Runnable接口比前者更加优越。 二者代码对比 Java 不支持多继承&#xff0c;如果你继承了 Thread 类&#xff0c;就不能再继承其他类&#xff0c;实现 Runnable 接口后&am…
阅读更多...
PDF Base64格式字符串转换为PDF文件临时文件

PDF Base64格式字符串转换为PDF文件临时文件

需求描述&#xff1a; 在对接电子病历系统与河北CA&#xff0c;进行免密文件签章的时候&#xff0c;两者系统入参不同&#xff0c;前者是pdf文件&#xff0c;base64格式&#xff1b;后者要求File类型的PDF文件。 在业务中间层开发时&#xff0c;则需要接收EMR侧提供的base64格式…
阅读更多...
代码随想录训练营第二十三天| 572.另一颗树的子树 104.二叉树的最大深度 559.N叉树的最大深度 111.二叉树的最小深度

代码随想录训练营第二十三天| 572.另一颗树的子树 104.二叉树的最大深度 559.N叉树的最大深度 111.二叉树的最小深度

572.另一颗树的子树&#xff1a; 状态&#xff1a;已做出 思路&#xff1a; 这道题目当时第一时间不是想到利用100.相同的树思路来解决&#xff0c;而是先想到了使用kmp&#xff0c;不过这个题目官方题解确实是有kmp解法的&#xff0c;我使用的暴力解法&#xff0c;kmp的大致思…
阅读更多...
【RabbitMq C++】消息队列组件

【RabbitMq C++】消息队列组件

RabbitMq 消息队列组件 1. RabbitMq介绍2. 安装RabbitMQ3. 安装 RabbitMQ 的 C客户端库4. AMQP-CPP 库的简单使用4.1 使用4.1.1 TCP 模式4.1.2 扩展模式 4.2 常用类与接口介绍4.2.1 Channel4.3.2 ev 5. RabbitMQ样例编写5.1 发布消息5.2 订阅消息 1. RabbitMq介绍 RabbitMq - …
阅读更多...
鸿蒙NEXT开发动画案例8

鸿蒙NEXT开发动画案例8

1.创建空白项目 2.Page文件夹下面新建Spin.ets文件&#xff0c;代码如下&#xff1a; /*** SpinKit动画组件 (重构版)* author: CSDN-鸿蒙布道师* since: 2025/05/14*/interface AnimationGroup {indexes: number[];delay: number; }ComponentV2 export struct SpinEight {Re…
阅读更多...
MySQL全局优化

MySQL全局优化

目录 1 硬件层面优化 1.1 CPU优化 1.2 内存优化 1.3 存储优化 1.4 网络优化 2 系统配置优化 2.1 操作系统配置 2.2 MySQL服务配置 3 库表结构优化 4 SQL及索引优化 mysql可以从四个层面考虑优化&#xff0c;分别是 硬件系统配置库表结构SQL及索引 从成本和优化效果来看&#xf…
阅读更多...
vue和springboot交互数据，使用axios【跨域问题】

vue和springboot交互数据，使用axios【跨域问题】

vue和springboot交互数据&#xff0c;使用axios【跨域问题】 提示&#xff1a;帮帮志会陆续更新非常多的IT技术知识&#xff0c;希望分享的内容对您有用。本章分享的是node.js和vue的使用。前后每一小节的内容是存在的有&#xff1a;学习and理解的关联性。【帮帮志系列文章】&…
阅读更多...
FFMPEG 与 mp4

FFMPEG 与 mp4

1. FFmpeg 中的 start_time 与 time_base start_time 流的起始时间戳&#xff08;单位&#xff1a;time_base&#xff09;&#xff0c;表示第一帧的呈现时间&#xff08;Presentation Time&#xff09;。通常用于同步多个流&#xff08;如音频和视频&#xff09;。 time_base …
阅读更多...
AI世界的崩塌：当人类思考枯竭引发数据生态链断裂

AI世界的崩塌：当人类思考枯竭引发数据生态链断裂

AI世界的崩塌&#xff1a;当人类思考枯竭引发数据生态链断裂 ——论过度依赖AI创作对技术进化的反噬 一、数据生态的恶性循环&#xff1a;AI的“自噬危机” 当前AI模型的训练依赖于人类创造的原始数据——书籍、论文、艺术作品、社交媒体动态等。据统计&#xff0c;2025年全球…
阅读更多...
C++【STL】(2)string

C++【STL】(2)string

C【STL】string用法扩展 1. assign&#xff1a;为字符串赋新值 用于替换字符串内容&#xff0c;支持多种参数形式。 常用形式&#xff1a; // 用另一个字符串赋值 str.assign("Hello World");// 用另一个字符串的子串&#xff08;从第6个字符开始&#xff0c;取5…
阅读更多...
最新文章

Copyright @ 2022~2023