前言
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。
从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一 一讲解，本篇博客我们主要介绍一些常用语法。
一、统一的列表初始化
1.1 { } 初始化
在C++98中，标准允许使用花括号{ }对数组或者结构体元素进行统一的列表初始值设定，C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加
struct Point
{
int _x;
int _y;
};
int main()
{
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
int a = { 0 };
return 0;
}
1.2 std::initializer_list
我们可以看出std::initializer_list也是一个模板类
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值
#include<vector>
#include<list>
int main()
{
vector<int> v = { 0,1,2,3 };
list<int> l = { 0,1,2,3 };
return 0;
}
二、变量类型的自动推导——decltype
关键字decltype将变量的类型声明为表达式指定的类型
int main()
{
int a = 1;
decltype(a) v1;
double x = 9;
decltype(x * x) ret = x * x;
return 0;
}
三、STL中的新变化
3.1 新容器
3.2 容器中的新方法
如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。
实际上C++11更新后，容器中增加的新方法最后用的插入接口函数的右值引用版本
下图是vector的操作新增：
四、右值引用与移动语义
4.1 左值引用与右值引用
4.1.1 左值引用与右值引用的概念
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名
什么是左值？什么是左值引用？
左值是一个表示数据的表达式，我们可以获取它的地址，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。左值引用就是给左值的引用，给左值取别名什么是右值？什么是右值引用？
右值也是一个表示数据的表达式，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名
左值引用能引用右值吗？右值引用能引用左值吗？
在C++11之前出来之前我们就可以通过const左值引用来引用右值，C++11出来之后右值引用左值只需要move一下左值即可
4.1.2 左值引用与右值引用的比较
左值引用只能引用左值，不能引用右值。但是const左值引用既可引用左值，也可引用右值。
右值引用只能右值，不能引用左值。但是右值引用可以move以后的左值。
4.1.3 左值引用与右值引用的实例
void test1()
{
//左值
int a = 0;
int* b = new int{ 0 };
const int c = 1;
//右值
10;
a + 1;
min(a, 1);
//左值引用左值
int& ra = a;
int*& rb = b;
const int& rc = c;
//右值引用右值
const int&& rr1 = 10;
int&& rr2 = a + 1;
auto&& rr3 = min(a, 1);
//左值引用右值 const 左值引用 可以引用右值
const int& lr1 = 10;
const int& lr2 = a+1;
const int& lr3 = min(a,1);
//右值引用左值 move一下左值
int&& r1 = move(a);
int*&& r2 = move(b);
const int&& r3 = move(c);
}
4.2 左值引用和右值引用的使用场景
4.2.1 左值引用的使用场景
引用的应用无非传参和传返回值，左值引用完美的解决了引用传参的问题，但是对于传返回值的问题没有完全解决。
caryon::string to_string(int value)
{
caryon::string str;
//……
return str;
}
void test2()
{
caryon::string ret2 = to_string(-1111);
}
我们知道to_string()的返回值是一个右值，用这个右值构造ret2，现在的调用就会匹配拷贝构造，因为const左值引用可以引用一个右值，这里就会产生深拷贝
4.3.2 右值引用及移动语义解决上述问题
在caryon::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占为已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己
//移动构造
string(string&& str)
{
cout << "string(string&& str)" << endl;
swap(str);
}
//移动赋值
string& operator=(string&& str)
{
cout << "string& operator=(string&& str)" << endl;
swap(str);
return *this;
}
再运行上面caryon::to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了
对于移动赋值也是处于这方面的考虑……
在STL中的容器都是新增了移动构造和移动赋值。
4.3 模板中的万能引用与完美转发
4.3.1 模板中的万能引用
有些情况下我们的左值和右值会调用同一个函数，此时我们无法区分出是左值还是右值调用，这是就有了模板中的万能引用
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<typename T>
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;
}
当我们运行该程序时却发现，打印出的内容显示调用的均是左值引用，为什么右值没有正确的调到右值引用的函数呢？
这是因为C++规定引用右值的值是左值，也就是程序中的t始终是左值，我们如何让左值向下传递时依然是左值，右值依然是右值呢？这就是接下来的内容——完美转发
4.3.2 完美转发
std::forward 完美转发在传参的过程中保留对象原生类型属性
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; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
template<typename T>
void PerfectForward(T&& t)
{
Fun(forward<T>(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;
}
五、新的类功能
5.1 类的默认成员函数
原来C++类中，有6个默认成员函数，C++11 新增了两个：移动构造函数和移动赋值运算符重载
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
- 如果没有自己实现移动构造函数(移动赋值重载函数)，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造(移动赋值重载)。默认生成的移动构造函数(移动赋值重载)，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造(移动赋值)，如果实现了就调用移动构造(移动赋值)，没有实现就调用拷贝构造(拷贝赋值)。
- 如果自己实现了移动构造(移动赋值)，编译器不会自动提供拷贝构造(拷贝赋值)。
5.2 类成员变量的初始化
C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。
5.3 新的类的关键字
- 强制生成默认函数的关键字default
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。 - 禁止生成默认函数的关键字delete
如果想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明不定义，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
六、可变参数模板
C++11的新特性可变参数模板能够创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。
下面就是一个基本可变参数的函数模板:
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template<class ...Args>
void show(Args... args)
{}
上面的参数Args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。
- 递归函数方式展开参数包
void Print()
{
cout << endl;
}
template<class T, class ...Args>
void Print(T t, Args... args)
{
cout << t << " ";
Print(args...);
}
template<class ...Args>
void show(Args... args)
{
Print(args...);
}
int main()
{
show(1);
show(1,2.2);
show(1,2.2,"cccccc");
return 0;
}
- 逗号表达式展开参数包
template <class T>
void PrintArg(T t)
{
cout << t << " ";
}
//展开函数
template <class ...Args>
void show(Args... args)
{
int arr[] = { (PrintArg(args), 0)... };
cout << endl;
}
int main()
{
show(1);
show(1,2.2);
show(1,2.2,"cccccc");
return 0;
}
库函数中的emplace_back() 就是利用的这种方式
template <class... Args>
void emplace_back (Args&&... args);
七、lambda表达式
7.1 引子
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法,如果待排序元素为自定义类型，需要用户定义排序时的比较规则：
struct Goods
{
string _name; //名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
return 0;
}
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式
7.2 lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
了解语法后我们就可以对上述代码进行改写：
struct Goods
{
string _name; //名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
//价格升序
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
});
//价格降序
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
});
return 0;
}
接下来我们介绍一下lambda表达式的各个部分：
- [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用- [var]：表示值传递方式捕捉变量var
- [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
- [&var]：表示引用传递捕捉变量var
- [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
- [this]：表示值传递方式捕捉当前的this指针
注意：
- 父作用域指包含lambda函数的语句块
- 语法上捕捉列表可由多个捕捉项组成，并以逗号分割
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量；[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量 - 捕捉列表不允许变量重复传递，否则就会导致编译错误
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复 - 在块作用域以外的lambda函数捕捉列表必须为空
- 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错
- lambda表达式之间不能相互赋值，即使看起来类型相同
- (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
- mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)
- ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导
- {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量
注意
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[] {};
// 省略参数列表和返回值类型，返回值类型由编译器推导为int
int a = 3, b = 4;
[=] {return a + 3; };
// 省略了返回值类型，无返回值类型
auto fun1 = [&](int c) {b = a + c; };
fun1(10);
cout << a << " " << b << endl;
// 各部分都很完善的lambda函数
auto fun2 = [=, &b](int c)->int {return b += a + c; };
cout << fun2(10) << endl;
// 复制捕捉x
int x = 10;
auto add_x = [x](int a) mutable { x *= 2; return a + x; };
cout << add_x(10) << endl;
return 0;
}
7.3 函数对象与lambda表达式
class Rate
{
public:
Rate(double rate) : _rate(rate)
{}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
int main()
{
// 函数对象
double rate = 0.015;
Rate r1(rate);
cout << r1(10000, 2) << endl;
// lamber
auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
cout << r2(10000, 2) << endl;
return 0;
}
从使用方式上来看，函数对象与lambda表达式完全一样。
函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()
八、包装器
头文件<functional>
8.1 function
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
使用方式：
void test4()
{
function<int(int, int)> func1 = [](int a, int b){return a + b; };
cout << func1(1, 1);
}
有了包装器我们就可以对函数或lambda表达式进行封装
8.2 bind
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。
调用bind的一般形式：auto newCallable = bind(callable,arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。
_1,_2等都被封在placeholders这个命名空间
#include<functional>
using namespace placeholders;
int main()
{
function<int(int, int)> func = [](int a, int b){return a - b; };
//普通绑定
auto fun1 = bind(func, _1, _2);
cout<<fun1(1, 10)<<endl;
//绑定参数顺序
auto fun2 = bind(func, _2, _1);
cout << fun2(100, 9) << endl;
//绑定参数个数
auto fun3 = bind(func, 100, _1);
cout << fun3(90) << endl;
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
