目录
1、C++11简介
在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能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。
2. 统一的列表初始化
2.1 ｛｝初始化
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：
struct Point
{
int _x;
int _y;
};
int main()
{
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 }; // 多参数构造函数隐式类型转换
return 0;
}C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。初始化自定义类型的对象时，也会调用构造函数的函数体。
struct Point
{
int _x;
int _y;
};
int main()
{
int x1 = 1;
int x2{ 2 };
int array1[]{ 1, 2, 3, 4, 5 };
int array2[5]{ 0 };
Point p{ 1, 2 };
// C++11中列表初始化也可以适用于new表达式中
int* pa = new int[4] { 0 };
return 0;
}创建对象时也可以使用列表初始化方式调用构造函数初始化
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{
cout << "Date(int year, int month, int day)" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 1, 1); // old style
// C++11支持的列表初始化，这里会调用构造函数初始化
Date d2{ 2022, 1, 2 };
Date d3 = { 2022, 1, 3 };
return 0;
}2.2 std::initializer_list
vector<int> v = { 1,2,3,4 };为什么 vector 可以这样初始化，原因是 vector 提供了这样的构造函数：
那 initializer_list 又是什么类型呢？
int main()
{
// the type of il is an initializer_list
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
return 0;
}std::initializer_list使用场景：
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加
std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=
的参数，这样就可以用大括号赋值
int main()
{
vector<int> v = { 1,2,3,4 };
list<int> lt = { 1,2 };
// 这里{"sort", "排序"}会先初始化构造一个pair对象
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
// 使用大括号对容器赋值
v = { 10, 20, 30 };
return 0;
}{ 1,2,3,4 } 叫做常量区数组，存在常量区，在 initializer_list 这个类中有两个指针：const T* start 和 const T* end，分别指向常量区数组的首元素和最后一个元素的下一个位置。
让模拟实现的vector也支持{}初始化和赋值
namespace myvector
{
template<class T>
class vector {
public:
typedef T* iterator;
vector(initializer_list<T> l)
{
_start = new T[l.size()];
_finish = _start + l.size();
_endofstorage = _start + l.size();
iterator vit = _start;
typename initializer_list<T>::iterator lit = l.begin();
while (lit != l.end())
{
*vit++ = *lit++;
}
//for (auto e : l)
// *vit++ = e;
}
vector<T>& operator=(initializer_list<T> l) {
vector<T> tmp(l);
std::swap(_start, tmp._start);
std::swap(_finish, tmp._finish);
std::swap(_endofstorage, tmp._endofstorage);
return *this;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
}3、声明
c++11提供了多种简化声明的方式，尤其是在使用模板时。
3.1 auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局
部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将
其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初
始化值的类型。
int main()
{
int i = 10;
auto p = &i;
// ??? pf = malloc;
auto pf = malloc;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
return 0;
}3.2 decltype
上面用 typeid(pf).name() 来获取 pf 的类型，能不能用 typeid(pf).name() 来定义一个变量呢（意思就是我用 auto 获取了 malloc 的函数指针类型，能不能用这种类型再定义一个变量呢？），这种方式肯定是不行的，因为 typeid(pf).name() 返回的是字符串。如果用 auto pf1 = pf，那就必须在定义时初始化，有没有可以不初始化的方式呢？用 decltype 就可以完成：
decltype(pf) pf1;更多的使用场景：
class A
{
private:
decltype(malloc) pf2;
// ...
};class B
{
private:
Func _f;
};
int main()
{
B<decltype(malloc)> bb1;
const int x = 1;
double y = 2.2;
// decltype 还可以推导表达式的类型
B<decltype(x * y)> bb2;
return 0;
}4、右值引用和移动语义
4.1 左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性。无论左值引用还是右值引用，都是给对象取别名，都是为了解决自定义类型在某些场景下不必要的深拷贝造成效率下降的问题。注意：如果类中的数据成员都是内置类型，就不需要考虑这个问题，因为它们的深拷贝本身就很快。
什么是左值？什么是左值引用？
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址，一般可以对它赋值（非 const），左值可以出现在赋值符号的左边，右值不能出现在赋值符号左边。定义时用 const 修饰符修饰后仍然是左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
int main()
{
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}特别注意常量字符串，它在表现形式上类似右值，但它是左值，表达式返回的结果是首字符的地址。常量字符串中每个字符也都是左值，只是不能被修改。
int main
{
"xxxx";
const char* p = "xxxx";
return 0;
}const 左值引用既可引用左值，也可引用右值
int main()
{
// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
return 0;
}什么是右值？什么是右值引用？
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引
用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能
取地址。右值引用就是对右值的引用，给右值取别名。
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;
}右值引用只能右值，不能引用左值，但是可以引用 move 以后的左值
int main()
{
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
int&& r2 = a;
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}需要注意的是右值是不能取地址的，但是给右值取别名后，右值会被存储到特定位置，且可
以取到该位置的地址，也就是说例如：不能取字面量 10 的地址，但是 rr1 引用后，可以对 rr1 取地址，也可以修改 rr1。如果不想 rr1 被修改，可以用 const int&& rr1 去引用，了解一下即可，实际中右值引用的使用场景并不在于此，这个特性也不重要。
左值引用和右值引用可以构成函数重载
// 构成函数重载
void f(int& a)
{
cout << "f(int a)" << endl;
}
void f(int&& a) const
{
cout << "f(int a)" << endl;
}const 左值引用和右值引用仍可以构成函数重载，调用时编译器会选择更匹配的函数
// 仍然构成函数重载
void f(const int& a) // 可以接收左值和右值
{
cout << "f(int a)" << endl;
}
void f(int&& a) // 只能接收右值
{
cout << "f(int a)" << endl;
}
int main()
{
int a = 0;
int b = 0;
f(a); // 调用 void f(const int& a)
f(a + b); // 调用 void f(int&& a)
return 0;
}右值和左值的区别总结（注意不是右值引用和左值引用的区别）
1、区别右值和左值的关键可以是是否可以取地址：左值可以，右值不能
2、右值不能被修改，const 左值不能被修改，非 const 可以
4.2 右值引用使用场景和意义
右值引用弥补左值引用短板的场景之一：传值返回
为了更好观察不使用移动语义时，传值返回的拷贝情况，可以使用下面的简化版本 string:
namespace mystring
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
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()
{
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
//string operator+=(char ch)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
}左值引用的短板：
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，
只能传值返回。例如：string to_string(int value) 函数中可以看到，这里只能使用传值返回，
传值返回会导致至少 1 次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
如果编译器完全不优化：
右值引用和移动语义解决上述问题：
在 string 类中增加移动构造和移动赋值，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
// 移动构造
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;
}
int main()
{
mystring::string ret1 = mystring::to_string(-1234);
mystring::string ret2;
ret2 = mystring::to_string(-1234);
return 0;
}再配合编译器的优化：
1、编译器把连续的构造/拷贝构造优化为一次拷贝构造
2、编译器把 to_string 的返回值识别成右值（为了提升性能，C++要求编译器的特殊处理）
右值引用弥补左值引用短板的场景之二：构造对象
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能
真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过 move
函数将左值转化为右值。C++11中，std::move() 函数位于 utility.h 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
STL容器插入接口函数增加了右值引用版本：void push_back (value_type&& val);它的作用是：如果插入的是右值，可以利用移动拷贝直接转移该右值的资源。
int main()
{
list<bit::string> lt;
bit::string s1("1111");
// 这里调用的是拷贝构造
lt.push_back(s1);
// 下面调用都是移动构造
lt.push_back("2222");
lt.push_back(std::move(s1));
return 0;
}
4.3 完美转发
模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
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;
}
// 输出结果
// 左值引用 // 不应该是右值引用吗？
// 左值引用
// 左值引用 // 不应该是右值引用吗？
// const 左值引用
// const 左值引用 // 不应该是右值引用吗？模板的万能引用只是提供了能够同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
在学习完美转发之前，需要清楚右值和右值引用的区别：
右值不能被修改、没有地址，但是右值引用可以被修改、有地址。右值引用是左值
int&& r = 10; // 10 不能被修改、没有地址
r++; // 右值引用可以被修改
cout << &r << endl; // 右值引用有地址因为右值引用是左值，所以右值引用可以作为形参为左值的函数的实参
这就解释了为什么上面的输出结果都是左值引用或 const 左值引用
如果想在参数传递过程中保持它的左值或者右值的属性，该怎么办呢？
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; }
template<typename T>
void PerfectForward(T&& t)
{
Fun(std::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;
}
// 输出结果：
// 右值引用
// 左值引用
// 右值引用
// const 左值引用
// const 右值引用5、 lambda表达式
在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());
}随着 C++ 语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法，
都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便。因此，在 C++11 语法中出现了 Lambda 表达式。
int main()
{
vector<Goods> 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; });
}上述代码就是使用 C++11 中的 lambda 表达式来解决，可以看出 lambda 表达式实际是一个匿名函数。
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 函数不能做任何事情。
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[] {};
// 局部的匿名函数对象
auto less = [](int x, int y)->bool {return x < y; };
cout << less(1, 2) << endl;
//auto goodsPriceLess = [](const Goods& x, const Goods& y)->bool
//{return x._price < y._price; };
// 省略返回值类型
auto goodsPriceLess = [](const Goods& x, const Goods& y)
{return x._price < y._price; };
// 省略参数列表和返回值类型，返回值类型由编译器推导为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;
}通过上述例子可以看出，lambda 表达式实际上可以理解为无名函数，该函数无法直接调
用，如果想要直接调用，可借助 auto 将其赋值给一个变量。
2. 捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
- [var]：表示值传递方式捕捉变量 var，捕捉的 var 变量是父作用域 var 变量的拷贝，在函数体内部可以直接使用，但不能修改，如果要修改，要使用 mutable 修饰
- [=]：表示值传递方式捕获所有父作用域中的变量 (包括 this )
- [&var]：表示引用传递捕捉变量 var
- [&]：表示引用传递捕捉所有父作用域中的变量 ( 包括 this )
- [this]：表示值传递方式捕捉当前的 this 指针
注意：
- 父作用域指包含 lambda 函数的语句块
- 捕捉列表捕捉的变量是父作用域变量的拷贝，在函数体内部可以直接使用，但不能修改，如果要修改，要使用 mutable 修饰
- 引用传递捕捉变量不需要考虑变量是否是 const 而考虑是否用 const 引用捕捉，捕捉列表会自动识别。
- 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如：[=, &a, &b]：以引用传递的方式捕捉变量 a 和 b，值传递方式捕捉其他所有变量。[&，a, this]：值传递方式捕捉变量 a 和 this，引用方式捕捉其他变量
- 捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：= 已经以值传递方式捕捉了所有变量，捕捉 a 重复
- 在块作用域以外的 lambda 函数捕捉列表必须为空。
- 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
- lambda 表达式之间不能相互赋值，即使看起来类型相同
void (*PF)();
int main()
{
auto f1 = [] {cout << "hello world" << endl; };
auto f2 = [] {cout << "hello world" << endl; };
//f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个 lambda 表达式拷贝构造一个新的副本
auto f3(f2);
f3();
// 可以将 lambda 表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}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.49;
Rate r1(rate);
r1(10000, 2);
// lambda
auto r2 = [=](double monty, int year)->double {return monty * rate * year;
};
r2(10000, 2);
return 0;
}从使用方式上来看，函数对象与 lambda 表达式完全一样。实际在底层编译器对于 lambda 表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个 lambda 表达式，编译器会自动生成一个类，这个类的类名是：<lambda + UUID>，在该类中重载了 operator()。UUID 是为了防止类名同名的一长串字符串。这也是为什么定义 lambda 仿函数对象要用 auto，因为你在编写代码时不知道 lambda 仿函数对象具体的类名。
6、可变模板参数
对于可变参数的使用，最经典的就是 printf 函数：
int printf ( const char * format, ... );
其中的三个点 ... ，就是可变参数，它可以是一个 int 或 两个 int 或 一个 int 一个 double 等等。
C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比
C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改
进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的，我们掌握一些基础的可变参数模板特性就够我们用了。
下面就是一个基本可变参数的函数模板
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args> // Args 名字可以自定义
void ShowList(Args... args)
{
cout << sizeof...(args) << endl;// 输出参数包有多少个参数
}
int main()
{
ShowList(1);
ShowList(1,1.1);
ShowList(1,1.1,"xxxx");
}
//输出结果：
// 1
// 2
// 3上面的参数 args 前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数
包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包 args 中的每个参数，
只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特
点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用 args[i] 这样方式获取可变
参数，所以我们的用一些奇招来一一获取参数包的值。
递归函数方式展开参数包
// 递归终止函数
template <class T>
void ShowList(const T& t)
{
cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
cout << value << " ";
ShowList(args...);
}
int main()
{
ShowList(1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}STL容器中的empalce相关接口函数：
http://www.cplusplus.com/reference/vector/vector/emplace_back/
http://www.cplusplus.com/reference/list/list/emplace_back/
template <class... Args>
void emplace_back (Args&&... args)int main()
{
std::list< std::pair<int, char> > mylist;
// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
mylist.emplace_back(10, 'a');
mylist.emplace_back(20, 'b');
mylist.emplace_back(make_pair(30, 'c'));
mylist.push_back(make_pair(40, 'd'));
mylist.push_back({ 50, 'e' });
for (auto e : mylist)
cout << e.first << ":" << e.second << endl;
return 0;
}int main()
{
// 下面我们试一下带有拷贝构造和移动构造的 std::string，再试试呢
// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
// 是先构造，再移动构造，其实也还好。
std::list< std::pair<int, std::string> > mylist;
mylist.emplace_back(10, "sort");
mylist.emplace_back(make_pair(20, "sort"));
mylist.push_back(make_pair(30, "sort"));
mylist.push_back({ 40, "sort" });
return 0;
}总结：由于移动构造的存在，push 系列和 emplace 系列的效率差不多。
7、包装器
7.1 function 包装器
template<class F, class T>
T useF(F f, T x)
{
// count 用来观察 useF 函数模板是否被实例化为多份
// 函数模板被实例化为不同函数，count 变量的地址不同
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;
// lambda 表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
return 0;
}通过上面的程序验证，我们会发现 useF 函数模板实例化了三份。这会导致模板的效率低下。能不能把 useF 函数的第一个参数 F f 设置为某个统一的类型，即“可调用类型”，使得不管是函数指针、仿函数对象、lambda 表达式都被模板识别为同一种类型，进而只实例化出一个模板函数。包装器可以很好的解决上面的问题。
包装器的声明
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参使用方法（以上面的函数指针、仿函数对象、lambda 表达式为例）
#include<functional> // 包含头文件
int main()
{
function<double(double)> f1 = f; // 包装函数指针
function<double(double)> f2 = Functor(); // 包装仿函数对象
function<double(double)> f3 = [](double d)->double// 包装 lambda 函数对象
{ return d / 4; }
useF(f1,11.11);
useF(f2,11.11);
useF(f3,11.11);
// 函数模板被实例化为一份
return 0;
}除了增加模板的效率，包装器更多的作用是统一可调用类型，使得函数指针、仿函数对象、lambda 表达式可以存储在同一个数据结构：
int main()
{
function<double(double)> f1 = f; // 包装函数指针
function<double(double)> f2 = Functor(); // 包装仿函数对象
function<double(double)> f3 = [](double d)->double// 包装 lambda 函数对象
{ return d / 4; }
vector<function<double(double)>> v = {f1,f2,f3};
return 0;
}包装器更多应用场景
class Solution {
public:
map<string,function<int(int,int)>> cmdFuncmap = {
{"+",[](int x,int y){return x + y;}},
{"-",[](int x,int y){return x - y;}},
{"*",[](int x,int y){return x * y;}},
{"/",[](int x,int y){return x / y;}},
};
int evalRPN(vector<string>& tokens) {
stack<int> st;
for(auto s : tokens)
{
if(cmdFuncmap.count(s))
{
//操作符
int right = st.top(); st.pop();
int left = st.top(); st.pop();
st.push(cmdFuncmap[s](left,right));
}
else
{
// 操作数
st.push(stoi(s));
}
}
return st.top();
}
};7.2 bind
假设有这样一个函数：
int sub(int a,int b)
{
return a - b;
}如果我们想调换函数参数传递的从左到右一一对应的关系，也就是说，在调用该函数时，第一个实参不一定传递给第一个形参，该怎么办呢？
如果我们想利用现有的函数，创造出一些新的函数，这些新的函数的形参是现有函数的形参的缺省，比如上面的函数，我只想传递第二个参数，第一个参数默认是某个数，该怎么办呢？
使用 bind 可以解决问题
使用方法
int main()
{
//表示绑定函数 sub 参数分别由调用 func1 的第一，二个参数指定
std::function<int(int, int)> func1 = std::bind(sub, placeholders::_1,
placeholders::_2);
// 也可以用 auto
// auto func1 = std::bind(sub, placeholders::_1, placeholders::_2);
func1(10,5); // 调用 sub(10,5);
//表示绑定函数 sub 参数分别由调用 func2 的第二，一个参数指定
std::function<int(int, int)> func2 = std::bind(sub, placeholders::_2,
placeholders::_1);
func1(10,5); // 调用 sub(5,10);
//表示绑定函数 sub 第一个参数默认为 100
//注意类型不是 std::function<int(int, int)>
std::function<int(int)> func3 = std::bind(sub, 100, placeholders::_1);
func3(50); // 调用 sub(100,50);
retrun 0;
}可以看出使用 bind 可以使任意的形参缺省，而不必遵循缺省必须是从右到左缺省。
注意：
应当注意新函数参数和 bind () 括号内参数和原函数参数的顺序关系
如果要绑定类中的非静态成员函数，在 bind() 括号内的函数名前要加上 &，静态成员函数可有可无,并且要注意非静态成员函数，第一个形参默认是 this 指针。
class Sub { public: static ssub(int a,int b) {return a - b}; sub(int a,int b){return a - b}; } int main() { auto func1 = bind(Sub::ssub,placeholders::_1,placeholders::_2); Sub s; auto func2 = bind(&Sub::sub,&s,placeholders::_1,placeholders::_2); return 0; }
bind 的底层原理实际是生成仿函数。
8、新的默认成员函数和关键字
原来C++类中，有6个默认成员函数：
1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。
C++11 新增了两个：默认移动构造函数和默认移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
- 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个（这三个函数一旦写其中一个，就意味着这是一个需要深拷贝的类，一般就都要写其他两个）。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
- 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
- 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。
禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成 private，并且只做函数声明，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明之后加上
= delete 即可，该语法指示编译器不生成对应函数的默认版本，称 = delete 修饰的函数为删除函数。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
