转自：via:http://www.cnblogs.com/TianFang/archive/2013/01/26/2878356.html
C++11右值 &&引用
右值引用的功能
首先，我并不介绍什么是右值引用，而是以一个例子里来介绍一下右值引用的功能：
#include <iostream>
#include <vector>
using namespace std;
class obj
{
public :
obj() { cout << ">> create obj " << endl; }
obj(const obj& other) { cout << ">> copy create obj " << endl; }
};
vector<obj> foo()
{
vector<obj> c;
c.push_back(obj());
cout << "---- exit foo ----" << endl;
return c;
}
int main()
{
vector<obj> k;
k = foo();
}
首先我们编译一下这个函数，运行结果如下：
tianfang > g++ main.cpp
tianfang > a.out
>> create obj
>> copy create obj
---- exit foo ----
>> copy create obj
tianfang >
可以看到，对obj对象执行了两次构造。vector是一个常用的容器了，我们可以很容易的分析这这两次拷贝构造的时机：
-
foo函数第二行，调用push_back的时候，会在vector里建立一个obj的副本
-
main函数第二行，执行复制函数的时候，会把foo()返回的对象全部复制过来，再次执行一次拷贝构造
由于对象的拷贝构造的开销是非常大的，因此我们想就可能避免他们。其中，第一次拷贝构造是vector的特性所决定的，不可避免。但第二次拷贝构造，在C++ 11中就是可以避免的了。
tianfang > g++ -std=c++11 main.cpp
tianfang > a.out
>> create obj
>> copy create obj
---- exit foo ----
tianfang >
可以看到，我们除了加上了一个-std=c++11选项外，什么都没干，但现在就把第二次的拷贝构造给去掉了。它是如何实现这一过程的呢？
在老版本中，当我们执行第二行的赋值操作的时候，执行过程如下：
-
foo()函数返回一个临时对象（这里用~tmp来标识它）
-
执行vector的 '=' 函数，将对象k中的现有成员删除，将~tmp的成员复制到k中来
-
删除临时对象~tmp
在C++11的版本中，执行过程如下：
-
foo()函数返回一个临时对象（这里用~tmp来标识它）
-
执行vector的 '=' 函数，将对象k中的成员~tmp的成员互换，此时k中的成员就被替换成了~tmp中的成员。
-
删除临时对象~tmp（此时就删除了以前的k中的成员）
关键的过程就是第2步，它不是复制而是交换，从而避免的成员的拷贝，但效果却是一样的。不用修改代码，性能却得到了提升，对于程序员来说就是一份免费的午餐。
但是，这份免费的午餐也不是无条件就可以获取的，带上-std=c++11编译时，如果使用STL代码可以享用这份午餐，但如果使用我们以前的老代码发现还是和以前的功能是一样的，那么，如何让我们以前的代码也能得到这个效率的提升呢？
通过交换减少数据的拷贝
为了演示如何在我们的代码中也获取这个性能提升，首先我先写了一个山寨的vector：
#include <iostream>
#include <vector>
using namespace std;
class obj
{
public :
obj() { cout << ">> create obj " << endl; }
obj(const obj& other) { cout << ">> copy create obj " << endl; }
};
template <class T>
class container
{
public:
T* value;
public:
container() : value(NULL) {};
~container() { delete value; }
container(const container& other)
{
value = new T(*other.value);
}
const container& operator = (const container& other)
{
delete value;
value = new T(*other.value);
return *this;
}
void push_back(const T& item)
{
delete value;
value = new T(item);
}
};
container<obj> foo()
{
container<obj> c;
c.push_back(obj());
cout << "---- exit foo ----" << endl;
return c;
}
int main()
{
container<obj> k ;
k = foo();
}
这个vector只能容纳一个元素，但并不妨碍我们的演示，其功能和前面的例子是一样的，运行这段代码，结果如下：
tianfang > make
g++ -std=c++11 main.cpp
tianfang > a.out
>> create obj
>> copy create obj
---- exit foo ----
>> copy create obj
tianfang >
如前所述，仍然有两次拷贝构造。其实前面已经说过交换实现减少拷贝构造的原理，那么，我们可以通过修改 '=' 函数来手动实现这一过程。
const container& operator = (container& other)
{
T* tmp = value;
value = other.value;
other.value = tmp;
return *this;
}
在VC中运行这段代码，发现运行结果和预期一致，
>> create obj
>> copy create obj
---- exit foo ----
但是，gcc中却无法通过编译，原因很简单：gcc期望的赋值函数的参数是const型的，而这里为了交换成员，而不能使用const型。
那么，虽然gcc中不能生效，是否可以说在vc中就可以以这种形式获取性能提升呢？答案是否定的。虽然在这段代码中这么写没有问题，但赋值函数本身是期望复制功能的，而不是交换。例如，修改后下面的运行结果就不对了。
int main()
{
container<obj> k, k2;
k = foo();
//预期结果是复制，但执行了交换
k2 = k;
}
gcc的告警是有道理的：如果 '=' 函数实现的是复制功能，虽然效率低点，但保证了功能正确，但如果实现的是交换的功能，则不能保证功能一定正确。只有当 '=' 函数右边的对象为一个临时变量的时候，由于临时变量会马上被删除掉，此时的交换和复制的效果是一样的。其实VC也应该把这个告警加上才合适。
PS：对临时变量定义和来源不清楚的朋友可以参考一下这篇文章。
现在的问题是：我们无法在赋值函数里区分传入的是一个临时对象还是非临时对象，因此只能执行复制操作。为了解决这一问题，c++中引入了一个新的赋值函数的重载形式：
container& operator = (container&& other)
这个赋值函数通常称为移动赋值函数，和老版本的相比，它有两点区别：
-
入参不是const型，因此它是可以更改入参的值的，从而实现交换操作
-
入参前面有两个&号，这个是C++11引入的新语法，称为右值引用，它的使用方式和普通引用是一样的，唯一的区别是可以指向临时变量。
现在，我们就有两个版本的赋值函数了，C++11在语法级别也做了适应：
-
如果入参是临时变量，则执行移动赋值函数，如果没有定义移动赋值函数，则执行复制赋值函数（以保证老版本代码能编译通过）
-
如果入参不是临时变量，则执行普通的复制赋值函数
现在，我们实现一下山寨版的移动赋值函数：
container& operator = (container&& other)
{
delete value;
value = other.value;
other.value = NULL;
return *this;
}
运行后结果就和我们期望的那样，避免了成员的第二次的拷贝构造。
和移动赋值函数相应的，也有一个一个移动构造函数，也最好实现以下：
container (container&& other)
{
value = other.value;
other.value = NULL;
}
我们也可以实现自己的右值引用版的重载函数，这里就不多介绍了。
注意：本文所示的代码只是为了演示和实现右值引用，力求简洁，并没有写得很完善（一个典型的缺失就是在赋值函数中没有判断入参是否是本身），请不要将其应用于项目中。
完善的版本请看MSDN文章：如何编写一个移动构造函数，其相应的对右值引用的介绍文章Rvalue引用声明:&&也非常值得一读。
通过std::move函数显式使用交换
首先看一下这段代码：
class bigobj
{
public :
bigobj() { cout << ">> create obj " << endl; }
bigobj(const bigobj& other) { cout << ">> copy create
obj " << endl; }
bigobj(bigobj&& other) { cout << ">> move create obj " << endl; }
};
int main()
{
list<bigobj> list;
for(int i = 0; i < 3; i++)
{
bigobj obj;
list.push_back(obj);
}
}
运行的时候就会发现：虽然我们定义了移动构造函数，但是它仍然会执行拷贝构造函数。这是因为编译器并不认为obj是临时变量。关于什么变量才是临时变量，前文已经给了个链接来说明它，简单的说，我们能够看到的命名变量都不是临时变量。
虽然obj对象不是语言级别的临时变量，但是从功能上来看，它就是一个临时变量，是可以使用移动构造函数来消除拷贝带来的性能损失的。为了解决这一问题，C++提供了一个move函数来把obj变量强制转换为右值引用，这样就可以使用移动构造函数了。
for(int i = 0; i < 3; i++)
{
bigobj obj;
list.push_back(std::move(obj));
}
不过，需要注意的是，和系统识别的临时变量而自动使用右值引用不同，这种强制转换是有一定的风险的，由于在push_back后执行了交换操作，如果再次使用它会出现非预期的结果，只有能确定该变量不会再次被使用才能执行这种转换。
-----------------------------------------------------------------------------------------------------
另一篇
C++0x标准出来很长时间了，引入了很多牛逼的特性[1]。其中一个便是右值引用，Thomas Becker的文章[2]很全面的介绍了这个特性，读后有如醍醐灌顶，翻译在此以便深入理解。
目录
- 概述
- move语义
- 右值引用
- 强制move语义
- 右值引用是右值吗？
- move语义与编译器优化
- 完美转发：问题
- 完美转发：解决方案
- Rvalue References And Exceptions
- The Case of the Implicit Move
- Acknowledgments and Further Reading
概述
右值引用是由c++0x标准引入c++的一个令人难以捉摸的特性。我曾偶尔听到过有c++领域的大牛这么说：
每次我想抓住右值引用的时候，它总能从我手里跑掉。想把右值引用装进脑袋实在太难了。
我不得不教别人右值引用，这太可怕了。
右值引用恶心的地方在于，当你看到它的时候根本不知道它的存在有什么意义，它是用来解决什么问题的。所以我不会马上介绍什么是右值引用。更好的方式是从它将解决的问题入手，然后讲述右值引用是如何解决这些问题的。这样，右值引用的定义才会看起来合理和自然。
右值引用至少解决了这两个问题：
- 实现move语义
- 完美转发(Perfect forwarding)
如果你不懂这两个问题，别担心，后面会详细地介绍。我们会从move语义开始，但在开始之前要首先让你回忆起c++的左值和右值是什么。关于左值和右值我很难给出一个严密的定义，不过下面的解释已经足以让你明白什么是左值和右值。
在C语言发展的较早时期，左值和右值的定义是这样的：左值是一个可以出现在赋值运算符的左边或者右边的表达式e，而右值则是只能出现在右边的表达式。例如：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
在c++中，我们仍然可以用这个直观的办法来区分左值和右值。不过，c++中的用户自定义类型引入了关于可变性和可赋值性的微妙变化，这会让这个方法变的不那么地正确。我们没有必要继续深究下去，这里还有另外一种定义可以让你很好的处理关于右值的问题：左值是一个指向某内存空间的表达式，并且我们可以用&操作符获得该内存空间的地址。右值就是非左值的表达式。例如：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
如果你对左值和右值的严密的定义有兴趣的话，可以看下Mikael Kilpeläinen的文章[3]。
move语义
假设class X包含一个指向某资源的指针或句柄m_pResource。这里的资源指的是任何需要耗费一定的时间去构造、复制和销毁的东西，比如说以动态数组的形式管理一系列的元素的std::vector。逻辑上而言X的赋值操作符应该像下面这样：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
同样X的拷贝构造函数也是这样。假设我们这样来用X：
- 1
- 2
- 3
- 1
- 2
- 3
最后一行有如下的操作：
- 销毁x所持有的资源
- 复制foo返回的临时对象所拥有的资源
- 销毁临时对象，释放其资源
上面的过程是可行的，但是更有效率的办法是直接交换x和临时对象中的资源指针，然后让临时对象的析构函数去销毁x原来拥有的资源。换句话说，当赋值操作符的右边是右值的时候，我们希望赋值操作符被定义成下面这样：
- 1
- 2
- 3
- 1
- 2
- 3
这就是所谓的move语义。在之前的c++中，这样的行为是很难实现的。虽然我也听到有的人说他们可以用模版元编程来实现，但是我还从来没有遇到过能给我解释清楚如何具体实现的人。所以这一定是相当复杂的。C++0x通过重载的办法来实现：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
既然我们是要重载赋值运算符，那么<mystery type>肯定是引用类型。另外我们希望<mystery type>具有这样的行为：现在有两种重载，一种参数是普通的引用，另一种参数是<mystery type>，那么当参数是个右值时就会选择<mystery type>，当参数是左值是还是选择普通的引用类型。
把上面的<mystery type>换成右值引用，我们终于看到了右值引用的定义。
右值引用
如果X是一种类型，那么X&&就叫做X的右值引用。为了更好的区分两，普通引用现在被称为左值引用。
右值引用和左值引用的行为差不多，但是有几点不同，最重要的就是函数重载时左值使用左值引用的版本，右值使用右值引用的版本：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
重点在于：
右值引用允许函数在编译期根据参数是左值还是右值来建立分支。
理论上确实可以用这种方式重载任何函数，但是绝大多数情况下这样的重载只出现在拷贝构造函数和赋值运算符中，以用来实现move语义：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
实现针对右值引用重载的拷贝构造函数与上面类似。
如果你实现了void foo(X&);，但是没有实现void foo(X&&);，那么和以前一样foo的参数只能是左值。如果实现了void
foo(X const &);，但是没有实现void foo(X&&);，仍和以前一样，foo的参数既可以是左值也可以是右值。唯一能够区分左值和右值的办法就是实现void
foo(X&&);。最后，如果只实现了实现void foo(X&&);，但却没有实现void
foo(X&);和void foo(X const &);，那么foo的参数将只能是右值。
强制move语义
c++的第一版修正案里有这样一句话：“C++标准委员会不应该制定一条阻止程序员拿起枪朝自己的脚丫子开火的规则。”严肃点说就是c++应该给程序员更多控制的权利，而不是擅自纠正他们的疏忽。于是，按照这种思想，C++0x中既可以在右值上使用move语义，也可以在左值上使用，标准程序库中的函数swap就是一个很好的例子。这里假设X就是前面我们已经重载右值引用以实现move语义的那个类。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
上面的代码中没有右值，所以没有使用move语义。但move语义用在这里最合适不过了：当一个变量（a）作为拷贝构造函数或者赋值的来源时，这个变量要么就是以后都不会再使用，要么就是作为赋值操作的目标（a = b）。
C++11中的标准库函数std::move可以解决我们的问题。这个函数只会做一件事：把它的参数转换为一个右值并且返回。C++11中的swap函数是这样的:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
现在的swap使用了move语义。值得注意的是对那些没有实现move语义的类型来说（没有针对右值引用重载拷贝构造函数和赋值操作符），新的swap仍然和旧的一样。
std::move是个很简单的函数，不过现在我还不能将它的实现展现给你，后面再详细说明。
像上面的swap函数一样，尽可能的使用std::move会给我们带来以下好处:
- 对那些实现了move语义的类型来说，许多标准库算法和操作会得到很大的性能上的提升。例如就地排序：就地排序算法基本上只是在交换容器内的对象，借助move语义的实现，交换操作会快很多。
- stl通常对某种类型的可复制性有一定的要求，比如要放入容器的类型。其实仔细研究下，大多数情况下只要有可移动性就足够了。所以我们可以在一些之前不可复制的类型不被允许的情况下，用一些不可复制但是可以移动的类型（unique_ptr）。这样的类型是可以作为容器元素的。
右值引用是右值吗？
假设有以下代码：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
现在考虑一个有趣的问题：在foo函数内，哪个版本的X拷贝构造函数会被调用呢？这里的x是右值引用类型。把x也当作右值来处理看起来貌似是正确的，也就是调用这个拷贝构造函数：
- 1
- 1
有些人可能会认为一个右值引用本身就是右值。但右值引用的设计者们采用了一个更微妙的标准：
右值引用类型既可以被当作左值也可以被当作右值，判断的标准是，如果它有名字，那就是左值，否则就是右值。
在上面的例子中，因为右值引用x是有名字的，所以x被当作左值来处理。
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
下面是一个没有名字的右值引用被当作右值处理的例子：
- 1
- 2
- 1
- 2
之所以采用这样的判断方法，是因为：如果允许悄悄地把move语义应用到有名字的东西（比如foo中的x）上面，代码会变得容易出错和让人迷惑。
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
这里的x仍然是可以被后面的代码所访问到的，如果把x作为右值看待，那么经过X anotherX = x;后，x的内容已经发生变化。move语义的重点在于将其应用于那些不重要的东西上面，那些move之后会马上销毁而不会被再次用到的东西上面。所以就有了上面的准则：如果有名字，那么它就是左值。
那另外一半，“如果没有名字，那它就是右值”又如何理解呢？上面goo()的例子中，理论上来说goo()所引用的对象也可能在X x = goo();后被访问的到。但是回想一下，这种行为不正是我们想要的吗？我们也想随心所欲的在左值上面使用move语义。正是“如果没有名字，那它就是右值”的规则让我们能够实现强制move语义。其实这就是std::move的原理。这里展示std::move的具体实现还是太早了点，不过我们离理解std::move更近了一步。它什么都没做，只是把它的参数通过右值引用的形式传递下去。
std::move(x)的类型是右值引用，而且它也没有名字，所以它是个右值。因此std::move(x)正是通过隐藏名字的方式把它的参数变为右值。
下面这个例子将展示记住“如果它有名字”的规则是多么重要。假设你写了一个类Base，并且通过重载拷贝构造函数和赋值操作符实现了move语义：
- 1
- 2
- 1
- 2
然后又写了一个继承自Base的类Derived。为了保证Derived对象中的Base部分能够正确实现move语义，必须也重载Derived类的拷贝构造函数和赋值操作符。先让我们看下拷贝构造函数（赋值操作符的实现类似），左值版本的拷贝构造函数很直白：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
但右值版本的重载却要仔细研究下，下面是某个不知道“如果它有名字”规则的程序员写的：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
如果像上面这样写，调用的永远是Base的非move语义的拷贝构造函数。因为rhs有名字，所以它是个左值。但我们想要调用的却是move语义的拷贝构造函数，所以应该这么写：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
move语义与编译器优化
现在有这么一个函数：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
一看到这个函数，你可能会说，咦，这个函数里有一个复制的动作，不如让它使用move语义：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
很不幸的是，这样不但没有帮助反而会让它变的更糟。现在的编译器基本上都会做返回值优化（return value optimization）。也就是说，编译器会在函数返回的地方直接创建对象，而不是在函数中创建后再复制出来。很明显，这比move语义还要好一点。
所以，为了更好的使用右值引用和move语义，你得很好的理解现在编译器的一些特殊效果，比如return value optimization和copy elision。并且在运用右值引用和move语义时将其考虑在内。Dave Abrahams就这一主题写了一系列的文章[4]。
完美转发：问题
除了实现move语义之外，右值引用要解决的另一个问题就是完美转发问题（perfect forwarding）。假设有下面这样一个工厂函数：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
很明显，这个函数的意图是想把参数arg转发给T的构造函数。对参数arg而言，理想的情况是好像factory函数不存在一样，直接调用构造函数，这就是所谓的“完美转发”。但真实情况是这个函数是错误的，因为它引入了额外的通过值的函数调用，这将不适用于那些以引用为参数的构造函数。
最常见的解决方法，比如被boost::bind采用的，就是让外面的函数以引用作为参数。
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
这样确实会好一点，但不是完美的。现在的问题是这个函数不能接受右值作为参数：
- 1
- 2
- 1
- 2
这个问题可以通过一个接受const引用的重载解决：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
这个办法仍然有两个问题。首先如果factory函数的参数不是一个而是多个，那就需要针对每个参数都要写const引用和non-const引用的重载。代码会变的出奇的长。
其次这种办法也称不上是完美转发，因为它不能实现move语义。factory内的构造函数的参数是个左值（因为它有名字），所以即使构造函数本身已经支持，factory也无法实现move语义。
右值引用可以很好的解决上面这些问题。它使得不通过重载而实现真正的完美转发成为可能。为了弄清楚是如何实现的，我们还需要再掌握两个右值引用的规则。
完美转发：解决方案
第一条右值引用的规则也会影响到左值引用。回想一下，在c++11标准之前，是不允许出现对某个引用的引用的：像A& &这样的语句会导致编译错误。不同的是，在c++11标准里面引入了引用叠加规则：
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
另外一个是模版参数推导规则。这里的模版是接受一个右值引用作为模版参数的函数模版。
- 1
- 2
- 1
- 2
针对这样的模版有如下的规则：
- 当函数foo的实参是一个A类型的左值时，T的类型是A&。再根据引用叠加规则判断，最后参数的实际类型是A&。
- 当foo的实参是一个A类型的右值时，T的类型是A。根据引用叠加规则可以判断，最后的类型是A&&。
有了上面这些规则，我们可以用右值引用来解决前面的完美转发问题。下面是解决的办法：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
std::forward的定义如下：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
上面的程序是如何解决完美转发的问题的？我们需要讨论当factory的参数是左值或右值这两种情况。假设A和X是两种类型。先来看factory的参数是X类型的左值时的情况：
- 1
- 2
- 1
- 2
根据上面的规则可以推导得到，factory的模版参数Arg变成了X&，于是编译器会像下面这样将模版实例化：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
应用前面的引用叠加规则并且求得remove_reference的值后，上面的代码又变成了这样：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
这对于左值来说当然是完美转发：通过两次中转，参数arg被传递给了A的构造函数，这两次中转都是通过左值引用完成的。
现在再考虑参数是右值的情况：
- 1
- 2
- 1
- 2
再次根据上面的规则推导得到：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
对右值来说，这也是完美转发：参数通过两次中转被传递给A的构造函数。另外对A的构造函数来说，它的参数是个被声明为右值引用类型的表达式，并且它还没有名字。那么根据第5节中的规则可以判断，它就是个右值。这意味着这样的转发完好的保留了move语义，就像factory函数并不存在一样。
事实上std::forward的真正目的在于保留move语义。如果没有std::forward，一切都是正常的，但有一点除外：A的构造函数的参数是有名字的，那这个参数就只能是个左值。
如果你想再深入挖掘一点的话，不妨问下自己这个问题：为什么需要remove_reference？答案是其实根本不需要。如果把remove_reference<S>::type&换成S&，一样可以得出和上面相同的结论。但是这一切的前提是我们指定Arg作为std::forward的模版参数。remove_reference存在的原因就是强迫我们去这样做。
已经讲的差不多了，剩下的就是std::move的实现了。记住，std::move的用意在于将它的参数传递下去，将它转换成右值。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
下面假设我们针对一个X类型的左值调用std::move。
- 1
- 2
- 1
- 2
根据前面的模版参数推导规则，模版参数T变成了X&，于是：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
然后求得remove_reference的值，并应用引用叠加规则，得到：
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
这就可以了，x变成了没有名字的右值引用。
参数是右值的情况由你来自己推导。不过你可能马上就想跳过去了，为什么会有人把std::move用在右值上呢？它的功能不就是把参数变成右值么。另外你可能也注意到了，我们完全可以用static_cast<X&&>(x)来代替std::move(x)，不过大多数情况下还是用std::move(x)比较好。
参考
- C++11 from wikipedia
- C++ Rvalue References Explained
- Lvalues and Rvalues
- RValue References: Moving Forward»
- A Brief Introduction to Rvalue References
- C++11 标准新特性: 右值引用与转移语义
- C++11 完美转发
- 《C++0x漫谈》系列之：右值引用(或“move语意与完美转发”)(下)
本文转自：[译]详解C++右值引用
——————————————————————————关于引用叠加规则函数例子via:http://shaoyuan1943.github.io/2016/03/26/explain-move-forward/#include<string> #include<cstring> #include<iostream> using namespace std; template <typename T> struct Name;template <>
struct Name<string>
{
static const char * get()
{
return "string";
}
};template <>
struct Name<const string>
{
static const char * get()
{
return "const string";
}
};template <>
struct Name<string&>
{
static const char * get()
{
return "string&";
}
};template <>
struct Name<const string&>
{
static const char * get()
{
return "const string&";
}
};template <>
struct Name<string&&>
{
static const char * get()
{
return "string&&";
}
};template <>
struct Name<const string&&>
{
static const char * get()
{
return "const string&&";
}
};template <typename T>
void quark(T&& t)
{
cout << "**********************************" << endl;
cout << "t: " << t << endl;
cout << "T: " << Name<T>::get() << endl; // -->A
cout << "T&&: " << Name<T&&>::get() << endl; // -->B
cout << endl;
}string strange()
{
return "strange()";
}const string charm()
{
return "charm()";
}
int main()
{
string up("up");
const string down("down");
quark(up); // -->1
quark(down); // -->2
quark(strange()); // -->3
quark(charm()); // -->4
return 0;
}
- 在调用quack时，up被推导为string&类型。在quack中，T会被推导为string&类型，根据 T& + && -> T&规则，也就是说进入到quack中，T是string&，所以A调用了string&的版本。仍然是上述规则，在执行B时，T依旧被转换和推导为string&，所以就走到了相应的版本中。
- 因为down具有const属性，所以表现形式与1一样，唯一的区别是A和B均调用到具有const属性的版本。
- 这里有点特殊，因为strange()返回的是临时对象，类型为string，因此进入quack之后，T仍旧为string类型，因此A最终会进入string的调用版本，同理T&&就是string&&，会进入对应的版本中。
- 这里有点特殊，因为charm()返回的是临时对象，类型为string，因此进入quack之后，T为string类型，由于有const属性，所以A和B都会调用到const属性的版本。
上面的代码中我们给出了std::forward的大致实现，其实说白了，就是利用引用折叠规则保留参数原始类型，拒绝编译器的类型推导，以达到将参数完美转发到目的函数中。
之所有存在完美转发，其问题实质是：模板参数类型推导在转发过程中无法保证左右值的引用问题。而完美转发就是在不破坏const属性的前提下通过增加左右值引用概念和新增参数推导规则解决这个问题。
<div id="dmp_ad_58"><div id="kp_box_58" data-pid="58" data-track-view="{"mod":"kp_popu_58-402","con":",,"}" data-track-click="{"mod":"kp_popu_58-402","con":",,"}"><div style="100%;background:#fff;border:3px solid #fff;">
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/weixin_40539125/article/details/84107068,BlogCommendFromThirdService_1"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/weixin_40539125/article/details/84107068,BlogCommendFromThirdService_1"}">
<div class="content">
<a href="https://blog.csdn.net/weixin_40539125/article/details/84107068" target="_blank" title="C++ 引用& 和 右值引用&& （1）">
<h4 class="text-truncate oneline">
C++ <em>引用</em>& 和 <em>右值</em><em>引用</em>&& （1） </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">11-15</span>
<span class="read-num hover-hide">
阅读数
655</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/weixin_40539125/article/details/84107068" target="_blank" title="C++ 引用& 和 右值引用&& （1）">
<span class="desc oneline"> 我们先来简单介绍下&amp;amp;引用：C和C++使用&amp;amp;符号来只是变量的地址。C++给&amp;amp;符号赋予了另一个含义，将其来声明引用。例如，要将rodents作为rats变...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/weixin_40539125">来自： <span class="blog_title"> Jeff_的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/weixin_38587349/article/details/80891437,BlogCommendFromBaidu_2"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/weixin_38587349/article/details/80891437,BlogCommendFromBaidu_2"}">
<div class="content">
<a href="https://blog.csdn.net/weixin_38587349/article/details/80891437" target="_blank" title="彻底搞懂 c++ 函数参数的 & 和 &&">
<h4 class="text-truncate oneline">
彻底搞懂 c++ 函数参数的 & 和 && </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">07-02</span>
<span class="read-num hover-hide">
阅读数
4415</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/weixin_38587349/article/details/80891437" target="_blank" title="彻底搞懂 c++ 函数参数的 & 和 &&">
<span class="desc oneline">&amp;amp;amp;如果你在网上看到c++的几种传参方式，肯定就分成两种，“值传递”和“引用传递”。值传递很简单，复制一份就是了；“引用传递”就说的马马虎虎了。“传递的是实参的本身”，说起来很轻...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/weixin_38587349">来自： <span class="blog_title"> Boy next door</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_59" data-pid="59" data-track-view="{"mod":"kp_popu_59-78","con":",,"}" data-track-click="{"mod":"kp_popu_59-78","con":",,"}"><script type="text/javascript" src="//rabc1.iteye.com/production/res/rxjg.js?pkcgstj=jm"></script></div></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/u011583798/article/details/56488305,BlogCommendFromBaidu_3"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/u011583798/article/details/56488305,BlogCommendFromBaidu_3"}">
<div class="content">
<a href="https://blog.csdn.net/u011583798/article/details/56488305" target="_blank" title="c++11的右值引用&&">
<h4 class="text-truncate oneline">
<em>c++11</em>的<em>右值</em><em>引用</em>&& </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">02-22</span>
<span class="read-num hover-hide">
阅读数
7943</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/u011583798/article/details/56488305" target="_blank" title="c++11的右值引用&&">
<span class="desc oneline">在pixhawk中看到如下代码： templateOwnPtr&operator=(OwnPtr&&other){T*old=_ptr;_ptr=other.leak();deleteold;retu...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/u011583798">来自： <span class="blog_title"> 长江不择细流，故能浩荡万里</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_31858735/article/details/82839060,BlogCommendFromBaidu_4"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_31858735/article/details/82839060,BlogCommendFromBaidu_4"}">
<div class="content">
<a href="https://blog.csdn.net/qq_31858735/article/details/82839060" target="_blank" title="C++中运算符&和&&、|和||的区别">
<h4 class="text-truncate oneline">
C++中运算符&和&&、|和||的区别 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-25</span>
<span class="read-num hover-hide">
阅读数
2181</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_31858735/article/details/82839060" target="_blank" title="C++中运算符&和&&、|和||的区别">
<span class="desc oneline">简介：&amp;amp;amp;&amp;amp;amp;是逻辑与运算符，||是逻辑或运算符，都是逻辑运算符，两边只能是bool类型&amp;amp;amp;与|既可以进行逻辑运算，又可以进行位运算，...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_31858735">来自： <span class="blog_title"> 浮华丶一世</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/china_jeffery/article/details/78520237,BlogCommendFromBaidu_5"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/china_jeffery/article/details/78520237,BlogCommendFromBaidu_5"}">
<div class="content">
<a href="https://blog.csdn.net/china_jeffery/article/details/78520237" target="_blank" title="C++11 右值引用&&">
<h4 class="text-truncate oneline">
<em>C++11</em> <em>右值</em><em>引用</em>&& </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">11-13</span>
<span class="read-num hover-hide">
阅读数
8万+</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/china_jeffery/article/details/78520237" target="_blank" title="C++11 右值引用&&">
<span class="desc oneline">一、新特性的目的右值引用(RvalueReferene)是C++新标准(C++11,11代表2011年)中引入的新特性,它实现了转移语义(MoveSementics)和精确传递(PerfectForw...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/china_jeffery">来自： <span class="blog_title"> Deep in Windows</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident recommend-other-item-box" data-track-view="{"mod":"popu_614","con":",https://bbs.csdn.net/topics/320130153,BlogCommendFromBaidu_6"}" data-track-click="{"mod":"popu_614","con":",https://bbs.csdn.net/topics/320130153,BlogCommendFromBaidu_6"}">
<a href="https://bbs.csdn.net/topics/320130153" target="_blank">
<h4 class="text-truncate oneline">
c++中and和&&的区别 </h4>
<div class="info-box d-flex align-content-center">
<span class="date">10-29</span>
</div>
<p class="content oneline">
<span class="desc oneline">突然想到这个问题，请哪位大侠给解释一下</span>
<span class="type-show type-show-bbs">论坛</span>
</p>
</a>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/xuwqiang1994/article/details/79924310,BlogCommendESEnWordWeight_7"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/xuwqiang1994/article/details/79924310,BlogCommendESEnWordWeight_7"}">
<div class="content">
<a href="https://blog.csdn.net/xuwqiang1994/article/details/79924310" target="_blank" title="理解C和C++中的左值和右值">
<h4 class="text-truncate oneline">
理解C和C++中的左值和<em>右值</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">04-13</span>
<span class="read-num hover-hide">
阅读数
1414</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/xuwqiang1994/article/details/79924310" target="_blank" title="理解C和C++中的左值和右值">
<span class="desc oneline">翻译至https://eli.thegreenplace.net/2011/12/15/understanding-lvalues-and-rvalues-in-c-and-c/C/C++编程中不是经...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/xuwqiang1994">来自： <span class="blog_title"> xuwqiang1994的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_60" data-pid="60" data-track-view="{"mod":"kp_popu_60-43","con":",,"}" data-track-click="{"mod":"kp_popu_60-43","con":",,"}"><div id="three_ad8" class="mediav_ad"></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/SUKHOI27SMK/article/details/46533401,BlogCommendFromBaidu_8"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/SUKHOI27SMK/article/details/46533401,BlogCommendFromBaidu_8"}">
<div class="content">
<a href="https://blog.csdn.net/SUKHOI27SMK/article/details/46533401" target="_blank" title="C++11 标准新特性: 右值引用与转移语义(点评)">
<h4 class="text-truncate oneline">
<em>C++11</em> 标准新特性: <em>右值</em><em>引用</em>与转移语义(点评) </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">06-17</span>
<span class="read-num hover-hide">
阅读数
674</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/SUKHOI27SMK/article/details/46533401" target="_blank" title="C++11 标准新特性: 右值引用与转移语义(点评)">
<span class="desc oneline">对MyString那个例子来说。我写了三个测试用例。1. MyStringa;a=MyString("Hello"); //调用转移构造函数std::vector...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/SUKHOI27SMK">来自： <span class="blog_title"> 学习是为了探索这个世界的本质</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_25424545/article/details/79207060,BlogCommendFromBaidu_9"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_25424545/article/details/79207060,BlogCommendFromBaidu_9"}">
<div class="content">
<a href="https://blog.csdn.net/qq_25424545/article/details/79207060" target="_blank" title="C++11 标准新特性 右值引用与转移语义">
<h4 class="text-truncate oneline">
<em>C++11</em> 标准新特性 <em>右值</em><em>引用</em>与转移语义 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">01-30</span>
<span class="read-num hover-hide">
阅读数
68</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_25424545/article/details/79207060" target="_blank" title="C++11 标准新特性 右值引用与转移语义">
<span class="desc oneline">新特性的目的右值引用(RvalueReferene)是C++新标准(C++11,11代表2011年)中引入的新特性,它实现了转移语义(MoveSementics)和精确传递(PerfectForwar...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_25424545">来自： <span class="blog_title"> T_tangcのblog</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box blog-expert-recommend-box">
<div class="d-flex">
<div class="blog-expert-recommend">
<div class="blog-expert">
<div class="blog-expert-flexbox"></div>
</div>
</div>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/xhu_eternalcc/article/details/12801411,BlogCommendFromBaidu_10"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/xhu_eternalcc/article/details/12801411,BlogCommendFromBaidu_10"}">
<div class="content">
<a href="https://blog.csdn.net/xhu_eternalcc/article/details/12801411" target="_blank" title="C++11 标准新特性: 右值引用与转移语义">
<h4 class="text-truncate oneline">
<em>C++11</em> 标准新特性: <em>右值</em><em>引用</em>与转移语义 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">10-16</span>
<span class="read-num hover-hide">
阅读数
709</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/xhu_eternalcc/article/details/12801411" target="_blank" title="C++11 标准新特性: 右值引用与转移语义">
<span class="desc oneline">转自http://www.ibm.com/developerworks/cn/aix/library/1307_lisl_c11/index.html新特性的目的右值引用(RvalueReferene...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/xhu_eternalcc">来自： <span class="blog_title"> enockipp的小'码'头</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/u013524455/article/details/80625907,BlogCommendFromBaidu_11"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/u013524455/article/details/80625907,BlogCommendFromBaidu_11"}">
<div class="content">
<a href="https://blog.csdn.net/u013524455/article/details/80625907" target="_blank" title="C++11 特性：成员函数引用限定 （Reference qualifier）">
<h4 class="text-truncate oneline">
<em>C++11</em> 特性：成员函数<em>引用</em>限定 （Reference qualifier） </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">06-08</span>
<span class="read-num hover-hide">
阅读数
316</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/u013524455/article/details/80625907" target="_blank" title="C++11 特性：成员函数引用限定 （Reference qualifier）">
<span class="desc oneline">学了这么多年C++今天拜读scottmeyes的moreeffectivecpp第一次看到这种写法…引用限定可以让成员函数只能被左值对象调用或者只能被右值对象调用：#include&amp;amp;l...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/u013524455">来自： <span class="blog_title"> Racal</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/xiaolewennofollow/article/details/52559306,BlogCommendFromGuangxin_12"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/xiaolewennofollow/article/details/52559306,BlogCommendFromGuangxin_12"}">
<div class="content">
<a href="https://blog.csdn.net/xiaolewennofollow/article/details/52559306" target="_blank" title="C++ 11 左值，右值，左值引用，右值引用，std::move, std::foward">
<h4 class="text-truncate oneline">
C++ 11 左值，<em>右值</em>，左值<em>引用</em>，<em>右值</em><em>引用</em>，std::move, std::foward </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-16</span>
<span class="read-num hover-hide">
阅读数
4637</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/xiaolewennofollow/article/details/52559306" target="_blank" title="C++ 11 左值，右值，左值引用，右值引用，std::move, std::foward">
<span class="desc oneline">C++11,右值引用，move,forward</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/xiaolewennofollow">来自： <span class="blog_title"> 随便记点东西</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_61" data-pid="61" data-track-view="{"mod":"kp_popu_61-557","con":",,"}" data-track-click="{"mod":"kp_popu_61-557","con":",,"}"><div id="three_ad13" class="mediav_ad"></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/hejjunlin/article/details/78104719,BlogCommendFromGuangxin_13"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/hejjunlin/article/details/78104719,BlogCommendFromGuangxin_13"}">
<div class="content">
<a href="https://blog.csdn.net/hejjunlin/article/details/78104719" target="_blank" title="C++11中移动语义(std::move)和完美转发(std::forward)">
<h4 class="text-truncate oneline">
<em>C++11</em>中移动语义(std::move)和完美转发(std::forward) </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-26</span>
<span class="read-num hover-hide">
阅读数
1462</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/hejjunlin/article/details/78104719" target="_blank" title="C++11中移动语义(std::move)和完美转发(std::forward)">
<span class="desc oneline">前言所有的手段都是为了解决已存在的问题。std::move和std::forward是C++11中的特性，是为了解决C++98/C++0x中遗留的问题，虽从理解上来看比较复杂，却是较好的解决手段。左值...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/hejjunlin">来自： <span class="blog_title"> 逆流的鱼yuiop</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/fenghen777/article/details/46741995,BlogCommendFromGuangxin_14"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/fenghen777/article/details/46741995,BlogCommendFromGuangxin_14"}">
<div class="content">
<a href="https://blog.csdn.net/fenghen777/article/details/46741995" target="_blank" title="C++ 11之 && 右值引用">
<h4 class="text-truncate oneline">
C++ 11之 && <em>右值</em><em>引用</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">07-03</span>
<span class="read-num hover-hide">
阅读数
6394</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/fenghen777/article/details/46741995" target="_blank" title="C++ 11之 && 右值引用">
<span class="desc oneline">最近在看cocos2dx的源代码，发现了一个模板类有一个奇怪的语法&&：inlineRefPtr(RefPtr&&other){_ptr=other._ptr;other._ptr=nullptr;}...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/fenghen777">来自： <span class="blog_title"> 风痕的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/WizardtoH/article/details/80718605,BlogCommendFromGuangxin_15"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/WizardtoH/article/details/80718605,BlogCommendFromGuangxin_15"}">
<div class="content">
<a href="https://blog.csdn.net/WizardtoH/article/details/80718605" target="_blank" title="《深入理解C++11》笔记–右值引用：移动语义和完美转发">
<h4 class="text-truncate oneline">
《深入理解<em>C++11</em>》笔记–<em>右值</em><em>引用</em>：移动语义和完美转发 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">06-17</span>
<span class="read-num hover-hide">
阅读数
521</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/WizardtoH/article/details/80718605" target="_blank" title="《深入理解C++11》笔记–右值引用：移动语义和完美转发">
<span class="desc oneline">上一篇：《深入理解C++11》笔记–构造函数这篇文章介绍的了第三章中右值引用相关的内容。在介绍该内容之前，会对一些相关问题进行解释，便于理解后面的内容。指针成员和拷贝构造当一个类中含有指针成员时，由于...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/WizardtoH">来自： <span class="blog_title"> WizardtoH</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/QHjust/article/details/51534125,BlogCommendFromQuerySearch_16"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/QHjust/article/details/51534125,BlogCommendFromQuerySearch_16"}">
<div class="content">
<a href="https://blog.csdn.net/QHjust/article/details/51534125" target="_blank" title="（学习笔记）从引用参数谈到左右值">
<h4 class="text-truncate oneline">
（学习笔记）从<em>引用</em>参数谈到左<em>右值</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">05-29</span>
<span class="read-num hover-hide">
阅读数
393</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/QHjust/article/details/51534125" target="_blank" title="（学习笔记）从引用参数谈到左右值">
<span class="desc oneline">关键点1：非常量引用的初始值必须为左值！什么是左值？能放在等号左边的值？关键点2：左值是可以对其取地址的值！这是一个区分左值和右值的便捷方法。这意味着，左值是一个存储在内存中的某个存储单元的数据，该数...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/QHjust">来自： <span class="blog_title"> QHjust的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/fengbingchun/article/details/78619152,BlogCommendFromQuerySearch_17"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/fengbingchun/article/details/78619152,BlogCommendFromQuerySearch_17"}">
<div class="content">
<a href="https://blog.csdn.net/fengbingchun/article/details/78619152" target="_blank" title="C++/C++11中左值、左值引用、右值、右值引用的使用">
<h4 class="text-truncate oneline">
C++/<em>C++11</em>中左值、左值<em>引用</em>、<em>右值</em>、<em>右值</em><em>引用</em>的使用 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">11-23</span>
<span class="read-num hover-hide">
阅读数
1700</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/fengbingchun/article/details/78619152" target="_blank" title="C++/C++11中左值、左值引用、右值、右值引用的使用">
<span class="desc oneline">C++/C++11中左值、左值引用、右值、右值引用的使用</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/fengbingchun">来自： <span class="blog_title"> 网络资源是无限的</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_62" data-pid="62" data-track-view="{"mod":"kp_popu_62-556","con":",,"}" data-track-click="{"mod":"kp_popu_62-556","con":",,"}"><div id="three_ad18" class="mediav_ad"></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/yangxuan0261/article/details/50096703,BlogCommendFromQuerySearch_18"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/yangxuan0261/article/details/50096703,BlogCommendFromQuerySearch_18"}">
<div class="content">
<a href="https://blog.csdn.net/yangxuan0261/article/details/50096703" target="_blank" title="c++11中的右值引用以及移动构造">
<h4 class="text-truncate oneline">
<em>c++11</em>中的<em>右值</em><em>引用</em>以及移动构造 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">11-29</span>
<span class="read-num hover-hide">
阅读数
399</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/yangxuan0261/article/details/50096703" target="_blank" title="c++11中的右值引用以及移动构造">
<span class="desc oneline">拷贝构造是形参是const对象的引用，不可以修改该引用对象而移动构造德尔形参是右值引用，可以修改引用对象。下面是《深入理解c++11》中对拷贝构造和移动构造的对比图，（ps：根据图的拷贝构造，可以看出...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/yangxuan0261">来自： <span class="blog_title"> 醉无言</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/Jxianxu/article/details/62046839,BlogCommendFromQuerySearch_19"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/Jxianxu/article/details/62046839,BlogCommendFromQuerySearch_19"}">
<div class="content">
<a href="https://blog.csdn.net/Jxianxu/article/details/62046839" target="_blank" title="C++11之右值引用、完美转换（Perfect Forwarding）、std::move">
<h4 class="text-truncate oneline">
<em>C++11</em>之<em>右值</em><em>引用</em>、完美转换（Perfect Forwarding）、std::move </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">03-14</span>
<span class="read-num hover-hide">
阅读数
309</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/Jxianxu/article/details/62046839" target="_blank" title="C++11之右值引用、完美转换（Perfect Forwarding）、std::move">
<span class="desc oneline">新特性的目的右值引用(RvalueReferene)是C++新标准(C++11,11代表2011年)中引入的新特性,它实现了转移语义(MoveSementics)和精确传递(PerfectForw...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/Jxianxu">来自： <span class="blog_title"> 姜的理想国</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/Kaitiren/article/details/22302579,BlogCommendFromQuerySearch_20"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/Kaitiren/article/details/22302579,BlogCommendFromQuerySearch_20"}">
<div class="content">
<a href="https://blog.csdn.net/Kaitiren/article/details/22302579" target="_blank" title="C++11 新特性之右值引用和转移构造函数">
<h4 class="text-truncate oneline">
<em>C++11</em> 新特性之<em>右值</em><em>引用</em>和转移构造函数 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">03-27</span>
<span class="read-num hover-hide">
阅读数
6217</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/Kaitiren/article/details/22302579" target="_blank" title="C++11 新特性之右值引用和转移构造函数">
<span class="desc oneline">问题背景[cpp] viewplaincopy#include using namespace std; vectorint> doubleValues (const vectori...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/Kaitiren">来自： <span class="blog_title"> Kaitiren的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_40936780/article/details/83932472,BlogCommendFromBaidu_21"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_40936780/article/details/83932472,BlogCommendFromBaidu_21"}">
<div class="content">
<a href="https://blog.csdn.net/qq_40936780/article/details/83932472" target="_blank" title="c++ 源码中&&变量是什么意思呢？">
<h4 class="text-truncate oneline">
c++ 源码中&&变量是什么意思呢？ </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">11-10</span>
<span class="read-num hover-hide">
阅读数
60</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_40936780/article/details/83932472" target="_blank" title="c++ 源码中&&变量是什么意思呢？">
<span class="desc oneline">很多刚学习的c++的朋友可能都对这个&amp;amp;&amp;amp;的含义有点疑惑这里的&amp;amp;&amp;amp;不是逻辑符号而是二级指针可以理解为引用的引用。...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_40936780">来自： <span class="blog_title"> qq_40936780的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/kitekitebaby/article/details/72566145,BlogCommendFromBaidu_22"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/kitekitebaby/article/details/72566145,BlogCommendFromBaidu_22"}">
<div class="content">
<a href="https://blog.csdn.net/kitekitebaby/article/details/72566145" target="_blank" title="C++中的 & 与 &&">
<h4 class="text-truncate oneline">
C++中的 & 与 && </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">05-19</span>
<span class="read-num hover-hide">
阅读数
447</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/kitekitebaby/article/details/72566145" target="_blank" title="C++中的 & 与 &&">
<span class="desc oneline">右值引用(RvalueReferene)是C++新标准(C++11,11代表2011年)中引入的新特性,它实现了转移语义(MoveSementics)和精确传递(PerfectForwarding)。...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/kitekitebaby">来自： <span class="blog_title"> 雨林轩志</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_63" data-pid="63" data-track-view="{"mod":"kp_popu_63-555","con":",,"}" data-track-click="{"mod":"kp_popu_63-555","con":",,"}"><div id="three_ad23" class="mediav_ad"></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_31360933/article/details/79698177,BlogCommendFromBaidu_23"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_31360933/article/details/79698177,BlogCommendFromBaidu_23"}">
<div class="content">
<a href="https://blog.csdn.net/qq_31360933/article/details/79698177" target="_blank" title="C&&C++&&VB&&java">
<h4 class="text-truncate oneline">
C&&C++&&VB&&java </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">03-26</span>
<span class="read-num hover-hide">
阅读数
376</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_31360933/article/details/79698177" target="_blank" title="C&&C++&&VB&&java">
<span class="desc oneline">研究问题：学的越多越容易打岔，这时候有必要对比一下细微差别!以下是C/C++/visualbasic/java等语法差别！！要点：C/C++／java语言严格区分大小写，VB不区分大小写C语言中没有特...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_31360933">来自： <span class="blog_title"> SunshineBoy的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/aeolus_pu/article/details/66473325,BlogCommendFromBaidu_24"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/aeolus_pu/article/details/66473325,BlogCommendFromBaidu_24"}">
<div class="content">
<a href="https://blog.csdn.net/aeolus_pu/article/details/66473325" target="_blank" title="c/c++中&& ||的区别">
<h4 class="text-truncate oneline">
c/c++中&& ||的区别 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">03-26</span>
<span class="read-num hover-hide">
阅读数
648</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/aeolus_pu/article/details/66473325" target="_blank" title="c/c++中&& ||的区别">
<span class="desc oneline">逻辑运算&&：逻辑与，前后条件同时满足表达式为真||：逻辑或，前后条件只要有一个满足表达式为真位运算 &：按位与|：按位或假如a=0xaa,b=0x55a&&b=true,在计算机中true以非0值表...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/aeolus_pu">来自： <span class="blog_title"> aeoluspu的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_35781950/article/details/73381408,BlogCommendFromBaidu_25"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_35781950/article/details/73381408,BlogCommendFromBaidu_25"}">
<div class="content">
<a href="https://blog.csdn.net/qq_35781950/article/details/73381408" target="_blank" title="C++中运算符 &和&&、|和|| 的区别">
<h4 class="text-truncate oneline">
C++中运算符 &和&&、|和|| 的区别 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">06-17</span>
<span class="read-num hover-hide">
阅读数
517</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_35781950/article/details/73381408" target="_blank" title="C++中运算符 &和&&、|和|| 的区别">
<span class="desc oneline">简介：&&是逻辑与运算符，||是逻辑或运算符，都是逻辑运算符，两边只能是bool类型&与|既可以进行逻辑运算，又可以进行位运算，两边既可以是bool类型，又可以是数值类型区别：if(A&&B)如果A为...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_35781950">来自： <span class="blog_title"> 天与云与山与水，上下一白</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/j597960549/article/details/79525857,BlogCommendFromBaidu_26"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/j597960549/article/details/79525857,BlogCommendFromBaidu_26"}">
<div class="content">
<a href="https://blog.csdn.net/j597960549/article/details/79525857" target="_blank" title="【强文翻译】c++右值引用详解">
<h4 class="text-truncate oneline">
【强文翻译】c++<em>右值</em><em>引用</em>详解 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">03-12</span>
<span class="read-num hover-hide">
阅读数
119</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/j597960549/article/details/79525857" target="_blank" title="【强文翻译】c++右值引用详解">
<span class="desc oneline">原文链接译注：这篇是我读过有关右值引用的文章中最通俗易懂的一篇，易懂的同时，其内容也非常全面，所以就翻译了一下以便加深理解。有翻译不准的地方请留言指出。INTRODUCTION右值引用是C++11标准...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/j597960549">来自： <span class="blog_title"> 90岁IT小生</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/u010229420/article/details/52933787,BlogCommendFromBaidu_27"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/u010229420/article/details/52933787,BlogCommendFromBaidu_27"}">
<div class="content">
<a href="https://blog.csdn.net/u010229420/article/details/52933787" target="_blank" title="c++ || ＆＆ 逻辑短路问题">
<h4 class="text-truncate oneline">
c++ || ＆＆ 逻辑短路问题 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">10-26</span>
<span class="read-num hover-hide">
阅读数
4583</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/u010229420/article/details/52933787" target="_blank" title="c++ || ＆＆ 逻辑短路问题">
<span class="desc oneline">结论：“或”逻辑前面为1，“与”逻辑前面为0就会发生短路1——或逻辑短路includeintmain(){inta=5,b=6,c=7,d=8,m=2,n=2;(m=ad);printf("%d %...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/u010229420">来自： <span class="blog_title"> 轻锋的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_64" data-pid="64" data-track-view="{"mod":"kp_popu_64-81","con":",,"}" data-track-click="{"mod":"kp_popu_64-81","con":",,"}"><div id="three_ad28" class="mediav_ad"></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/rekrad/article/details/52412493,BlogCommendFromBaidu_28"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/rekrad/article/details/52412493,BlogCommendFromBaidu_28"}">
<div class="content">
<a href="https://blog.csdn.net/rekrad/article/details/52412493" target="_blank" title="C++可变模板参数中&&和&的使用">
<h4 class="text-truncate oneline">
C++可变模板参数中&&和&的使用 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-02</span>
<span class="read-num hover-hide">
阅读数
2031</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/rekrad/article/details/52412493" target="_blank" title="C++可变模板参数中&&和&的使用">
<span class="desc oneline">templatevoidtbLog(T&t){ cout</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/rekrad">来自： <span class="blog_title"> rekrad的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/fengbingchun/article/details/52562004,BlogCommendFromBaidu_29"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/fengbingchun/article/details/52562004,BlogCommendFromBaidu_29"}">
<div class="content">
<a href="https://blog.csdn.net/fengbingchun/article/details/52562004" target="_blank" title="C++11中rvalue references的使用">
<h4 class="text-truncate oneline">
<em>C++11</em>中rvalue references的使用 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-17</span>
<span class="read-num hover-hide">
阅读数
1850</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/fengbingchun/article/details/52562004" target="_blank" title="C++11中rvalue references的使用">
<span class="desc oneline">C++11中rvaluereferences的使用</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/fengbingchun">来自： <span class="blog_title"> 网络资源是无限的</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/ShWe_yayaya/article/details/81874509,BlogCommendFromQuerySearch_30"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/ShWe_yayaya/article/details/81874509,BlogCommendFromQuerySearch_30"}">
<div class="content">
<a href="https://blog.csdn.net/ShWe_yayaya/article/details/81874509" target="_blank" title="C++11新特性---右值引用&类型推导（一）">
<h4 class="text-truncate oneline">
<em>C++11</em>新特性---<em>右值</em><em>引用</em>&类型推导（一） </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">08-20</span>
<span class="read-num hover-hide">
阅读数
55</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/ShWe_yayaya/article/details/81874509" target="_blank" title="C++11新特性---右值引用&类型推导（一）">
<span class="desc oneline">本篇文章摘自博客：https://blog.csdn.net/hzyong_c/article/details/8273884一、右值引用，move语义1、左值(lvalue)和右值(rvalue)的...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/ShWe_yayaya">来自： <span class="blog_title"> ShWe的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/jiange_zh/article/details/50574455,BlogCommendFromQuerySearch_31"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/jiange_zh/article/details/50574455,BlogCommendFromQuerySearch_31"}">
<div class="content">
<a href="https://blog.csdn.net/jiange_zh/article/details/50574455" target="_blank" title="C++11 浅谈 右值引用和move语义">
<h4 class="text-truncate oneline">
<em>C++11</em> 浅谈 <em>右值</em><em>引用</em>和move语义 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">01-24</span>
<span class="read-num hover-hide">
阅读数
1384</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/jiange_zh/article/details/50574455" target="_blank" title="C++11 浅谈 右值引用和move语义">
<span class="desc oneline">一、左值和右值lvalue：具有存储性质的对象，要实际占用内存空间、内存地址；位于赋值运算符左边时可以赋值（同时也可以用在右边）。rvalue：没有存储性质的对象，也就是临时对象。位于赋值运算符左边时...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/jiange_zh">来自： <span class="blog_title"> jiange_zh的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/liqinghua1653/article/details/12280851,BlogCommendFromQuerySearch_32"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/liqinghua1653/article/details/12280851,BlogCommendFromQuerySearch_32"}">
<div class="content">
<a href="https://blog.csdn.net/liqinghua1653/article/details/12280851" target="_blank" title="深入浅出C++11（3） -- 右值引用和move语义">
<h4 class="text-truncate oneline">
深入浅出<em>C++11</em>（3） -- <em>右值</em><em>引用</em>和move语义 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">10-04</span>
<span class="read-num hover-hide">
阅读数
7722</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/liqinghua1653/article/details/12280851" target="_blank" title="深入浅出C++11（3） -- 右值引用和move语义">
<span class="desc oneline">右值引用什么是lvalue，什么是rvalue？lvalue：具有存储性质的对象，即lvalue对象，是指要实际占用内存空间、有内存地址的那些实体对象，例如：变量(variables)、函数、函数指针...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/liqinghua1653">来自： <span class="blog_title"> liqinghua1653的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_65" data-pid="65" data-track-view="{"mod":"kp_popu_65-84","con":",,"}" data-track-click="{"mod":"kp_popu_65-84","con":",,"}"><div id="three_ad33" class="mediav_ad"></div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/u012814856/article/details/83410552,BlogCommendFromQuerySearch_33"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/u012814856/article/details/83410552,BlogCommendFromQuerySearch_33"}">
<div class="content">
<a href="https://blog.csdn.net/u012814856/article/details/83410552" target="_blank" title="细谈 C++ 传参的四种方式：按值传参、按左值引用传参、按常量引用传参以及按右值引用传参">
<h4 class="text-truncate oneline">
细谈 C++ 传参的四种方式：按值传参、按左值<em>引用</em>传参、按常量<em>引用</em>传参以及按<em>右值</em><em>引用</em>传参 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">10-26</span>
<span class="read-num hover-hide">
阅读数
222</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/u012814856/article/details/83410552" target="_blank" title="细谈 C++ 传参的四种方式：按值传参、按左值引用传参、按常量引用传参以及按右值引用传参">
<span class="desc oneline">一、引言一直以来，我对于C++的传参方式只有皮毛上的了解而没有深入其里的探讨。正好，最近在学习《DataStucturesAndAlgorithmsAnalysisInCpp4thEdition》这本...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/u012814856">来自： <span class="blog_title"> (ÒωÓױ)</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/victorydh123/article/details/73603830,BlogCommendFromQuerySearch_34"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/victorydh123/article/details/73603830,BlogCommendFromQuerySearch_34"}">
<div class="content">
<a href="https://blog.csdn.net/victorydh123/article/details/73603830" target="_blank" title="C++11中的universal引用和右值引用">
<h4 class="text-truncate oneline">
<em>C++11</em>中的universal<em>引用</em>和<em>右值</em><em>引用</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">06-22</span>
<span class="read-num hover-hide">
阅读数
613</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/victorydh123/article/details/73603830" target="_blank" title="C++11中的universal引用和右值引用">
<span class="desc oneline">stackoverflow上有个问题：Why“universalreferences”havethesamesyntaxasrvaluereferences?就是说为什么这俩的形式都是T&&（T表示一...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/victorydh123">来自： <span class="blog_title"> victorydh123的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/xxpresent/article/details/52649902,BlogCommendFromBaidu_35"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/xxpresent/article/details/52649902,BlogCommendFromBaidu_35"}">
<div class="content">
<a href="https://blog.csdn.net/xxpresent/article/details/52649902" target="_blank" title="c++之指针&&引用">
<h4 class="text-truncate oneline">
c++之指针&&<em>引用</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-24</span>
<span class="read-num hover-hide">
阅读数
4698</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/xxpresent/article/details/52649902" target="_blank" title="c++之指针&&引用">
<span class="desc oneline">引用</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/xxpresent">来自： <span class="blog_title"> xxpresent的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_16540387/article/details/78843936,BlogCommendFromBaidu_36"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_16540387/article/details/78843936,BlogCommendFromBaidu_36"}">
<div class="content">
<a href="https://blog.csdn.net/qq_16540387/article/details/78843936" target="_blank" title="c++中运算符&，&&，|，||的区别">
<h4 class="text-truncate oneline">
c++中运算符&，&&，|，||的区别 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">12-19</span>
<span class="read-num hover-hide">
阅读数
1486</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_16540387/article/details/78843936" target="_blank" title="c++中运算符&，&&，|，||的区别">
<span class="desc oneline">简介：&&是逻辑与运算符，||是逻辑或运算符，都是逻辑运算符，两边只能是bool类型&与|既可以进行逻辑运算，又可以进行位运算，两边既可以是bool类型，又可以是数值类型&|为整型和bool类型预定义...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_16540387">来自： <span class="blog_title"> qq_16540387的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/Sad_Sugar/article/details/50569203,BlogCommendFromBaidu_37"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/Sad_Sugar/article/details/50569203,BlogCommendFromBaidu_37"}">
<div class="content">
<a href="https://blog.csdn.net/Sad_Sugar/article/details/50569203" target="_blank" title="C++中的右值引用"&&"">
<h4 class="text-truncate oneline">
C++中的<em>右值</em><em>引用</em>"&&" </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">01-23</span>
<span class="read-num hover-hide">
阅读数
2352</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/Sad_Sugar/article/details/50569203" target="_blank" title="C++中的右值引用"&&"">
<span class="desc oneline">C++的右值引用</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/Sad_Sugar">来自： <span class="blog_title"> Sad_Sugar的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_66" data-pid="66" data-track-view="{"mod":"kp_popu_66-881","con":",,"}" data-track-click="{"mod":"kp_popu_66-881","con":",,"}"><script src="https://nbrecsys.4paradigm.com/resource/cus/csdn/sdk-csdn-render.js"></script>
<div class="recommend-item-box recommend-box-ident recommend-other-item-box" data-track-view="{"mod":"popu_614","con":",https://bbs.csdn.net/topics/20420760,BlogCommendFromBaidu_38"}" data-track-click="{"mod":"popu_614","con":",https://bbs.csdn.net/topics/20420760,BlogCommendFromBaidu_38"}">
<a href="https://bbs.csdn.net/topics/20420760" target="_blank">
<h4 class="text-truncate oneline">
请问:c++中&和&&有什么区别? </h4>
<div class="info-box d-flex align-content-center">
<span class="date">03-09</span>
</div>
<p class="content oneline">
<span class="desc oneline">如题.谢谢!</span>
<span class="type-show type-show-bbs">论坛</span>
</p>
</a>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/chiliaolm/article/details/52916179,BlogCommendFromBaidu_39"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/chiliaolm/article/details/52916179,BlogCommendFromBaidu_39"}">
<div class="content">
<a href="https://blog.csdn.net/chiliaolm/article/details/52916179" target="_blank" title="在c/c++中的&、|和&&、||的区别（易混淆）">
<h4 class="text-truncate oneline">
在c/c++中的&、|和&&、||的区别（易混淆） </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">10-24</span>
<span class="read-num hover-hide">
阅读数
9409</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/chiliaolm/article/details/52916179" target="_blank" title="在c/c++中的&、|和&&、||的区别（易混淆）">
<span class="desc oneline">在c/c++中的&和|是位运算符，和它们处于相同地位的还有>、^、~。这两个运算符会使得参与运算的参数的每一位都进行运算。例如10和6相与，即1010&0110,得0010，也就是2.但是&&和||却...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/chiliaolm">来自： <span class="blog_title"> chiliaolm的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/StephenZou14/article/details/77817114,BlogCommendFromBaidu_40"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/StephenZou14/article/details/77817114,BlogCommendFromBaidu_40"}">
<div class="content">
<a href="https://blog.csdn.net/StephenZou14/article/details/77817114" target="_blank" title="C++11之左值、纯右值和将亡值">
<h4 class="text-truncate oneline">
<em>C++11</em>之左值、纯<em>右值</em>和将亡值 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">09-03</span>
<span class="read-num hover-hide">
阅读数
1406</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/StephenZou14/article/details/77817114" target="_blank" title="C++11之左值、纯右值和将亡值">
<span class="desc oneline">在C++11中所有的值一定属于左值、纯右值和将亡值三种值之一，分别介绍一下这三种类型。左值与右值在C++中定义左值与右值的比较标准的方法是根据其可以取地址来判断。左值就是可以对变量进行取地址或者有名字...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/StephenZou14">来自： <span class="blog_title"> StephenZou14的博客</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/wgmkss/article/details/6123350,BlogCommendFromBaidu_41"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/wgmkss/article/details/6123350,BlogCommendFromBaidu_41"}">
<div class="content">
<a href="https://blog.csdn.net/wgmkss/article/details/6123350" target="_blank" title="C++右值引用">
<h4 class="text-truncate oneline">
C++<em>右值</em><em>引用</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">01-07</span>
<span class="read-num hover-hide">
阅读数
1038</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/wgmkss/article/details/6123350" target="_blank" title="C++右值引用">
<span class="desc oneline">C++0x来了，你准备好了吗？(四)右值引用右值引用 作为最重要的一项语言特性，右值引用(rvaluereferences)被引入到C++0x中。我们可以通过操作符“&&”来声明一个右值引用，原先在C...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/wgmkss">来自： <span class="blog_title"> wgmkss的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/infoworld/article/details/50737502,BlogCommendFromBaidu_42"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/infoworld/article/details/50737502,BlogCommendFromBaidu_42"}">
<div class="content">
<a href="https://blog.csdn.net/infoworld/article/details/50737502" target="_blank" title="[C++11]_[初级]_[左值引用声明和右值引用声明]">
<h4 class="text-truncate oneline">
[<em>C++11</em>]_[初级]_[左值<em>引用</em>声明和<em>右值</em><em>引用</em>声明] </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">02-25</span>
<span class="read-num hover-hide">
阅读数
2018</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/infoworld/article/details/50737502" target="_blank" title="[C++11]_[初级]_[左值引用声明和右值引用声明]">
<span class="desc oneline">场景:在remove_reference结构体中能看到右值引用的身影&&,那么这里的右值引用到底有什么用呢?经常也发现int&和int&&这两种类似的应用类型,第一种是左值引用声明,第二种是右值引用声...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/infoworld">来自： <span class="blog_title"> 心如止水</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_67" data-pid="67" data-track-view="{"mod":"kp_popu_67-882","con":",,"}" data-track-click="{"mod":"kp_popu_67-882","con":",,"}"><script src="https://nbrecsys.4paradigm.com/resource/cus/csdn/sdk-csdn-render.js"></script>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/KangRoger/article/details/40072379,BlogCommendFromBaidu_43"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/KangRoger/article/details/40072379,BlogCommendFromBaidu_43"}">
<div class="content">
<a href="https://blog.csdn.net/KangRoger/article/details/40072379" target="_blank" title="C++中的左值和右值">
<h4 class="text-truncate oneline">
C++中的左值和<em>右值</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">10-14</span>
<span class="read-num hover-hide">
阅读数
1万+</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/KangRoger/article/details/40072379" target="_blank" title="C++中的左值和右值">
<span class="desc oneline">左值和右值的区别，以及C++11中对左值符号&和右值符号&&、std::move。</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/KangRoger">来自： <span class="blog_title"> KangRoger的专栏</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/pizi0475/article/details/6278478,BlogCommendFromBaidu_44"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/pizi0475/article/details/6278478,BlogCommendFromBaidu_44"}">
<div class="content">
<a href="https://blog.csdn.net/pizi0475/article/details/6278478" target="_blank" title="C/C++的左值和右值">
<h4 class="text-truncate oneline">
C/C++的左值和<em>右值</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">03-25</span>
<span class="read-num hover-hide">
阅读数
826</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/pizi0475/article/details/6278478" target="_blank" title="C/C++的左值和右值">
<span class="desc oneline">0 左值性(lvalueness)在C/C++中是表达式的一个重要属性。只有通过一个左值表达式才能来引用及更改一个对象(object)的值。（某些情况下，右值表达式也能引用(refer)到某一个对象...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/pizi0475">来自： <span class="blog_title"> 痞子龙3D编程</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_30272539/article/details/81390900,BlogCommendFromQuerySearch_45"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_30272539/article/details/81390900,BlogCommendFromQuerySearch_45"}">
<div class="content">
<a href="https://blog.csdn.net/qq_30272539/article/details/81390900" target="_blank" title="7.2、函数返回值为引用左值和右值问题">
<h4 class="text-truncate oneline">
7.2、函数返回值为<em>引用</em>左值和<em>右值</em>问题 </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">08-03</span>
<span class="read-num hover-hide">
阅读数
270</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_30272539/article/details/81390900" target="_blank" title="7.2、函数返回值为引用左值和右值问题">
<span class="desc oneline">#include&amp;lt;iostream&amp;gt;usingnamespacestd;/***@briefp*@return*函数返回值为引用：1、当函数的返回值的是一个局部变量引用的时...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/qq_30272539">来自： <span class="blog_title"> 沿海奔跑的少年</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/qq_35611903/article/details/74980517,BlogCommendFromQuerySearch_46"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/qq_35611903/article/details/74980517,BlogCommendFromQuerySearch_46"}">
<div class="content">
<a href="https://blog.csdn.net/qq_35611903/article/details/74980517" target="_blank" title="C++11中，＆表示左值引用,＆＆表示右值引用">
<h4 class="text-truncate oneline">
<em>C++11</em>中，＆表示左值<em>引用</em>,＆＆表示<em>右值</em><em>引用</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">07-11</span>
<span class="read-num hover-hide">
阅读数
216</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/qq_35611903/article/details/74980517" target="_blank" title="C++11中，＆表示左值引用,＆＆表示右值引用">
<span class="desc oneline">左值和右值都是针对表达式而言的，左值是指表达式结束后依然存在的持久对象，右值指表达式结束时就不再存在的临时对象——显然右值不可以被取地址...</span>
</a>
<span class="blog_title_box oneline no-title">
<span class="type-show type-show-blog type-show-after">博文</span>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-box-ident type_blog clearfix" data-track-view="{"mod":"popu_614","con":",https://blog.csdn.net/craftsman1970/article/details/82152704,BlogCommendFromQuerySearch_47"}" data-track-click="{"mod":"popu_614","con":",https://blog.csdn.net/craftsman1970/article/details/82152704,BlogCommendFromQuerySearch_47"}">
<div class="content">
<a href="https://blog.csdn.net/craftsman1970/article/details/82152704" target="_blank" title="C++11新特性（66）- 用static_cast将左值转换为右值">
<h4 class="text-truncate oneline">
<em>C++11</em>新特性（66）- 用static_cast将左值转换为<em>右值</em> </h4>
<div class="info-box d-flex align-content-center">
<p class="date-and-readNum oneline">
<span class="date hover-show">08-28</span>
<span class="read-num hover-hide">
阅读数
210</span>
</p>
</div>
</a>
<p class="content">
<a href="https://blog.csdn.net/craftsman1970/article/details/82152704" target="_blank" title="C++11新特性（66）- 用static_cast将左值转换为右值">
<span class="desc oneline">温故而知新本文涉及两个概念，static_cast和右值引用，在阅读本文之前，最好先阅读下面的文章。C++显式转换(1)-static_castC++11新特性（23）-右值引用C++11新特性（24...</span>
</a>
<span class="blog_title_box oneline ">
<span class="type-show type-show-blog type-show-after">博文</span>
<a target="_blank" href="https://blog.csdn.net/craftsman1970">来自： <span class="blog_title"> 面向对象思考</span></a>
</span>
</p>
</div>
</div>
<div class="recommend-item-box recommend-ad-box"><div id="kp_box_68" data-pid="68" data-track-view="{"mod":"kp_popu_68-883","con":",,"}" data-track-click="{"mod":"kp_popu_68-883","con":",,"}"><!-- T48 位置 -->