C++11黑科技(右值引用 + lambda表达式 + function包装器)
目录
一、右值引用
1.1左值和右值的概念
1.2 右值引用符号以及常见的右值
1.3 左值引用与右值引用比较
1.4 右值引用的场景与意义
1.4.1 左值引用的短板
1.4.2 右值引用补缺左值拷贝构造
1.4.3 移动赋值
1.5 完美转发(模板中的&& 万能引用)
二、lambda表达式
2.1 lambda表达式参数
2.2 lambda表达式原理
三、function包装器
3.1 包装器定义
3.2 包装器优点
一、右值引用
C++11中引入了右值引用语法特性，无论左值引用还是右值引用，本质都是给对象取别名！
1.1左值和右值的概念
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
1.2 右值引用符号以及常见的右值
&&为右值引用符号！
字面常量、表达式返回值，函数返回值 为常用的右值
int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;
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;
}1.3 左值引用与右值引用比较
左值引用总结：
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值
int main()
{
// 左值引用只能引用左值，不能引用右值。
int a = 10;
int& ra1 = a; // ra为a的别名
//int& ra2 = 10; // 编译失败，因为10是右值
// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
return 0;
}右值引用总结：
1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。这里的move理解为变化了a的性质(左值->右值)
int main()
{
// 右值引用只能右值，不能引用左值。
int&& r1 = 10;
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
int&& r2 = a;/
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}1.4 右值引用的场景与意义
1.4.1 左值引用的短板
左值引用的使用场景：
做参数和做返回值都可以提高效率,但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。（详细原因在我的另一篇博客：C++入门钥匙（引用+内联函数+函数重载））传值返回会导致至少1次拷贝构造！
1.4.2 右值引用补缺左值拷贝构造
测试右值引用代码(保留核心部分了！)：
通过显示器打印的结果我们来判断调用的构造函数！
namespace wyz
{
class string
{
public:
//...
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
//cout << "string(char* str)" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// s1.swap(s2)
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 深拷贝" << endl;
string tmp(s._str);
swap(tmp);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动语义" << endl;
swap(s);
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
}
//...
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
wyz::string to_string(int value)
{
//...
wyz::string str;
//...
return str;
}
}
int main()
{
//移动构造
wyz::string ret = wyz::to_string(-1234);
return 0;
}
1.当没有实现右值引用的时候：
2.当存在右值引用时:
现在我们来看一下右值引用相比于拷贝一次的优势在哪:
移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己！上面情况下return str命令后,我们的ret相当于窃取了右值str的数据而没有进行拷贝!这样也就没有拷贝构造，没有消耗拷贝时间！窃取的同时，str就不在拥有原先的数据了！
1.4.3 移动赋值
//移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}//移动赋值场景
wyz::string ret;
ret = wyz::to_string(-1234);
1.5 完美转发(模板中的&& 万能引用)
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template
void PerfectForward(T&& t)
{
Fun(t);
}
int main()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
} 
虽然这里&&模板参数都接受了左右值，但是二次传参的时候，统一将他们作为左值传参！
std::forward 完美转发在传参的过程中保留对象原生类型属性
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// std::forward(t)在传参的过程中保持了t的原生类型属性。
template
void PerfectForward(T&& t)
{
Fun(std::forward(t));
}
int main()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
} 
二、lambda表达式
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。
如果待排序元素为自定义类型，需要用户定义排序时的比较规则，这样我们需要每次根据需要定义一个仿函数类，这样写过于复杂。所以后面诞生出lambda表达式。
2.1 lambda表达式参数
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement
}
1. lambda表达式各部分说明
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来
判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda
函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回
值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推
导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情
class Goods
{
//...
};
int main()
{
vector v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate < g2._evaluate; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate > g2._evaluate; });
} 2. 捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针注意：
a. 父作用域指包含lambda函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
d. 在块作用域以外的lambda函数捕捉列表必须为空。
e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量都会导致编译报错。
f. lambda表达式之间不能相互赋值，即使看起来类型相同
2.2 lambda表达式原理
编译器会把一个Lambda表达式生成一个匿名类的匿名对象，并在类中重载函数调用运算符，实现了一个operator()方法。其底层本质是一个函数对象(仿函数)
auto print = []{cout << "Hello World!" << endl; };
//编译器会把上述代码翻译如下：
class print_class
{
public:
void operator()(void) const
{
cout << "Hello World!" << endl;
}
};
// 用构造的类创建对象，print此时就是一个函数对象
auto print = print_class();
三、function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器
我们来看看这样一行代码：ret = func(x);
上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！例如下面代码：
template
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
return 0;
} 
由结果可知，模板实例化了3次！下面来看看包装器
3.1 包装器定义
std::function在头文件
// 类模板原型如下
template function; // undefined
template
class function;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
//使用
#include
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
// 函数名(函数指针)
std::function func1 = f;
cout << func1(1, 2) << endl;
// 函数对象
std::function func2 = Functor();
cout << func2(1, 2) << endl;
// lamber表达式
std::function func3 = [](const int a, const int b)
{return a + b; };
cout << func3(1, 2) << endl;
// 类的静态成员函数
std::function func4 = &Plus::plusi;
cout << func4(1, 2) << endl;
//类成员函数
std::function func5 = &Plus::plusd;
cout << func5(Plus(), 1.1, 2.2) << endl;
return 0;
} 3.2 包装器优点
它可以将特征标相同的函数指针、函数对象和lambda表达式等统一定义为一类特殊的对象。
下面代码验证：
template
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
std::function func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function func3 = [](double d)->double { return d /
4; };
cout << useF(func3, 11.11) << endl;
return 0;
} 