C++11常用的一部分新特性

C++11

  • 统一的列表初始化
    • {}初始化
    • std::initializer_list
  • 声明
    • auto
    • decltype
    • nullptr
  • STL中一些变化
    • 新容器
    • 已有容器的新接口
  • 右值引用和移动语义
    • 左值引用和右值引用
    • 右值引用使用场景和意义
    • 右值引用引用左值及其一些更深入的使用场景分析
    • 完美转发
  • 新的类功能
    • 默认成员函数
    • default与delete
  • 可变参数模板
    • 参数包
    • 遍历参数包中的参数
    • STL容器中的empalce相关接口函数
  • lambda表达式
    • 为什么要有lambda表达式
    • lambda表达式的格式
    • lambda的底层
  • 包装器
    • function包装器
    • bind

统一的列表初始化

{}初始化

C++11扩大了用大括号括起的列表(初始化列表)的使用范围,使其可用于所有的内置类型和用户自
定义的类型,使用初始化列表时,可添加等号(=),也可不添加。

#include
using namespace std;
int main()
{
	int arr1[] = { 1,2,3,4,5,6 };
	int arr2[]{ 1,2,3,4,5,6 };
	for (auto e : arr1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : arr2)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

C++11常用的一部分新特性_第1张图片

#include
using namespace std;
struct Point
{
 int _x;
 int _y;
};
int main()
{
	Point* p1 = new Point[2]{ {1,1},{2,2} };
	return 0;
}

C++11常用的一部分新特性_第2张图片

#include
using namespace std;
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(2023, 5, 25);
	Date d2{ 2023, 5, 25 };
	Date d3 = { 2023, 5, 25 };
	return 0;
}

C++11常用的一部分新特性_第3张图片
C++11常用的一部分新特性_第4张图片
也就是说这里用花括号进行初始化调用的是类的构造。
也就是说,C++11几乎可以一切都可以用花括号初始化,包括变量(但是不建议这样)。

std::initializer_list

来看下面这段代码:

#include
#include
#include
using namespace std;
int main()
{
	vector<int> arr{1, 2, 3, 4, 5, 6};//这里的初始化为什么可以随意改变元素数量呢?
	auto a = { 10,20,30 };//来看看这个花括号初始化成了什么类型
	cout << typeid(a).name() << endl;//这里拿到的是类型的字符串
	return 0;
}

C++11常用的一部分新特性_第5张图片
这是initializer_list类型的使用文档https://cplusplus.com/reference/initializer_list/initializer_list/
C++11常用的一部分新特性_第6张图片
这个类似一个常量数组,有两个指针指向数组的开始和结束(其实也是迭代器)。
并且这个vector可以利用这个类型进行初始化的。
C++11常用的一部分新特性_第7张图片
其实就相当于将initializer_list类型中的数据遍历然后push_back()到vector里面。
这种类型的实用处就是:

//这里就不用初始化一个pair类型的然后在插入map中了,因为里面是匿名对象的初始化
map<string, string> str = { {"字符串","string"},{"排序","sort"} };//里面的两个小花括号也可以理解为一个pair类型的initializer_list数组

声明

auto

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

decltype

关键字decltype将变量的类型声明为表达式指定的类型。

#include

using namespace std;

int main()
{
	int x = 0;
	cout << typeid(x).name() << endl;
	decltype(x) y;
	cout << typeid(y).name() << endl;

	return 0;
}

C++11常用的一部分新特性_第8张图片
那么decltype使用的地方在哪里呢?

#include

using namespace std;
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret = t1 * t2;//这里万一涉及到整型提升,不知道提升到哪个类型就可以自动推导,不至于丢失精度
	cout << typeid(ret).name() << endl;
	cout << ret << endl;
}
int main()
{
	F(1, 2);
	F(1, 2.2);
	return 0;
}

C++11常用的一部分新特性_第9张图片

nullptr

这个之前也经常用。
由于C++中NULL被定义成字面量0,这样就可能回带来一些问题,因为0既能指针常量,又能表示
整形常量。所以出于清晰和安全的角度考虑,C++11中新增了nullptr,用于表示空指针。

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

STL中一些变化

新容器

C++11常用的一部分新特性_第10张图片
array
https://legacy.cplusplus.com/reference/array/array/
C++11常用的一部分新特性_第11张图片
这个新容器和数组的功能没什么区别,不如vector好用,比普通数组多一个越界检查的报错。
C++11常用的一部分新特性_第12张图片
C++11常用的一部分新特性_第13张图片
forward_list
https://legacy.cplusplus.com/reference/forward_list/forward_list/
这是个单链表。
C++11常用的一部分新特性_第14张图片
这里的区别就是,每个节点少一个指针的大小,并且没有头插头删(并不是那么好用)

已有容器的新接口

这里以vector举例:
C++11常用的一部分新特性_第15张图片
这四个其实就是上面的正迭代器和反迭代器,c只是为了显示是const版本的而已,看起来更容易辨别。
C++11常用的一部分新特性_第16张图片
这个接口是缩容的接口,如果空间浪费的实在是太大,可以用一下(用时间换空间)。
在这里插入图片描述
还有这两个接口,与右值引用和可变模板参数有关,下面会结合这个接口讲解。

右值引用和移动语义

左值引用和右值引用

什么是左值?

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

什么是右值?

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

注意:

  1. 左值引用只能引用左值,不能引用右值。
  2. 但是const左值引用既可引用左值,也可引用右值。
  3. 右值引用只能右值,不能引用左值。
  4. 但是右值引用可以move以后的左值。
#include
using namespace std;
int main()
{
	// 左值引用只能引用左值,不能引用右值。
	int a = 10;
	int& ra1 = a;//ra为a的别名
	//int& ra2 = 10;//编译失败,因为10是右值
	//const左值引用既可引用左值,也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	int a = 10;
	int&& r2 = a;
	// error C2440: “初始化”: 无法从“int”转换为“int &&”
	// message : 无法将左值绑定到右值引用
	
	// 右值引用可以引用move以后的左值
	int&& r3 = std::move(a);
	return 0;
}

需要注意的是右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,且可
以取到该位置的地址,也就是说例如:不能取字面量10的地址,但是rr1引用后,可以对rr1取地
址,也可以修改rr1。如果不想rr1被修改,可以用const int&& rr1 去引用。

右值引用使用场景和意义

左值引用最大的意义就是函数传参,返回值,减少拷贝。
那么左值引用的缺点是什么?
看下面代码:

template<class T>
T func(const int x)
{
	T ret;
	return ret;//这里ret是局部变量,出作用域就会销毁,所以是一个传值返回
}

右值引用的价值之一就是补齐这最后一块短板。

右值引用引用左值及其一些更深入的使用场景分析

来看这样一段代码:

#include
#include
#include
using namespace std;
namespace baiye
{
	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)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::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
	};
}
namespace baiye
{
	baiye::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		baiye::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
			str += ('0' + x);
		}
		if (flag == false)
		{
			str += '-';
		}
		reverse(str.begin(), str.end());
		return str;
	}
}
int main()
{
	baiye::string str = baiye::to_string(-1234);
	return 0;
}

先看main函数中创建str然后调用to_string函数返回一个string类型赋值给str。
这里编译器优化就变成了拷贝构造。
C++11常用的一部分新特性_第17张图片
这样就少了一次拷贝构造。
但如果是这种情况就无法进行优化。
C++11常用的一部分新特性_第18张图片
那么这种情况下C++11是怎么解决问题的呢?

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			swap(s);
		}

如果传的参数是右值就会走这个函数。
注意:C++11给右值分为

纯右值(内置类型)
将亡值(自定义类型)

那么在to_string函数中返回了一个将亡值,如果在进行拷贝构造有些没必要:
C++11常用的一部分新特性_第19张图片
那么这里在进行拷贝传值的时候就会传给移动构造函数,移动构造函数内部其实就是交换两个对象的值,反正将亡值也要销毁了,这样就不用进行深拷贝了。(深拷贝代价太大,如果深拷贝的对象是vector>效率就非常低了)
C++11常用的一部分新特性_第20张图片
但是刚才这种情况还没有解决:
C++11常用的一部分新特性_第21张图片
那么这里就可以再写一个移动赋值:

		// 移动赋值
		string& operator=(string&& s)
		{
			swap(s);
			return *this;
		}

总结
右值引用是间接起作用,如果右值是将亡值,那么就转移资源。

C++11常用的一部分新特性_第22张图片
这里用vector举例:如果传进去的是右值,就会走这个接口,会提升效率。

**注意:**右值引用被引用一次之后,引用的这个别名就变成了左值。
C++11常用的一部分新特性_第23张图片
C++11常用的一部分新特性_第24张图片
如果不变成左值怎么传给swap。

完美转发

万能引用

#include

using namespace std;
template<class T>
void func(T&& x)//这里也可以称为引用折叠,如果传的是左值,就折叠成一个引用符号
{

}
int main()
{
	int x = 10;
	func(x);//左值也可以
	func(2);//右值也可以
	const int y = 20;
	func(y);//const左值
	func(move(y));//const右值
	return 0;
}

C++11常用的一部分新特性_第25张图片
那么这个时候如果func函数中要去调用这四个函数,结果是怎么样的呢?

#include

using namespace std;
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<class T>
void func(T&& x)
{
	Fun(x);
}
int main()
{
	int x = 10;
	func(x);//左值
	func(2);//右值
	const int y = 20;
	func(y);//const左值
	func(move(y));//const右值
	return 0;
}

C++11常用的一部分新特性_第26张图片
这里只会调用前两个函数,因为func中的参数x都是左值属性,这里就需要一个叫完美转发的在传参的过程中保持了 x 的原生类型属性。
C++11常用的一部分新特性_第27张图片
C++11常用的一部分新特性_第28张图片

新的类功能

默认成员函数

C++11 新增了两个默认成员函数:移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下:

如果你没有自己实现移动构造函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,自定义类型成员,则需要看这个成员是否实现移动构造,如果实现了就调用移动构造,没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个,那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,自定义类型成员,则需要看这个成员是否实现移动赋值,如果实现了就调用移动赋值,没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值,编译器不会自动提供拷贝构造和拷贝赋值。

default与delete

强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数,但是因为一些原
因这个函数没有默认生成。比如:我们提供了拷贝构造,就不会生成移动构造了,那么我们可以
使用default关键字显示指定移动构造生成。

#include
using namespace std;
class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
	Person(Person && p) = default;//强制生成
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成,在C++98中,是该函数设置成private,并且只声明补丁
已,这样只要其他人想要调用就会报错。在C++11中更简单,只需在该函数声明加上=delete即
可,该语法指示编译器不生成对应函数的默认版本,称=delete修饰的函数为删除函数。

#include
using namespace std;
class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p) = delete;
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = move(s1);
	return 0;
}

C++11常用的一部分新特性_第29张图片
这样吴凯伦是内部和外部都无法使用这个拷贝构造函数了。

可变参数模板

参数包

这个也是为了对标C语言的可变性参数,比如printf和scanf。

#include
using namespace std;
// Args是一个模板参数包,args是一个函数形参参数包
// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
int main()
{

	return 0;
}

上面的参数args前面有省略号,所以它就是一个可变模版参数,我们把带省略号的参数称为“参数
包”,它里面包含了0到N(N>=0)个模版参数。我们无法直接获取参数包args中的每个参数的,
只能通过展开参数包的方式来获取参数包中的每个参数,这是使用可变模版参数的一个主要特
点,也是最大的难点,即如何展开可变模版参数。

如何查看参数包有几个参数呢?

#include
using namespace std;
template <class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;//查看参数包有几个参数
}
int main()
{
	ShowList(1);
	ShowList(1, 2.2);
	ShowList(1, 2.2, string("xxx"));

	return 0;
}

C++11常用的一部分新特性_第30张图片

遍历参数包中的参数

递归函数方式展开参数包

#include
using namespace std;
// 递归终止函数
void ShowList()//当参数包中的参数变成0个的时候就会调用这个函数
{
	cout << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)//第一个参数传给value,剩下的参数传给args参数包
{
	cout << value << " ";
	ShowList(args...);
}
int main()
{
	ShowList(1);//这里1传给value,然后参数包没有参数调用终止函数
	ShowList(1, 2.2);//这里第一次1传给value,2.2传给参数包,第二次2.2传给value,参数包没有值,调用终止函数
	ShowList(1, 2.2, string("xxx"));
	return 0;
}

C++11常用的一部分新特性_第31张图片
非常的怪异。
逗号表达式展开参数包

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

C++11常用的一部分新特性_第32张图片
这里的arr数组是一个辅助的作用,里面调用的是PrintArg函数,编译器自行初始化arr数组,参数包中有多少个参数数组的空间就有多大。
在这里插入图片描述
这里的逗号表达式只是为了初始化arr数组,初始化为0。
C++11常用的一部分新特性_第33张图片

STL容器中的empalce相关接口函数

http://www.cplusplus.com/reference/vector/vector/emplace_back/
C++11常用的一部分新特性_第34张图片
C++11常用的一部分新特性_第35张图片
emplace_back是可以不传参的,那么默认用户的就是匿名构造,传入的值就是0。
那么emplace_back的意义在哪里呢?

#include
#include
using namespace std;
int main()
{
	vector<pair<int, string>>arr;
	arr.emplace_back(1, "xxx");//这里可以这样初始化(直接构造),push_back只能构造一个对象去传,当然emplace_back也可以构造一个对象传
	
	return 0;
}

其实就是一种优化,如果传入的是右值编译器可以直接优化成直接构造(移动构造或者是移动赋值都省下了),不需要任何拷贝构造或者是移动构造(如果是左值还是构造+深拷贝)。

lambda表达式

为什么要有lambda表达式

这个和仿函数有些类似。
举个例子,如果定义水果类,创建多个水果对象,那么他们分别有名字,价格,评价等等属性,如果想通过sort函数来实现对于不同对象的排序就要写很多个仿函数,非常的麻烦。

#include
#include
#include 
#include 
using namespace std; 
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;
}

那么这个时候lambda表达式就可以上场了。

#include
#include
#include 
#include 
using namespace std; 
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(), [](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; });//按照评价排序
	return 0;
}

这是按照价格排序的结果:
C++11常用的一部分新特性_第36张图片
这是按照评价排序:
C++11常用的一部分新特性_第37张图片

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函数不能做任何事情。

#include
using namespace std;
int main()
{
	//其实lambda就是要给可调用的对象
	auto compare = [](int x, int y) {return x > y; };//这个类型编译器认识,但是我们不认识
	cout << compare(1, 2) << endl;
	return 0;
}

那么,在外部定义的变量能在lambda表达式中使用吗?

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto add1 = []() { return a + b; };
	return 0;
}

在这里插入图片描述
这里是不可以的,因为是两个不同的作用域,这个时候需要捕捉这两个变量才可以使用。

auto add1 = [a, b]() { return a + b; };

这个时候编译就通过了。
那么如果想交换两个变量呢?

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto swap1 = [a, b]()
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

C++11常用的一部分新特性_第38张图片
这里是不允许的,如果想修改要加mutable。

	auto swap1 = [a, b]()mutable
	{
		int c = a;
		a = b;
		b = c;
	};

但是外部的a和b并没有发生改变,也就是说捕捉的对象是传值拷贝,加了一个const的变量,mutable只是让他们变成非const属性的值。
如果想改变就要这样:

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto swap1 = [&a, &b]()//这里虽然是外部a和b的别名,但是不能修改a和b的名字,不然就不能捕捉了
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

这里也无法在捕捉列表取地址。
在捕捉列表里面可以用=就是捕捉父作用域向上的变量,&是捕捉父作用域向上的变量别名。(向上就是在捕捉列表语句前面的所有变量)

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto add1 = [=]() { return a + b; };
	auto swap1 = [&]()
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

注意:这些可以进行混合捕捉,比如对父作用域向上的变量进行传值捕捉,对于某一个或者是某些进行引用捕捉。

lambda的底层

#include
using namespace std;
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);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);
	return 0;
}

C++11常用的一部分新特性_第39张图片
C++11常用的一部分新特性_第40张图片
第一个是仿函数的反汇编,第二个是lambda表达式的反汇编,也就是说本质都是一样的调用仿函数。
并且lambda表达式的类型名字也很繁琐。

包装器

function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板,也是一个包装器。

#include
using namespace std;
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;
	}
};
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;
}

C++11常用的一部分新特性_第41张图片
这里实例化的三分不同的函数,有没有什么办法让他不生成这么多的函数。

#include
#include
using namespace std;
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
int main()
{
	function<int(int, int)> f1;//第一个int是返回值,括号里面的是参数
	f1 = f;//封装到f1中
	cout << f1(1, 2) << endl;
	function<int(int, int)> f2(f);//这种方法也可以将f封装到f2中
	cout << f2(1, 2) << endl;
	function<int(int, int)> f3 = Functor();
	cout << f3(1, 2) << endl;
	/*function f4(Functor());//这里不可以,因为编译器会识别成为函数指针
	cout << f4(1, 2) << endl;*/
	function<int(int, int)> f5 = [](const int a, const int b){return a + b; };
	cout << f5(1, 2) << endl;
}

C++11常用的一部分新特性_第42张图片
类中的成员函数也是可以包装的,但是要注意:

#include
#include
using namespace std;
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	int plusd(int a, int b)
	{
		return a + b;
	}
};
int main()
{
	//这里存入的是函数指针
	function<int(int, int)> f1 = &Plus::plusi;//静态成员函数可以不加&
	cout << f1(1, 2) << endl;
	function<int(Plus, int, int)> f2 = &Plus::plusd;//非静态成员函数必须加&,这里还要加一个参数,因为传参还有一个this指针
	cout << f2(Plus(), 1, 2) << endl;//这里是传进去一个Plus类型的对象,其实就是利用这个对象调用该成员函数而已
}

C++11常用的一部分新特性_第43张图片
其实包装器就是对于可调用对象类型的大统一。
那么使用的场景呢?
力扣:逆波兰表达式

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opMap=
        {
            {"+",[](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;}}
        };//这里就是统一了类型
        for(auto& e:tokens)//在map中查找符号
        {
            if(opMap.count(e))
            {
                int a = st.top();
                st.pop();
                int b = st.top();
                st.pop();

                st.push(opMap[e](b, a));//找到之后就将栈中的两个值通过map中储存的包装器中的lamber表达式进行运算,这里要注意数的顺序,先去取出来的在左边,后取出来的在右边
            }
            else
            {
                st.push(stoi(e));
            }
        }
        return st.top();
    }
};

bind

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

// 原型如下:
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);

举例:

#include
#include 
using namespace std;
int Plus(int a, int b)
{
	return a - b;
}
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一,二个参数指定
	function<int(int, int)> func1 = bind(Plus, placeholders::_1,placeholders::_2);//placeholders是占位对象
	cout << func1(1, 2) << endl;
	//_1代表本来的第一个参数,_2代表本来的第二个参数
	//这里调参数
	function<int(int, int)> func3 = bind(Plus, placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	return 0;
}

C++11常用的一部分新特性_第44张图片
那么实际的作用在哪里呢?
比如包装器包装的是类的成员函数,传参的时候第一个总是类的匿名对象,写起来很麻烦。

#include
#include 
using namespace std;
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	function<int(int, int)> func1 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//这里本来是三个参数,但是第一个参数已经被绑定了,包装器的参数也不用写三个了,这里也不用传三个参数了
	return 0;
}

C++11常用的一部分新特性_第45张图片

你可能感兴趣的:(笔记,C++,c++,算法,数据结构)