欢迎各位大佬光临本文章！！！

还请各位大佬提出宝贵的意见，如发现文章错误请联系冰冰，冰冰一定会虚心接受，及时改正。

本系列文章为冰冰学习编程的学习笔记，如果对您也有帮助，还请各位大佬、帅哥、美女点点支持，您的每一分关心都是我坚持的动力。

我的博客地址：bingbing~bang的博客_CSDN博客https://blog.csdn.net/bingbing_bang?type=blog

我的gitee：冰冰棒 (bingbingsupercool) - Gitee.comhttps://gitee.com/bingbingsurercool

---

系列文章推荐

冰冰学习笔记：《位图与布隆过滤器》

冰冰学习笔记：《哈希表与无序容器》​​​​​​​

---

目录

系列文章推荐

前言

1.列表初始化

1.1{ }初始化

1.2initializer_list

2.新增关键字与范围for

2.1auto

2.2decltype与typeid()

2.3nullptr

2.4范围for

3.右值引用

3.1左值引用与右值引用的简介

3.2左值引用与右值引用的差异

3.3右值引用的意义

3.4万能引用与完美转发

4.新增容器

5.类的新增函数

6.可变参数模板

7.lambda表达式

8.包装器function与bind

---

前言

        什么是C++11呢？首先我们使用的C++语言中语法都是基于C++98标准发行的，但是语言本身就需要更新来适应新的特性和弥补之前的缺陷，因此1998年成立的C++委员会计划每5年更新一次标准，使得C++语言更加健壮。2003年C++委员会提交了一份技术勘误表，对C++98标准中的漏洞进行了修复，但是语言的核心部分没有改动，因此03版本并没有称为真正意义上的新标准。到了06年，委员会认为07年肯定推不出新的标准，因此将即将推出的标准称为C++0x，但是直到10年也没有推出新的版本。最终C++十年磨一剑，在11年终于推出了C++11新标准。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言， C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更 强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，接下来我们要介绍一些C++11中常用的新技术。

1.列表初始化

1.1{ }初始化

        在C++98的标准中，我们可以使用{ }用来初始化结构体和数组：

struct Point
{
	int _x;
	int _y;
};
int main()
{
	int arr1[5] = { 1,2,3,4,5 };//初始化数组
	Point p = { 1,2 };//初始化结构体
	return 0;
}

        但是在C++11的标准中，{ }初始化的权限被放大了，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。另外，在使用new时也可以使用。

int main()
{
	int arr1[5] = { 1,2,3,4,5 };
	Point p = { 1,2 };
	int x = 1;
	int y = { 2 };
	int z{ 3 };
	Point p1  { x,y };
	Point p2  { y,z };
	Point* p3 = new Point{ 4,5 };
	cout << p3->_x <<p3->_y<< endl;
	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;
};
void test2()
{
	Date d1(2023, 1, 1);
	cout << "------------" << endl;
	Date d2{ 2023,1,2 };
	Date d3 = { 2023,1,3 };
}

        当然，这样书写难免会显得奇怪，因此在平常写代码的过程中我们还是按照传统的写法进行比较好。

1.2initializer_list

        列表初始化最方便的应用是在STL库中容器的初始化时，例如在vector中，我们可以很方便的使用{}进行一组元素的初始化，如果不适用{ }进行初始化，那我们只能进行元素的插入。

void test3()
{
	//列表初始化进行构造
	vector<int> v1 = { 1,2,3,4,5 };
	cout << v1[0] << " " << v1[1] << " " 
		<< v1[2] << " " << v1[3] << " " 
		<< v1[4] << endl;
	cout << "-------------" << endl;
	//传统方法
	vector<int> v2;
    //元素插入
	v2.push_back(1);v2.push_back(2);v2.push_back(3);
	v2.push_back(4);v2.push_back(5);
	cout << v2[0] << " " << v2[1] << " "
		<< v2[2] << " " << v2[3] << " "
		<< v2[4] << endl;
}

         但是为什么STL可以支持{ }进行初始化呢？我们自己以前实现的vector可以支持吗？

        我们会发现，自己实现的并不能直接支持，原因在于STL库中的vector都增加了initializer_list版本的构造函数。initializer_list是C++库中实现的一个类模板，经常作为一些容器初始化函数的参数，用来支持{ }初始化。

        在容器的赋值重载中，也会实现initialize_list版本的赋值重载：

        那如果我们的vector想支持{ }初始化，那么构造函数和赋值重载就需要增加initializer_list版本的函数。

vector(initializer_list<T> t)
	:_start(nullptr)
	,_finish(nullptr)
	,_end_of_storage(nullptr)
{
	reserve(t.size());
	for (auto p : t)
	{
		push_back(p);
	}
}
vector<T>& operator =(initializer_list<T> t)
{
	resize(0);
	for (auto e : t)
	{
		push_back(e);
	}
	return *this;
}
//此时自己实现的就支持了{ }初始化和赋值
lb::vector<int> v2 = { 1,2,3,4,5 };
	v2 = { 6,7,8,9,10 };

2.新增关键字与范围for

        C++11中新增了许多的关键字，例如前面在继承和多态中使用的virtual以及final，C++11中还对原有的的关键字含义做了更改，例如auto。

2.1auto

        C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局 部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将 其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初 始化值的类型。

2.2decltype与typeid()

        在上面的例子中，我们使用了typeid()来获取类型的名称，当我们不知道某个变量的类型的时候，可以用typeid()这个类中的成员函数获取。在C++11中，还有一个关键字与这个类相似。

        decltype关键字不是获得变量的类型名称，而是使用变量的类型来创建新的变量。

void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret=10;
	cout << "ret的类型：" << typeid(ret).name() << " ret的值：" << ret << endl;
}

void test5()
{
	const int x = 1;
	double y = 2.2;
	decltype(x * y) ret; // ret的类型是double
	decltype(&x) p;      // p的类型是int*
	cout << typeid(ret).name() << endl;
	cout << typeid(p).name() << endl;
	F(1, 'a');
}

        例如，我们想对一个整型变量和浮点型变量进行乘积操作，但是我们并不知道乘积是什么类型，此时我们就可以采用decltype来进行推导定义。 此时会有人说，auto也可以呀，确实，但是我们如果想使用乘积的类型来创建新的变量实现其他的操作时，变量类型就无法使用auto获得。

        例如上面的函数中，我们只是使用t1*t2的类型来创建ret，并不需要获得相乘的结果。

2.3nullptr

        nullptr我们一直在使用，用来代替C语言中的NULL，作为空使用。nullptr也是C++11中新增的关键字。原因在于C++中将NULL定义为了字面量0，并非C语言中的((void*)0)。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

2.4范围for

        范围for也是我们一直使用的语法，范围for并不神奇，其底层只是对迭代器进行了简单的替换。

		iterator begin()
		{
			cout << "begin()" << endl;
			return _start;
		}
		iterator end()
		{
			cout << "end()" << endl;
			return _finish;
		}

        例如我们在自己实现的vector中对迭代器函数begin()和end()进行改造，一旦有人调用就会进行打印，当我们使用范围for进行遍历时，会发现其调用了迭代器。 

3.右值引用

3.1左值引用与右值引用的简介

        之前我们学习的C++语法中，为了简化指针的用法，我们使用了引用来代替。而在C++11中，将之前的引用语法定义为左值引用，并且新增了右值引用。那么什么是左值引用，什么是右值引用呢？

        左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋 值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左 值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

void test7()
{
	//左值
	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;
}

        右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引 用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

void test8()
{
	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;

}

        简单来说，左值可以取地址，右值不能取地址。 但是右值在被引用后，右值会被存储到特定的位置，且可以取到该位置的地址，还能对其进行赋值。对右值引用后，引用本身变为了左值。

3.2左值引用与右值引用的差异

        那么左值引用和右值引用有什么区别呢？在之前我们没有学习右值引用时，在一些函数中如果使用引用的传参，如果参数不会改变，那我们会建议使用const类型的引用进行参数接收。原因在于const 修饰的左值引用既可以引用左值也可以引用右值。一般情况下，左值引用只能引用左值。

        右值引用也只能引用右值，但是右值引用可以引用move以后的左值。

void test10()
{
	int x = 20;
	int& a = 10;//左值引用引用右值，编译失败
	const int& b = 10;//const修饰的可以引用
	int&& c = 10;
	int&& d = x;//右值引用无法引用左值
	int&& e = move(x);//可以引用move以后的左值
}

3.3右值引用的意义

        既然const类型的左值引用既能引用左值也可以引用右值，那为什么C++11增加右值引用呢？左值引用固然优秀，但是左值引用有些问题并不能很好的解决。左值引用在传参和做返回值时可以减少拷贝的次数，提高效率。但是面对局部变量的返回值，左值引用无法使用引用返回，局部对象出了作用域就会销毁，因此我们只能使用传值返回。如果对象小还好，但是对象一旦占据大量的空间，在使用拷贝时会极大的损失效率。

        例如我们之前使用的to_string函数。我们只能进行传值返回。

lb::string to_string(int value)
{
	lb::string str;
	bool flag = true;
	if (value < 0)
	{
		flag = false;
		value = 0 - value;
	}
	while (value > 0)
	{
		int x = value % 10;
		value /= 10;
		str += ('0' + x);
	}
	if (flag == false)
	{
		str += '-';
	}
	std::reverse(str.begin(), str.end());
	return str;
}
void test11()
{
	int x = 176589;
	lb::string s = to_string(x);
}

        在进行传值返回后，如果没有编译器的优化是需要拷贝2次的，编译器进行优化后会拷贝一次。

        但是我们发现上面的例子中就算是拷贝了一次，string类中的拷贝是深拷贝，还是会浪费拷贝的资源。此时我们发现，str本身就是需要销毁的变量，但是我们需要这个即将销毁的变量所保存的资源，那如果我们能够将这个资源转移出来，那我们就不需要拷贝了呀，直接将资源转移给s不就行了吗？

        右值引用和移动构造的出现就很好的解决了上面的问题。STL库中的容器都新增了一些移动构造和移动赋值的接口，接口的参数都是右值引用。移动构造本质是将参数右值的资源窃取过来，占为己有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

        由于to_string 返回的参数是一个即将消亡的右值，因此使用移动构造将会把资源直接转移出来，而不会进行深拷贝降低效率。

        //移动构造
		string(string&& s)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			cout << "调用移动构造" << endl;
			swap(s);
		}
		//移动赋值
		string& operator=(string&& s)
		{
			swap(s);
			cout << "调用移动赋值" << endl;
			return *this;
		}

        当我们使用一个已经存在的对象作为接受时，会直接调用移动构造和移动赋值。

        当我们想用右值引用来引用左值的时候，就需要move函数。move函数可以将一个左值变为一个右值。 但是使用move之后，原来的对象资源就会被转移走，因此我们要格外小心。

        s1变为了空，资源转移给了s2。移动构造只有在深拷贝的时候才有用处，浅拷贝并没有效率的提升。

3.4万能引用与完美转发

        当我们使用模板来创建右值引用的参数时，右值引用不再是原来的右值引用，此时T&& t称为万能引用，参数t 既可以是左值也可以是右值。当参数传过来的是左值时，&&将会折叠一个变为 T& t，进行参数接受，当参数为右值时则接受右值引用。但是我们会发现无论传过来的是左值还是右值，t在进行传参时，t就变成了左值。此时会照成一些错误。如下面的代码所示，我们无论传递左值还是右值，统统调用的Fun函数都是左值引用的版本。原因在于Fun函数的参数t是左值。

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);
}
void test12()
{
	PerfectForward(10);           // 右值
	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);      // const 左值
	PerfectForward(std::move(b)); // const 右值
}

         那么如何解决这种状况呢，让我们的参数保持自己本身的特性。完美转发就是解决的办法。forward将保持对象原生的类型属性。

4.新增容器

        C++11中还新增几个容器，其中包括利用哈希原理的unordered_map 和 unordered_set，以及forward_list和array。

        array和forwad_list 用的非常少，array与数组类似，但是array对于越界的检测更加严格，无论读写，只要越界都会被检测出来，但是传统的数组是对写入的抽查，有些越界并不会被检查。

5.类的新增函数

        C++的类中原本含有默认的六个成员函数，我们在类与对象章节做出了详细的论述。C++11中类新增了两个默认成员函数，使其变为了八个默认成员函数。新增的这两个成员函数就是移动构造和移动赋值，但是这两个默认成员函数形成的条件比较苛刻。

        如果我们没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造， 如果实现了就调用移动构造，没有实现就调用拷贝构造。

        如果我们没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。

        当然，如果我们自己提供了，编译器就不会默认生成。

        在下面的代码中，Person类会自己生成移动赋值和移动构造，因此，会调用一次拷贝构造，一次移动构造，一次移动赋值。

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	//屏蔽掉拷贝构造会默认生成移动赋值和移动构造
    /*Person(const Person& p)
		:_name(p._name)
		,_age(p._age)
	{}*/
private:
		lb::string _name;
		int _age;
};
void test13()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
}

        当我们显示提供拷贝构造后，编译器不会给Person类默认生成移动构造和移动赋值，因此会调用2次拷贝构造，一次拷贝赋值重载。

        C++11中还对某些关键赋予了其他的用法，例如default，在类成员函数的后面提供，会让该成员函数强制默认生成。

        delete关键字出了释放被new开辟的空间外，delete关键字还可以修饰默认生成的成员函数，让其禁止默认生成。例如，我们如果想创建一个只能在堆上开辟空间的类，C++98的做法是将构造函数私有，而在C++11中，我们可以将构造函数进行禁止。

class HeapOnly    
{     
public:     
    static HeapOnly* CreateObject()  
   {      
        return new HeapOnly;    
   }
private:    
    HeapOnly() {}
    
    // C++98
    // 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
 // 2.声明成私有
    HeapOnly(const HeapOnly&)；
    
    // or
        
    // C++11    
    HeapOnly(const HeapOnly&) = delete;
};

6.可变参数模板

        C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比 C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改 进。

        可变参数即不知道传递过来多少个参数，但是我们可以是使用参数包进行一一接受，在参数接受完毕后再获取每个参数。STL的emplace_back函数的接口就是可变参数。

 

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

如何获取每个参数是一个难点，这里我们提供两种方式：

（1）递归函数方式展开

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...);
}
void test14()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));

}

        递归方式的展开是利用函数ShowList的第一个参数进行完成的，当可变参数传递后，第一个参数会匹配函数ShowList的第一个参数，随后剩余的参数将匹配到可变参数args中。递归调用就会将参数依次匹配到value中，直到ShowList函数的可变参数args没有传参时调用递归种植函数ShowList(const T& t)。

如果要计算可变参数的个数可以采用此种方式：sizeof...(args)

（2）逗号表达式

        这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg 不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。

template <class T>
void PrintArg(T t)
{
 cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
 int arr[] = { (PrintArg(args), 0)... };
 cout << endl;
}
void test16()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
}

        expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行 printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列 表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...(args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args) 打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在 数组构造的过程展开参数包。

7.lambda表达式

        我们以前在进行某些自定义类型的比较的时候往往需要自己实现仿函数来进行比较，每比较一个类型的对象我们都需要创建一个类来进行仿函数的包装，这样虽然可以实现比较但是太过于麻烦。因此在C++11中，人们为了简便这种方式，委员会引入了lambda表达式来简便这种比较的方式。

lambda表达式的语法：

[capture-list] (parameters) mutable -> return-type { statement }

（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[ ]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda 函数使用。

（2）(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略

（3）mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。

（4）->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型， 没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

（5）{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;
}

        lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。

捕捉列表的说明：

        捕捉列表描述了上下文中哪些数据可以被lambda使用，以及使用的方式是传值还是引用。

[var]：表示值传递方式捕捉变量var

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

[&var]：表示引用传递捕捉变量var

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

[this]：表示值传递方式捕捉当前的this指针

注意：父作用域指包含lambda函数的语句块（函数），语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量， [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量。捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。在块作用域以外的lambda函数捕捉列表必须为空， 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者 非局部变量都会导致编译报错。lambda表达式之间不能相互赋值，即使看起来类型相同。

int d = 100;
void test19()
{
	int a = 10;
	int b = 20;
	char c = 'a';
	auto fun1 = [=]() {cout << a << " " << b << " " << c << " " << d << endl; };
	fun1();
	if (a)
	{
		auto fun2 = [&]() {cout << ++a << " " << --b << " " << c << " " << d << endl; };
		fun2();
	}
}

        例如在上面的代码段中fun1代表的lambda表达式能够将a，b，c全部捕捉，但是全局变量d也能够正常捕捉，全局变量d的作用域在全局，哪里都可以用。 fun2代表的lambda表达式看起来只能捕捉a变量，其实并不是，这里的父作用域实际上是整个函数test19的作用域，因此照样可以捕捉其他的局部变量。

        lambda表达的底层实现其实还是仿函数，捕获列表实际上就是传参过程，编译器对lambda表达式的处理就是按照仿函数的模式进行处理的，也就是说如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

 

8.包装器function与bind

        function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那我们为什么需要包装器呢？

先看下面的例子：

ret=func(x);

        上面的代码中func可以是什么呢？可以是仿函数对象，可以是函数指针，也可以是lambda表达式。这些对象都可以调用，在实现模板时就会对一个模板进行多次的实例化，导致了模板的效率底下。

template<class F, class T>
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;
	}
};
void test20()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	// 仿函数
	cout << useF(Functor(), 11.11) << endl;
	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
}

        由代码的执行结果我们可以看到，count有三份，说明我们实现了3个useF函数模板。

但是如果我们使用包装器将三个函数进行包装，对应的模板只会实现一份。

std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

        function<返回类型(参数类型)> 包装器名称=包装函数。

        对于普通函数我们可以直接将函数名进行包装，对于仿函数，我们需要包装仿函数对象，对于类成员函数函数，静态成员在突破类域后直接进行包装，而普通的成员函数需要增加一个包装的内容，即类对象，然后在包装函数的地址。

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;
	}
};
void test21()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;
	// lamber表达式
	std::function<int(int, int)> func3 = [](const int a, const int b)
	{return a + b; };
	cout << func3(1, 2) << endl;

	// 类的成员函数
	std::function<int(int, int)> func4 = &Plus::plusi;//静态函数
	cout << func4(1, 2) << endl;
	std::function<double(Plus, double, double)> func5 = &Plus::plusd;//成员函数
	cout << func5(Plus(), 1.1, 2.2) << endl;
}

 在使用了包装器后，模板参数就不再出现实例化多份的情况了。

        bind和包装器通常一起使用。是一个函数模板，它就像一个函数包装器(适配器)，接受一个可 调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而 言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M 可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

当然最主要的用处还是实现参数不同时的包装效果。

int Plus(int a, int b)
{
	return a + b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
#include<map>
void test22()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,
		placeholders::_2);
	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
	//func2的类型为 function<void(int, int, int)> 与func1类型一样
	//表示绑定函数 plus 的第一，二为： 1， 2
	auto  func2 = std::bind(Plus, 1, 2);
	cout << func1(1, 2) << endl;
	cout << func2() << endl;
	Sub s;
	// 绑定成员函数
	std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,
		placeholders::_1, placeholders::_2);
	//参数的调用顺序更换
	std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,
		placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	cout << func4(1, 2) << endl;
	
	map<string, function<int(int, int)>> dict =
	{
		{"+",func2},
		{"-",func3}
	};	
}

        使用bind后，我们可以将传递两个参数的普通函数和传递三个参数的类成员函数包装成一样的类型，并能使用map进行映射。