目录
C++11简介
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于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++98中，标准允许使用花括号{}对数组元素进行统一的列表初始值设定。比如：
int array1[] = {1,2,3,4,5};
int array2[5] = {0};
如果想使用{}用来初始化vector对象的时候，就无法通过编译，导致每次定义vector时，都需要先把vector定义出来，然后使用循环对其赋初始值，非常不方便。
vector<int> v{1,2,3,4,5}; //C++11引入{} 后的写法非常方便
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。其实它的底层是由initializer_list类模板来支持的
int main()
{
// 内置类型变量
int x1 = {10};
int x2{10};
int x3 = 1+2;
int x4 = {1+2};
int x5{1+2};
// 数组
int arr1[5] {1,2,3,4,5};
int arr2[]{1,2,3,4,5};
// 动态数组，在C++98中不支持
int* arr3 = new int[5]{1,2,3,4,5};
// 标准容器
vector<int> v{1,2,3,4,5};
map<int, int> m{{1,1}, {2,2,},{3,3},{4,4}};
return 0;
}
std::initializer_list
这种类型的对象由编译器根据初始化列表声明自动构造，列表声明是一个用花括号括起来的逗号分隔元素列表。
auto il = {1,2,3,4,5,6};
cout << typeid(il).name() << endl;
//编译器根据初始化列表声明自动构造出来的类型：class std::initializer_list<int>
并且initializer_list也会拥有自己的类成员函数
| 函数 | 功能 |
|---|---|
| (constructor) | 构造空的initializer_list(公共成员函数) |
| size | 返回list的大小(公共成员函数) |
| begin | 返回开始的迭代器(公共成员函数) |
| end | 返回到end的迭代器(公共成员函数) |
其实STL中的各个容器之所以都支持{}来初始化对象，也都跟这个initializer_list类模板有关，以下举例几个容器list、vector、
模拟部分vector中initializer_list的用法
#include <initializer_list>
template<class T>
class Vector {
public:
// ...
Vector(initializer_list<T> l): _capacity(l.size()), _size(0)
{
_array = new T[_capacity]; //开空间
for(auto e : l) _array[_size++] = e; //依次读取l对象中的元素赋值给_array数组
}
Vector<T>& operator=(initializer_list<T> l) {
delete[] _array; //释放旧空间
_array = new T[_capacity]; //开辟新空间
size_t i = 0;
for (auto e : l) _array[i++] = e; //依次读取l对象中的元素赋值给_array数组
return *this;
}
// ...
private:
T* _array;
size_t _capacity;
size_t _size;
};
变量类型推导
C++11中，可以使用auto来根据变量初始化表达式类型推导变量的实际类型，可以给程序的书写提供许多方便。程序可以通过编译，而且更加简洁。
decltype类型推导
为什么需要decltype，auto使用的前提是：必须要对auto声明的类型进行初始化，否则编译器无法推导出auto的实际类型。但有时候可能需要根据表达式运行完成之后结果的类型进行推导，因为编译期间，代码不会运行，此时auto也就无能为力。
decltype是根据表达式的实际类型推演出定义变量时所用的类型，比如：
1、推演表达式类型作为变量的定义类型
int main()
{
int a = 10;
int b = 20;
// 用decltype推演a+b的实际类型，作为定义c的类型
decltype(a+b) c;
cout<<typeid(c).name()<<endl;
return 0;
}
2、推演函数返回值的类型
void* GetMemory(size_t size) {
return malloc(size);
}
int main()
{
// 如果没有带参数，推导函数的类型
cout << typeid(decltype(GetMemory)).name() << endl;
// 如果带参数列表，推导的是函数返回值的类型,注意：此处只是推演，不会执行函数
cout << typeid(decltype(GetMemory(0))).name() <<endl;
return 0;
}
右值引用
右值引用概念，C++98中提出了引用的概念，引用即别名，引用变量与其引用实体共同使用一块内存空间，而引用的底层是通过指针来实现的，因此使用引用，可以提高程序的可读性。为了提高程序运行效率，C++11中引入了右值引用，右值引用也是别名，但其只能对右值引用。
左右与右值概念区分
左值与右值是C语言中的概念，但C标准并没有给出严格的区分方式，一般认为：可以放在=左边的，或者能够取地址的称为左值，只能放在=右边的，或者不能取地址的称为右值，但是也不一定完全正确。
int a = 10; //左值
int& ra1 = a; //左值引用绑定到左值
const int&& ra2 = 10; //右值引用绑定到右值
左值右值总结：
1、左值引用提高可读性，右值引用提高效率
2、左值是出现在 = 的左边，他是可以取地址的，左值是变量，右值是出现在 = 的右边的，他是不能取地址的，他是一个具有const属性的常量值
右值引用作用
C++98中引用作用：因为引用是一个别名，需要用指针操作的地方，可以使用引用来代替，可以提高代码的可读性以及安全性。C++11中右值引用主要有以下作用：
- 实现移动语义(移动构造与移动赋值)
- 给中间临时变量取别名
右值引用的使用场景
解决左值引用做返回值返回的时候，如果需要返回一个局部的对象，那么就需要涉及到深拷贝，过程如：栈帧快要销毁时构造出一个临时对象，将临时对象返回给对应的常引用，那么就会存在两次深拷贝的代价，当然现代编译器会将这两次拷贝构造给优化成一次构造函数，那么有没有更好的处理方式呢？这里就需要介绍右值和移动构造了，可以解决深拷贝的问题，效率会得到提高
//测试代码
class String
{
public:
//默认构造
String(const char* str = "")
{
if (nullptr == str)
str = "";
_str = new char[strlen(str) + 1];
strcpy(_str, str);
cout << "构造函数\n" << endl;
}
//拷贝构造
String(const String& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
cout << "调用了拷贝构造函数\n" << endl;
}
//拷贝赋值
String& operator=(const String& s)
{
if (this != &s)
{
char* pTemp = new char[strlen(s._str) + 1];
strcpy(pTemp, s._str);
delete[] _str;
_str = pTemp;
}
return *this;
}
//重载加法运算符
String operator+(const String& s)
{
char* pTemp = new char[strlen(_str) + strlen(s._str) + 1];
strcpy(pTemp, _str);
strcpy(pTemp + strlen(_str), s._str);
String strRet(pTemp); //char*指针做参数构造strRet对象
return strRet; //注意这里的返回值会产生一个临时对象，
}
//析构函数
~String()
{
if (_str) delete[] _str;
}
private:
char* _str;
};
void func()
{
String s1("hello");
String s2("world");
String s3(s1 + s2);
}
先来看operator+ 没有加上移动构造函数，存在深拷贝的问题，代价极大
加上移动构造函数，只要涉及到用右值构造一个对象时，都不会存在深拷贝的问题，因为当使用右值去构造一个对象的时候都会优先去调用移动构造函数创建这个对象，那么就没有深拷贝的代价了
//移动构造
String(String&& str)
{
if (this == &str) return;
swap(str._str, _str); //交换str右值和_str的值
cout << "调用了移动构造函数\n" << endl;
}
另外增加了移动构造最好把移动赋值也一起加上
String& operator=(String&& str)
{
swap(str._str, _str);
return *this;
}
总结这两种现象：
当一个对象需要通过另一个对象s1构造出来，那么需要知道该对象s1是左值还是右值，如果是左值，并且类中没有定义移动构造函数，那么会优先调用拷贝构造，如果对象s1是右值，并且类中存在移动构造函数和拷贝构造函数，也会根据s1是右值去优先匹配到移动构造函数
右值引用引用左值、C++11 std::move()
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
当想往vector容器中插入一个String对象时，也会伴随着拷贝构造，这个时候我们也可以考虑用（右值引用 + 移动构造函数的特性）
测试代码
//vector容器中 push_back的模拟实现
void push_back(const T& v)
{
//满了考虑扩容
if (_finish == _endofstroage)
{
//尾插数据的时候提前计算增容大小
size_t newcapacity = capacity() == 0 ? 4
: capacity() * 2;
reserve(newcapacity);
}
//往这块空间填充值，_finish再往后挪动
*_finish = v;
_finish++;
}
//测试STL库里面的vector对象在push_back过程存不存在拷贝行为?
void func()
{
String s1("hello");
vector<String> v;
v.push_back(s1); //会调用拷贝构造函数，存在一次拷贝
//v.push_back(std::move(s1));
}
从程序的运行结果显而易见的是但凡我们往vector容器中插入一个左值默认调用的成员函数是拷贝构造，他是存在一次拷贝构造行为的
站在模拟实现vector的push_back接口函数的角度，可以分析出发生拷贝行为的具体原因
我们都知道vector的拷贝是一种深拷贝的行为，而为了减少发生这种拷贝带来的代价，可以将v.push_back(s1)，括号中的参数变成右值，这样即使是用*_finish = v; 发生的也是资源转换，并不存在拷贝，并且这个移动构造函数里面执行的也是swap(str._str, _str); 只是交换了两个对象的指针完成了资源的交换，由深拷贝的代价转化为交换两个指针，极大的提升了效率。
void func()
{
String s1("hello");
vector<String> v;
//v.push_back(s1); //会调用拷贝构造函数，存在一次拷贝
v.push_back(std::move(s1)); //会调用移动构造函数，完成资源交换
}
程序运行结果
std::move()
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
return ((typename remove_reference<_Ty>::type&&)_Arg);
}
注意：
- 被转化的左值，其生命周期并没有随着左值的转化而改变，即std::move转化的左值变量lvalue不会被销毁。
- STL中也有另一个move函数，就是将一个范围中的元素搬移到另一个位置。
总结右值引用使用的场景：
1、右值引用使用场景1，主要是对深拷贝的类，如：list、vector增加移动构造和移动赋值，如果需要解决对象的深拷贝的问题，可以先考虑利用右值和移动构造的特性节省资源
2、右值引用的使用场景2，还可以使用在容器插入接口函数中如果实参是右值，则可以转移它的资源，减少拷贝
完美转发
这里我们通过测试代码来观察，我们都知道PerfectForward是一个函数模板而使用模板参数类型T&&的都被称作为万能引用，万能引用是可以即接受左值又接受右值的
//重载多个版本的Func()函数
//1、左值版本
void Func(int& val) { cout << "Func(int& val)" << endl; }
void Func(const int& val) { cout << "Func(const int& val)" << endl; }
//2、右值版本
void Func(int&& val) { cout << "Func(int&& val)" << endl; }
void Func(const int&& val) { cout << "Func(const int&& val)" << endl; }
template <class T> void PerfectForward(T&& val)//提供函数模板
{
Func(val); //使用模板参数类型的(T&&)是一个万能引用，这里的val既可以是左值也可以是右值
}
void func1()
{
int a = 10;
PerfectForward(a); //使用左值
PerfectForward(1); //使用右值
const int b = 10;
PerfectForward(b); //使用const属性的左值
PerfectForward(1); //使用左值
}
程序运行结果：我们可以发现不管是传递左值还是传递右值PerfectForward函数最终T&& val的类型都会被变化化为左值，其实这个并不算是完美转发，接下来再看什么叫做完美转发吧
完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用另外一个函数，PerfectForward为转发的模板函数，Func为实际目标函数，但是上述转发还不算完美，完美转发是目标函数总希望将参数按照传递给转发函数的实际类型转给目标函数，而不产生额外的开销，就好像转发者不存在一样。所谓完美：函数模板在向其他函数传递自身形参时，如果相应实参是左值，它就应该被转发为左值；如果相应实参是右值，它就应该被转发为右值。这样做是为了保留在其他函数针对转发而来的参数的左右值属性进行不同处理（比如参数为左值时实施拷贝语义；参数为右值时实施移动语义）。
template <class T> void PerfectForward(T&& val)//提供函数模板
{
Func(forward<T>(val));
//使用完美转发后val的属性是什么就会调用对应类型的Func函数
}
void func1()
{
int a = 10;
PerfectForward(a);
PerfectForward(1);
const int b = 10;
PerfectForward(b);
PerfectForward(1);
}
使用forward函数模板实现完美转发后程序运行结果：
总结一下完美转发的意义：
如果不使用完美转发，那么实际传递的参数类型的属性不管是左值还是右值传递给对应的函数模板后T&&对象的属性都会是左值，而使用完美转发之后forward函数是能确定T&& 引用对象的属性的，并调用对应的Func函数
C++11引入了移动构造函数和移动赋值运算符重载一些需要注意的地方：
1、如果你没有自己实现一个移动构造函数，且没有实现析构函数、拷贝构造、拷贝复制重载中的任意一个，那么编译器会自动生成一个默认移动构造，默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，否则就只调用拷贝构造。
2、如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值，默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值，跟移动构造是完全类似的
3、如果你提供了移动构造和移动赋值，编译器不会自动提供拷贝构造和拷贝赋值
默认成员函数控制
在C++中对于空类编译器会生成一些默认的成员函数，比如：构造函数、拷贝构造函数、运算符重载、析构函数和&和const&的重载、移动构造、移动拷贝构造等函数。如果在类中显式定义了，编译器将不会重新生成默认版本。有时候这样的规则可能被忘记，最常见的是声明了带参数的构造函数，必要时则需要定义不带参数的版本以实例化无参的对象。而且有时编译器会生成，有时又不生成，容易造成混乱，于是C++11让程序员可以控制是否需要编译器生成。
显式缺省函数
在C++11中，可以在默认函数定义或者声明时加上=default，从而显式的指示编译器生成该函数的默认版本，用=default修饰的函数称为显式缺省函数。
class A {
public:
A(int a): _a(a)
{}
// 显式缺省构造函数，由编译器生成
A() = default;
// 在类中声明，在类外定义时让编译器生成默认赋值运算符重载
A& operator=(const A& a);
private:
int _a;
};
删除默认函数
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且不给定义，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
class A
{
public:
A(int a): _a(a)
{}
// 禁止编译器生成默认的拷贝构造函数以及赋值运算符重载
A(const A&) = delete;
A& operator(const A&) = delete;
private:
int _a;
};
C++11可变参数包展开
递归展开
递归遍历打印参数包的值
//函数模板可变参数包展开
//递归方式展开
void func5() {} //当不剩余参数包的时候调用不带参数的func5
template <class T, class ...Args>
void func5(T value, Args... args)
//value获取一包参数的第一个参数，...args获取从第二个参数开始的剩余参数
{
cout << value << " 、" << endl;
func5(args...);
//递归拆包，会将一包参数拆分成一个参数，和又一包参数，直到只剩一个参数时终止递归
}
int main()
{
func5(1 , 'a', string("hello word"));
//调用func5()函数时会将函数参数传递给value和...args（一包参数）
return 0;
}
可变参数包的应用
递归计算模板参数包的和
template<class T>
T sum(T &num)
{
return num;
}
template <class T, class ...Args>
T sum(T value, Args... args)
{
return value + sum<T>(args...);
}
int main()
{
cout << sum(10,10,10,10,10,10,10) << endl;
return 0;
}
使用可变参数包去列表初始化
template <class ...Args >
void test1(Args ... arg)
{
int arr[] = { arg... };
}
int main()
{
test1(1,52,22,874,87,45,10);
return 0;
}
效果：
可以使用参数包以列表初始化的方式去创建一个一维数组
逗号表达式展开
template <class T>
void print(T val)
{
cout << val << " ";
}
template <class ...Args >
void test1(Args ... args)
{
int arr[] = { (print(args), 0)... };
}
代码中，（1）的逗号表达式为： (print(args), 0)。先执行表达式1（print(args)）,再执行表达式2（0）。 使用调用代码test1(1, 2, 3, 4)，（1）处的逗号表达式展开结果如下
int arr[] = { (print(1), 0) , (print(2), 0), (print(3), 0), (print(4), 0) };
而，第一个逗号表达式结果为0， 第二逗号表达式的结果为0， … 最后一个逗号表达式展开后，逗号表达式的结果为0，所以(1)的代码最后是这样的：
int arr[] = {0, 0, 0, 0}; /// (2)
右值引用、可变参数包扩展谈之 STL容器新增接口函数emplace_back
博主只举例以下，但是STL中确实是有很多容器都增加了emplace_back接口函数，主要的原因是C++追求极高的效率！
vector中新增
queue新增
deque新增
list新增
不管是哪个容器中的emplace_back都有以下的几种性质
-
将新元素插入到列表的末尾，即当前最后一个元素的后面。 这个新元素使用
args（参数包）作为其构造的参数就地构造。 -
这有效地将容器大小增加了1。
-
该元素是通过调用allocator_traits::construct并
完美转发args这个参数包来就地构造的。 -
-
存在一个类似的成员函数push_back，它将现有对象
移动复制或移动构造到容器中。
这四点性质最重要的是会调用移动构造函数，会根据参数包args的信息（类型，参数个数，参数值）调用allocator_traits::construct函数通过完美转发技术确定args参数包中的类型再直接构造出一个对象的，但是怎么使用emplace_back才能达到极致的效果呢？
使用emplace_back的三种情况
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{ cout << "构造函数" << endl; }
Date(const Date& d)
{
cout << "拷贝构造" << endl;
}
Date(Date&& d)
{
cout << "移动构造" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//创建list对象
list<Date> lt;
Date d;
lt.emplace_back(d); //拷贝构造
lt.emplace_back(Date(2, 2, 2)); //尾插匿名对象，构造 + 移动构造
lt.emplace_back(10, 10, 10); //尾插一个参数包 ， 直接构造
return 0;
}
打印结果：
构造函数 //创建Date对象d
拷贝构造 //尾插一个对象
构造函数 //尾插一个匿名对象
移动构造
构造函数 //尾插一包参数
总结：使用emplace_back接口函数时，直接尾插一个参数包代价是最小的
lambda表达式
lambda表达式书写格式：
[capture-list] (parameters) mutable -> return-type { statement }
lambda表达式说明
- [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
- 捕获列表说明，捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
- [var]：表示值传递方式捕捉变量var
- [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
- [&var]：表示引用传递捕捉变量var
- [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
- [this]：表示值传递方式捕捉当前的this指针
void test4()
{
int x = 10, y = 20;
//参数传递x, y
auto swap1 = [](int& x,int& y)mutable->void {int tmp = x; x = y; y = tmp; };
swap1(x, y);
cout << x << " " << y << endl;
//引用捕捉x，y变量
auto swap2 = [&x, &y] {int tmp = x; x = y; y = tmp; };
swap2();
cout << x << " " << y << endl;
//引用捕捉父作用域所有的变量
auto swap3 = [&] {int tmp = x; x = y; y = tmp; };
swap3();
cout << x << " " << y << endl;
//值传递的方式,捕捉父作用域所有的变量
auto swap4 = [=]()mutable {int tmp = x; x = y; y = tmp; };
swap4();
cout << x << " " << y << endl;
}
-
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
-
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
-
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
-
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
注意：
- a. 父作用域指包含lambda函数的语句块
- b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量 [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量 - c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。 比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
- d. 在块作用域以外的lambda函数捕捉列表必须为空。
- e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
- f. lambda表达式之间不能相互赋值，即使看起来类型相同
包装器
function包装器
function包装器也叫做适配器，C++中的function本质是一个类模板，也是一个包装器， 那么我们来看看为什么需要function呢？
之前使用的可调用对象的类型涉及： 函数指针、仿函数(函数对象)、lambda表达式。
ret = func(1);
//假设我们写了这样的一句代码，那么func()可能是函数指针，或者仿函数，
//又或是lambda表达式这些都属于可调用的类型，那么有没有什么更方便的写法呢？
C++11引入包装器
包装器函数
-
class T 它可以将任何类型的可调用元素(如函数和函数对象)封装到可复制对象中，并且其类型仅依赖于其调用签名(而不是依赖于可调用元素类型本身)。
-
函数类实例化的对象可以包装以下任何一种可调用对象:函数、函数指针、成员指针或任何类型的函数对象(例如，类中定义operator()的对象，包括闭包)。
-
包装的可调用对象的衰变副本被对象存储在内部，它成为函数的目标。 实例化函数包装类并不需要这个目标可调用对象的特定类型; 只有它的呼叫签名。
-
函数对象可以被复制和移动，并且可以被用来直接调用具有指定调用签名的可调用对象(参见成员操作符())。
-
函数对象也可以处于没有目标可调用对象的状态。 在这种情况下，它们被称为空函数，调用它们会抛出一个bad_function_call异常。
std::function在#include<function> 头文件中
//类模板原型如下
template<class T> function;
template <class Ret, class ...Args>
模板参数说明：
Ret：被调用函数的返回类型
Args... ：被调用函数的形参
包装器包装可调用对象的四种情况
//普通函数
int f(int x, int y) { return x + y; }
//仿函数
struct functiont { int operator()(int x, int y) {return x + y; } };
//成员函数
class T
{
public:
int add(int x, int y) { return x + y; }
static int sub(int x, int y) { return x - y; }
};
//包装器
void packaging()
{
//包装函数指针
std::function<int(int, int)> ff1 = f;
auto ret = ff1(1,2);
printf("%d\n", ret);
//包装仿函数
std::function<int(int, int)> ff2 = functiont();
ret = ff1(1, 2);
printf("%d\n", ret);
//包装静态成员函数
std::function<int(int, int)> ff4 = T::sub;
ret = ff4(1, 2);
printf("%d\n", ret);
//包装成员函数，固定写法需要取出函数的地址
std::function<int(T, int, int)> ff5 = &T::add;
ret = ff5(T(), 1, 2); //对像的成员函数需要被this调用所以需要传递T()
printf("%d\n", ret);
//包装lambda
std::function<int(int, int)> ff6 = [](int x, int y){return x * y; };
ret = ff6(1, 2);
printf("%d\n", ret);
}
包装器只是把可调用对象的类型包装起来，做到像函数一样调用包装器对象传递对应的实参
总结：
std::function 包装各种各样的可调用的对象，统一可调用对象类型，并且指定了参数和返回值类型，为什么有std::function，因为不包装前可调用类型存在很多的问题：
1、函数指针类型复杂，不方便使用和理解
2、仿函数类型是一个类名，没有指定调用参数和返回值。得去看仿函数具体的实现
3、lambda表达式在语法层，看不到类型，底层有类型，基本都是lamb_uuid，也比较难看
bind（了解）
std::bind函数定义在头文件中，是一个函数模板，他就像一个函数包装器（适配器），接受一个可调用对象（callable object），生成一个新的可调用对象来"适应" 原对象的参数列表。一般而言，我们用他可以把一个原本接受N个参数的函数fn，通过绑定一些参数，返回一个接受M个（M可以大于N，但这么做并没有意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序等操作
原型：
simple(1)
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
//with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
可以将bind函数看作是一个通用的函数适配器，他接受一个可调用对象，生成一个新的可调用对象来“适应” 原对象的参数列表。调用bind的一般形式为：auto newCallable = bind（Callable, arg_list）;
其中newCallable 本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的Callable参数。当我们调用newCallable 时，newCallable 会调用newCallable ，并传递给arg_list中的参数
arg_list中的参数可能包含形如_n的名字，其中_n是一个整数，这些参数是占位符，表示newCallable的参数，他们占据了传递给 newCallable 的参数的 “位置” 。数值n表示生成的可调用对象中参数的位置：_1为newCallable 的第一个参数，_2为第二个参数，以此类推。
int add(int x, int y) { return x + y; }
void Bindtest()
{
std::function<int(int, int)> fc = bind(add, placeholders::_1, placeholders::_2);
//bind (Fn&& fn, Args&&... args);
auto ret = bind(add, 10, placeholders::_1);
//将add 绑定到模板参数列表Fn上，将函数参数绑定到参数包...args上
cout << ret(10) << endl;
}
bind的应用场景，有点类似于突破类域访问类的成员函数的作用
class Calculate
{
public:
int add(int x, int y) { cout << "int add(int x, int y) "; return x + y; }
int sub(int x, int y) { cout << "int sub(int x, int y) "; return x - y; }
int mul(int x, int y) { cout << "int mul(int x, int y) "; return x * y; }
int div(int x, int y) { cout << "int div(int x, int y) "; return x / y; }
};
void Bindtest()
{
//绑定成员函数add
std::function<int(int, int)> f1 = bind(&Calculate::add, Calculate(), placeholders::_1,placeholders::_2 );
cout << f1(1, 2) << endl;
//绑定成员函数sub
std::function<int(int, int)> f2 = bind(&Calculate::sub, Calculate(), placeholders::_1, placeholders::_2);
cout << f2(1, 2) << endl;
//绑定成员函数add
std::function<int(int, int)> f3 = bind(&Calculate::mul, Calculate(), placeholders::_1, placeholders::_2);
cout << f3(1, 2) << endl;
//绑定成员函数add
std::function<int(int, int)> f4 = bind(&Calculate::div, Calculate(), placeholders::_1, placeholders::_2);
cout << f4(1, 2) << endl;
}
1116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
