【C++】C++11

目录

  • [1. C++简介](#1. C++简介)
  • [2. 统一的列表初始化](#2. 统一的列表初始化)
    • [2.1. { }初始化](#2.1. { }初始化)
    • [2.2. std: :initializer_list](#2.2. std: :initializer_list)
  • [3. 声明](#3. 声明)
    • [3.1. auto](#3.1. auto)
    • [3.2. decltype](#3.2. decltype)
    • [3.3. nullptr](#3.3. nullptr)
  • [4. 范围for循环](#4. 范围for循环)
  • [5. STL的变化](#5. STL的变化)
  • [6. 右值引用和移动语义](#6. 右值引用和移动语义)
    • [6.1. 左值引用和右值引用比较](#6.1. 左值引用和右值引用比较)
    • [6.2. 右值引用使用场景和意义](#6.2. 右值引用使用场景和意义)
      • [6.2.1. 移动构造](#6.2.1. 移动构造)
      • [6.2.2. 移动赋值](#6.2.2. 移动赋值)
    • [6.3. 万能引用和完美转发](#6.3. 万能引用和完美转发)
  • [7. 默认移动构造、默认移动赋值](#7. 默认移动构造、默认移动赋值)
    • [7.1. default和delete](#7.1. default和delete)
  • [8. 可变参数模板](#8. 可变参数模板)
    • [8.1. 递归解析参数包、展开参数包](#8.1. 递归解析参数包、展开参数包)
    • [8.2. emplace相关的接口函数](#8.2. emplace相关的接口函数)
  • [9. lambda表达式](#9. lambda表达式)
    • [9.1. lambda表达式语法](#9.1. lambda表达式语法)
    • [9.2. lambada表达式](#9.2. lambada表达式)
    • [9.3. lambda表达式的底层](#9.3. lambda表达式的底层)
  • [10. 包装器](#10. 包装器)
    • [10.1. function包装器](#10.1. function包装器)
    • [10.2. bind包装器](#10.2. bind包装器)

1. C++简介

  • C++11标准相比于C++98/03标准,带来了数量可观的变化,对C++03作了约600个补正修订,增加了约400个新特性,eg:final、override、unordered系列容器、default、delete等。C++11能够更好的应用系统开发和库开发,语法更加泛化和简单化、更加安全和稳定、提升开发效率,项目开发应用较多。

2. 统一的列表初始化

2.1. { }初始化

  1. 一切皆列表初始化。

  2. C++11标准,允许对变量、数组、结构体、用户自定义类型、new表达式进行同一的列表初始值设定,使用列表初始化,可添加=,也可不添加=。

cpp 复制代码
#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<string>

using namespace std;

struct Person {
	int age;
	int height;
};

class Date {
public:
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{ }

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//一切皆列表初始化,=可加、也可不加
	int a1 = { 10 };  //变量
	int a2{ 10 };

	Person p1 = { 18, 100 }; //结构体
	Person p2{ 18, 100 };

	int arr1[10] = { 1, 2, 3 };  //数组
	int arr2[10]{ 1, 2, 3 };

	//C++98、C++11都支持
	//多参数构造函数支持隐式类型转化,构造+拷贝构造,新的编译器会优化成直接构造
	Date d1 = { 2022, 1, 1 }; //用户自定义类型
	Date d2{ 2022, 1, 1 };

	//单参数构造函数支持隐式类型转化,构造+拷贝构造,新的编译器会优化成直接构造
	string s = "lala";

	//new表达式
	Date d1(2022, 2, 1);
	Date d2(2022, 4, 1);
	Date d3(2022, 3, 1);
	Date* p3 = new Date[3]{d1, d2, d3};  //拷贝构造
	Date* p4 = new Date[3]{ {2024, 4, 15}, {2024, 4, 16},{2024, 4, 17} };  //构造+拷贝构造,优化直接构造

	Date* p5 = new Date(2023, 1, 1);  //构造
	Date* p5 = new Date{ 2024, 1, 1 };   //构造+拷贝构造,优化直接构造

    //Date d5 = (2024, 2, 1);  //不支持
}

2.2. std: :initializer_list

cpp 复制代码
int main()
{
	auto il = { 1, 2, 3, 4 };
	cout << typeid(il).name() << endl;

	return 0;
}


  1. initializer_list是C++11引入的一个模板类,它允许我们用{ }初始化一个对象,和vector一样,可以表示某种特定类型值的数组,成员函数有无参构造、迭代器begin、end、size。

  2. initializer_list限制:

a.它是只读的,不能修改它的内容。

b.它是轻量级的,只存储元素指针和大小,不存储元素本身,initializer_list对象大小为8字节,只存储了两个指针,一个指针指向数组的开始,一个指针指向数组的末尾。

c.临时数组的声明周期和initializer_list对象生命周期一样。

  1. initializer_list一般是用作于构造函数的参数,STL中有不少的容器增加了std: :initializer_list作为参数的构造函数,这样初始化对象更方便,也可以作为operator=( )的参数,这样对象就可以用大括号进行赋值。
cpp 复制代码
int main()
{
    //两者都是构造+拷贝构造,编译器直接优化为直接构造
	Date d = { 2024, 4, 16 };  //参数个数是受限制的

	vector<int> v = { 1, 2, 3, 4 }; //参数个数不受限制
	for (auto& e : v)
	{
		cout << e << ' ';
	}
    cout << endl;
    
    vector<int> v1({ 1, 2, 3 });  //直接构造

	return 0;
}


cpp 复制代码
vector(initializer_list<T> il)  //initializer_list作为参数的构造函数
{
	reserve(il.size());
	for (auto& e : il)
	{
		push_back(e);
	}
}
cpp 复制代码
int main()
{
    pair<string, string> p1("sort", "排序");
    pair<string, string> p2("left", "左边");
    
    map<string, string> m1 = { p1, p2};  //initializer_list<pair>作为参数构造+拷贝构造,编译器优化为直接构造
    map<string, string> m2 = { {"right", "右边"}, {"count", "数目"} };
    	/*pair<const char*, const char*>与pair<const string, string>是不同的类型,需要先调用pair构造(在pair类中套了其他模板,
    	用于支持不同类型pair的构造)。其次initializer_list<pair>作为参数构造+拷贝构造,编译器优化为直接构造*/
	return 0;
}
cpp 复制代码
template<class T1, class T2>
struct pair {
	pair(const T1& first, const T2& second) 
		:_first(first)
		,_second(second)
	{ }

	template<class U, class V>   //pair允许在内部套其他大的模板,达到用不同类型的pair去构造其他类型的piar
	pair(pair<U, V>& p)
		:_first(p._first)
	    ,_second(p._second)
	{ }

	T1 _first;
	T2 _second;
};

3. 声明

3.1. auto

  • C++98中auto是自动存储类型的说明符,表示变量是局部自动存储类型,但是在局部域定义的局部对象默认自动存储类型,所以在C++11中就摒弃了auto原来的作用,此处auto只用于实现自动类型推导,要求必须显示初始化,让编译器将定义对象的类型设置为初始值的类型。

3.2. decltype

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

cpp 复制代码
int main()
{
    const int x = 3;   
	decltype(x) y = 4;  //顶层const,const修饰变量本身,decltype会去掉const
	cout << typeid(y).name() << endl;

	const int* p = &x;
	decltype(p) a1 = nullptr;  //底层const,const修饰指针指向的内容,decltype不会去掉const
	cout << typeid(a1).name() << endl;

	return 0;
}
  • 顶层const,const修饰变量本身,decltype会去掉const。底层const,const修饰指针指向的内容,decltype不会去掉const。

  • typeid( ).name( )求变量的类型,并进行打印。

3.3. nullptr

  • 因为NULL被定义为字面量0,NULL既能表示为指针常量,又能表示为整形常量。C++11将nullptr定义为空指针。

4. 范围for循环

  • STL容器只要支持迭代器,就支持范围for,打印容器中的元素。

5. STL的变化

  1. 新的容器:unordered_map、unordered_set、单链表(forward_list)、静态数组(array)。

  2. 新接口:

a.一些无关重要的方法,eg:cbegin、cend返回const迭代器,而begin、end也可以返回const迭代器。

b.initializer_list系列的构造。

c.push、insert、emplace等增加了右值引用版本,提高了效率。

d.容器新增的移动构造、移动赋值,它们可以减少拷贝,提高效率。

6. 右值引用和移动语义

6.1. 左值引用和右值引用比较

  1. 在C语言中,左值是可以被修改的,而右值不能被修改。而C++中这样定义是不准确的。

  2. 左值是表达式,常见形态有变量、指针、指针解引用后的值、函数返回值(传引用返回)、const修饰的变量。右值是表达式,常见形态有字面常量、表达式的返回值(运算)、函数返回值(传值返回)。

  3. 左值可以被取地址,一般可以对它进行赋值,const修饰后的左值,不能给它赋值,可以出现在赋值符号的左边。右值不可以被取地址,不能对它进行修改,不可以出现在赋值符号的左边。

  4. 左值引用是给左值取别名,左值引用不能给右值取别名,但是const左值引用可以给右值取别名。右值引用是给右值取别名,右值引用不能给左值取别名,但是右值引用可以给move(左值)取别名。

  5. 引用都是取别名,不开空间存储。底层,引用是用指针实现的,左值引用是存储当前左值的地址,右值引用是将右值拷贝给栈中的一块临时空间,存储这个临时空间的地址。可以对右值引用变量取地址,也可以对它进行修改。

cpp 复制代码
int main()
{
    //左值:a、p、*p、c、传引用返回
	int a = 0;  
	int* p = new int(10);
	const int c = 6;
	fun1();

	//左值可以给左值取别名
	int* ptr = &a;

	//左值引用:给左值取别名
	int& aa = a;
	int*& pp = p;
	const int& cc = c;
	int& ret1 = fun1();

	//右值:10、运算、传值返回  注意:右值不能取地址,不能出现在左边
	10;
	a + c;
	fun2();

	//右值引用:给右值取别名
	int&& d = 10;
	int&& e = a + c;
	int&& ret2 = fun2();

    //左值引用不能给右值取别名,const左值引用可以给右值取别名
	const int& g = 10;
	//右值引用不能给左值取别名,右值引用可以给move(左值)取别名
	int&& h = move(a);
    
    return 0;
}

6.2. 右值引用使用场景和意义

6.2.1. 移动构造

cpp 复制代码
//移动构造 --- 右值(将亡值)
string(string&& s)
{
	cout << "string(string&& s)" << endl;
	swap(s);
}
  • 右值引用,移动语义:右值引用是对右值的引用,移动语义是将右值的资源直接转移给左值对象,而不需要进行开销较大的深拷贝。移动语义是C++11引入的一个新特性,它允许我们将资源从一个对象转移到另一个对象,以提高效率和性能 ------》 移动构造、移动赋值。

总结:进行深拷贝的类需要进行移动构造、移动赋值,进行浅拷贝的类不需要进行移动构造、移动赋值。

6.2.2. 移动赋值

cpp 复制代码
//移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s)" << endl;
	swap(s);
	return *this;
}

6.3. 万能引用和完美转发

  1. 万能引用:是一种既能接收左值、又能接收右值的引用,它的形式为T&&(T为模板参数),传左值,它就为左值引用、传右值,它就为右值引用,它不是C++的一个新特性,而是利用模板类型推导和引用折叠的规则来实现的功能。

  2. 引用折叠:是C++出现的新概念,用于处理引用的引用情况。在C++中,当创建一个引用的引用时,引用规则会将其中的引用消除,只保留一个单引用。& 、& -> & ;& 、&& -> & ;&& 、&& -> &&。

  3. 完美转发:forward(t), 是C++引入的新特性,在函数模板中保持参数的原属性,本身为左值,属性不变; 本身为右值(但经右值引用引用后,属性变为左值),将属性转变为右值,相当于move了一下。

  4. move:是一个函数模板,将左值属性变为右值属性。

cpp 复制代码
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; }

/*1.引用折叠:&、&&->&、&&、&&->&&  不能单纯的把下面的模板理解为右值引用的模板
* 2.万能引用:传左值,它就为左值引用、 传右值,它就为右值引用
* 3.完美转发forward<T>(t):保持属性,本身是左值,属性不变、 本身是右值(被右值引用引用后,属性为左值),转化为右值,相当于move以下
* 4.move:已知其为右值(将亡值),右值引用引用后,属性为左值,将左值属性变为右值属性*/
template<class T>  
void PerfectForward(T&& t) //万能引用
{
	Fun(forward<T>(t));  //完美转发
}

int main()
{
	int a = 10; 
	PerfectForward(a);  //左值
	PerfectForward(move(a)); //右值

	const int b = 6;  
	PerfectForward(b);  //const左值
	PerfectForward(move(b));  //const右值
	return 0;
}

7. 默认移动构造、默认移动赋值

  1. C++类有八大默认成员函数:构造函数、拷贝构造函数、拷贝赋值重载、析构函数、移动构造函数、移动赋值运算符重载、取地址重载、const取地址重载。默认成员函数就是我们不写,编译器默认生成。重要的为前6个。

  2. 默认移动构造:如果我们没有显示实现移动构造,且没有显示实现析构函数、拷贝构造、拷贝赋值重载中的任意一个,编译器就会自动生成一个默认移动构造。默认生成的移动构造构分为两部分,对于内置类型完成值拷贝、对于自定义类型,看它是否实现了移动构造,实现了就调用移动构造,没有实现,就调用拷贝构造。

  3. 默认移动赋值:如果我们没有显示实现移动赋值,且没有显示实现析构函数、拷贝构造、拷贝赋值重载中的任意一个,编译器就会自动生成一个默认移动赋值。默认生成的移动赋值分为两部分,对于内置类型完成值拷贝、对于自定义类型,看它是否实现了移动赋值,实现了就调用移动赋值,没有实现,就调用拷贝赋值。

7.1. default和delete

  1. default关键字指示编译器强制生成对应的默认函数。

  2. 限制某些默认成员函数的生成:方法一:在C++98中,将该函数设置为private,只声明不实现。原因:将函数的定义设置为private,尽管类外访问不到,但在类中可以进行访问、若只声明,设置为公有,会出现链接错误,很可能在外面别人手动帮你实现该函数的定义(函数可以在类中声明,类外定义)。 方法二:在函数的声明后加上=defaule即可。delete关键字指示编译器不生成对应函数的默认版本,被=delete修饰的函数称为删除函数。

8. 可变参数模板

cpp 复制代码
//可变参数的函数模板
template<class ...Args>  //Args是模板参数包 
void ShowList(Args ...args)  //args是函数形参数包   参数包里面函数0~N个模板参数
{   //...   }
  1. 带有省略号的称为"参数包", 它里面包含0~N(N>=0)个模板参数。Args是模板参数包 、args是函数形参数包。

  2. 我们无法直接拿到参数包args中每个参数的类型和值,语法上不支持通过args[i]来获取可变参数,因为这样是运行时解析参数。而此处是模板,是编译时解析参数。

8.1. 递归解析参数包、展开参数包

cpp 复制代码
void _ShowList()   //递归终止函数
{
	cout << endl;
}

template<class T, class ...Args>
void _ShowList(const T& val, Args ...args) 
{
	cout << val << " ";
	_ShowList(args...);
}

//拿到每个参数值和类型,编译时递归解析
template<class ...Args>
void ShowList(Args ...args)
{
	_ShowList(args...);
}


void _ShowList(const string& s)
{
	cout << s << " ";
	_ShowList();
}

//实例化以后,推演生成的过程
void _ShowList(const char& ch, string s)
{
	cout << ch << " ";
	_ShowList(s);
}

void _ShowList(const int& val, char ch, string s)
{
	cout << val << " ";
	_ShowList(ch, s);
}

void ShowList(int val, char ch, string s)
{
	_ShowList(val, ch, s);
}

int main()
{
	ShowList();
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', string("sort"));

	return 0;
}
cpp 复制代码
template <class T>
int PrintArg(T t)  
{
	cout << t << " ";
	return 0;
}

//展开函数
template <class ...Args>
void Show(Args... args)
{
	//在数组构造的过程中,展开参数包
	int arr[20] = { PrintArg(args)... };  //列表初始化,最终创建出一个元素值都为0的数组  
	cout << endl;
}

int main()
{
	Show();
	Show(10);
	Show(10, 'B');
	Show(10, 'B', string("Talent")); 

	return 0;
}
  • 在数组创建的时候,展开参数包。 { PrintArg(args)... }为列表初始化,用来初始化一个变长数组,它将会展开成(PrintArg(args1))、(PrintArg(args2) . . . (PrintArg(argsn),最终创建出一个元素值都为0的数组。

8.2. emplace相关的接口函数

  1. emplace_back、push_back都是C++标准库中的成员函数,都是在容器的尾部添加一个新元素。push_back接受一个值作为参数,并将这个值的副本添加到容器的末尾,可能会导致额外的性能开销,因为要复制整个对象。emplace_back是在容器的尾部直接构造新的元素,它使用对象的构造函数来创建对象。

  2. emplace系列,直接写插入对象参数:对于浅拷贝类的对象,减少(一次)拷贝构造,效率提高 、深拷贝类的对象,减少(一次)移动构造,效率提升不是很明显,与push_back无区别。

cpp 复制代码
void test1()
{
	//直接写插入对象参数,深拷贝类的对象,减少(一次)移动构造,效率提升不是很明显,与push_back无区别
	list<bit::string> lt1;
	bit::string s1("xxxx");
	lt1.push_back(s1);
	lt1.push_back(move(s1));

	cout << endl;
	bit::string s2("vvvvvv");
	lt1.emplace_back(s2);
	lt1.emplace_back(move(s2));

	cout << endl;
	lt1.push_back("lala");
	lt1.emplace_back("haha");  //深拷贝类的对象,有移动构造、赋值,右值
	cout << "========================================" << endl;

	list<pair<bit::string, bit::string>> lt2;
	pair<bit::string, bit::string> kv1("xxxx", "yyyy");
	lt2.push_back(kv1);
	lt2.push_back(move(kv1));
	
	cout << endl;
	pair<bit::string, bit::string> kv2("xxxx", "yyyy");
	lt2.emplace_back(kv2);
	lt2.emplace_back(move(kv2));
	
	cout << endl;
	lt2.emplace_back("xxxx", "yyyy");  //
	cout << "=============================================" << endl;
	
	//直接写插入对象参数,浅拷贝类的对象,减少(一次)拷贝构造,效率提高
	list<Date> lt3;
	Date d1(2022, 10, 2);
	lt3.push_back(d1);
	lt3.push_back(move(d1));

	cout << endl;
	Date d2(2024, 10, 1);
	lt3.emplace_back(d2);
	lt3.emplace_back(move(d2));

	cout << endl;
	lt3.emplace_back(2023, 10, 1);  //浅拷贝对象,无移动构造、赋值,右值
	cout << "=============================================" << endl;
}

int main()
{
	test1();

	return 0;
}
cpp 复制代码
template<class T>  //节点 
struct ListNode {  //struct类未用访问限定符修饰的变量为public,在类外指定类域就可以直接进行访问
	ListNode* _prev;  //带头双向循环链表
	ListNode* _next;
	T _data;

     //左值
	ListNode(const T& val = T()) //缺省值-》防止无参调用,因无默认构造函数,又显示写了构造函数,编译器会报错
		:_prev(nullptr)
		,_next(nullptr)
		,_data(val)
	{ }

	//右值
	ListNode(T&& val) 
		:_prev(nullptr)
		, _next(nullptr)
		, _data(forward<T>(val)) //右值引用引用右值,它的属性变为左值
    { }

	template<class ...Args>  //可变参数模板
	ListNode(Args&& ...args)   //万能引用+完美转发
		:_prev(nullptr)
		, _next(nullptr)
		, _data(forward<Args>(args)...) //右值引用引用右值,它的属性变为左值
	{ }
};

template<class T> //链表-带头双向循环链表,存储的元素为节点
	class list {   //class类未用访问限定符修饰的变量为private,在类外不可以访问
	public:
		typedef ListNode<T> Node; 
//左值
		void push_back(const T& val) //尾插
        {
			insert(end(), val);
		}

		//右值
		void push_back(T&& val)  
		{
			insert(end(), forward<T>(val)); //右值引用引用左值,它的属性变为左值
		}

		//尾插、直接调用构造函数
		template<class ...Args>    //可变参数模板
		void emplace_back(Args&& ...args)  //万能引用+完美转发
		{
			emplace(end(), forward<Args>(args)...);
		}
//左值
		iterator insert(iterator position, const T& val)
		{
			Node* newnode = new Node(val);
			Node* cur = position._node;  //struct中public变量访问可以 对象.变量名
			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;

			return newnode;  //有返回值,与erase匹配

		}

		//右值
		iterator insert(iterator position,T&& val)
		{
			Node* newnode = new Node(forward<T>(val)); //右值引用引用左值,它的属性变为左值
			Node* cur = position._node;  //struct中public变量访问可以 对象.变量名
			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;

			return move(newnode);  //有返回值,与erase匹配

		}

		template<class ...Args> 
		iterator emplace(iterator position, Args&& ...args)  //可变参数模板
		{
			Node* newnode = new Node(forward<Args>(args)...);  //万能引用+完美转发
			Node* cur = position._node;  //struct中public变量访问可以 对象.变量名
			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;

			return move(newnode);  //有返回值,与erase匹配

		}
}

9. lambda表达式

9.1. lambda表达式语法

lambda表达式书写格式:[capture-list] (paramerters) mutable -> return-types { statement }。

  1. 表达式各部分说明:

a. [capture-list]:捕捉列表,出现在lambda函数的开始位置,让编译器根据[ ]来判断接下来的代码是否为lambda函数,捕捉列表能够捕捉其所在作用域中的变量、静态存储期的变量(静态变量、全局变量),供lambda函数使用。捕捉列表说明什么数据能被lambda使用,以及捕捉的方式是传值还是传引用。

b. (paremerters):参数列表,与普通的参数列表一致,如果不需要参数传递,则可以连同( )一起省略。

c. mutable:默认情况下,一般lambda函数为const函数,mutablek可以取消其常量性 (捕捉列表以传值方式捕捉,被捕捉到的变量不能修改,若想要修改它,需要添加mutable),使用mutable,参数列表不能省略(即使参数为空)。

d. ->return-type:返回值类型。如果没有返回值,这部分可以省略、如果返回值类型是明确的,此时返回值也可以省略,由编译器对返回类型进行推导。

e. {statement}:函数体。在{ }内,只能使用参数、捕捉列表捕捉的变量。

注意:参数列表、返回值类型可以省略,捕捉列表、函数体不可以省略,即使为空。C++11最简单的lambda函数为[ ]{ },该lambda函数表示什么事情都不做。

  1. 捕捉列表说明:

a. 捕捉列表可以由多个捕捉项组成,以逗号分隔:当前作用域为包含lambda函数的语句块{ } 。[ val1 ]:传值捕捉变量var1、[ &val2 ]:传引用捕捉变量val2、[ & ]:传引用捕捉当前作用域内的所有变量,包括this、[ = ]:传值捕捉当前作用域内的所有变量,包括this、[ this ]:传值捕捉当前的this、[ & , n ]:传值捕捉n,传引用捕捉当前作用域的其他变量、[ =、&a , &b ]:传引用捕捉a、b,传值捕捉当前作用域的其他变量。

b.捕捉列表不允许变量重复传递,即:不允许某个变量被以相同的方式捕捉,否则编译器会报错。eg:[ = , a ]、[ & , &b ]。

c. 在块作用域以外的lambda函数捕捉列表必须为空:"在块作用域以外"是指在全局作用域定义的变量、在其它非直接封闭作用域定义的变量,如果它们具有静态存储期,即使lambda函数没有明确的捕捉列表(捕捉列表为空),lambda函数仍可以访问和使用它们。

d. lambda函数只能捕捉到当前作用域内的变量,如果捕捉了其他作用域内的变量(不具有静态存储期)、非全局变量,编译器都会报错。

e. lambda表达式之间不能相互赋值,即使lambda表达式完全相同。

cpp 复制代码
int main()
{
	//test1();

	void (*PF)();  //与lambda表达式具有相同类型的函数指针
	 
	auto f1 = [] {cout << "hello" << endl; }; 
	auto f2 = [] {cout << "hello" << endl; };
	//f1 = f2;   不允许lambda表达式之间相互赋值

	auto f3(f2);  //可以用lambda表达式进行拷贝构造, lambda对象被禁掉了构造函数
	f3();

	PF = f2;  //赋值
	PF();
	return 0;
}
  • 可以用lambda表达式进行拷贝构造, lambda对象被禁掉了构造函数。可以将lambda表达式赋值给具有相同类型的函数指针。

9.2. lambada表达式

cpp 复制代码
#include <algorithm>

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()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较,排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]));
	for (auto& e : array) cout << e << ' ';
	cout << endl;

	// 如果需要降序,需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());  //sort函数模板,传的是仿函数对象
	for (auto& e : array) cout << e << ' ';
	cout << endl;

	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());

	//lambda表达式,局部的匿名函数对象,没有类型,该函数无法直接调用,需要借助auto将其赋值给一个变量
	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; });
	return 0;
  • sort为函数模板,需要的是仿函数对象,默认情况下,仿函数为less(),按照小于的方式进行比较,升序。若需要降序,需要改变函数的比较规则,手动传仿函数greater()。

💡Tips:lambda表达式为局部的匿名函数对象,语法层无类型,其类型是编译器去在编译时根据uuid算法随机生成一个唯一的、匿名的函数对象类型。

9.3. lambda表达式的底层

  1. 仿函数:也叫做函数对象,像函数一样使用对象,在类中重载operator()运算符,创建仿函数类对象,通过对象去调用operator( )运算符。

  2. 在使用方式上, lambda与函数对象,无区别,函数对象将rate定义为成员变量,在定义对象时给初始值即可,lambda通过捕捉列表可以将rate变量捕捉到。在底层,编译器将lambda表达式处理方式,是按照函数对象的方式进行处理的,如果定义了一个lambda表达式,编译器会自动生成一个类,在类中重载了operator()运算符。类名是编译器根据uuid算法随机生成的,唯一性,匿名性。------》lambda表达式底层是仿函数。

cpp 复制代码
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 money, int year)->double {  return money * rate * year; };
	r2(10000, 2);

	//在使用方式上,lambda与函数对象,无区别,函数对象将rate定义为成员变量,在定义对象时给初始值即可,lambda通过捕捉列表可以将rate变量捕捉到
	/*在底层,编译器将lambda表达式处理方式,是按照函数对象的方式进行处理的,如果定义了一个lambda表达式,
	编译器会默认生成一个类,在类中重载了operator()运算符。类名是编译器根据uuid算法随机生成的,唯一性,匿名性*/
	return 0;
}
cpp 复制代码
int main()
{
	void (*PF)();  //与lambda表达式具有相同类型的函数指针
	 
	auto f1 = [] {cout << "hello" << endl; }; 
	auto f2 = [] {cout << "hello" << endl; };
	f1();
	f2();
	//f1 = f2;   不允许lambda表达式之间相互赋值

	auto f3(f2);  //可以用lambda表达式进行拷贝构造, lambda对象被禁掉了构造
	f3();

	PF = f2;  //赋值
	PF();
	return 0;
}

10. 包装器

10.1. function包装器

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

cpp 复制代码
// functional包装器的使用方法如下:
#include <functional>

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;
	}
};

int main()
{
	function<int(int, int)> f1 = f;  //函数指针(普通函数)
	cout << f1(3, 4) << endl;
	function<int(int, int)> f2 = Functor();  //函数对象(仿函数)
	cout << f2(1, 2) << endl;
	function<int(int, int)> f3 = &Plus::plusi; //类中的静态成员函数
	cout << f3(2, 3) << endl;
	function<double(Plus, double, double)> f4 = &Plus::plusd;  //类中的成员函数
	cout << f4(Plus(), 1.1, 2.2) << endl;
	function<double(Plus*, double, double)> f5 = &Plus::plusd;
	Plus ps;
	cout << f5(&ps, 2.2, 3.3) << endl;

	return 0;
}
  • ret = fun( x ) , 此处的fun可能是 函数指针(函数名)、仿函数对象(函数对象)、lambda表达式对象,这些都是可调用的类型,但可能会导致模板的效率低下,因为函数模板可能会实例化为多份。下面可知useF函数模板实例化了三份。
cpp 复制代码
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;
}
cpp 复制代码
int main()
{
	//function包装器,也叫做适配器,将可调用的类型封装为一个类,统一类型,解决了函数模板实例化多份的问题导致的效率低下问题
	function<double(double)> f1 = f;  //函数指针
	function<double(double)> f2 = Functor();   //函数对象
	function<double(double)> f3 = [](double d)->double {return d / 4; };  //lambda表达式
	
	useF(f1, 11.1);
	useF(f2, 11.1);
	useF(f3, 11.1);

	return 0;
}


https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/

cpp 复制代码
class Solution {  //function包装器,lambda表达式(匿名函数对象,无类型)
public:
    int evalRPN(vector<string>& tokens) {
    stack<int> st;  //栈用来存储操作数

    map<string, function<int(int, int)>> m = 
    { {"+", [](int left, int right)->int{ return left + right;} }, 
      {"-", [](int left, int right)->int{ return left - right;} },
      {"*", [](int left, int right)->int{ return left * right;} },
      {"/", [](int left, int right)->int{ return left / right;} }
    };

    for(int i = 0; i < tokens.size(); i++)
    {
        if(m.count(tokens[i])) 
        {
            int right = st.top();
            st.pop();
            int left = st.top();
            st.pop();
            st.push(m[tokens[i]](left, right)); //
        }
        else st.push(stoi(tokens[i]));
    }
    return st.top();
    }
};

10.2. bind包装器

bind包装器:定义在#include头文件中,是一个函数模板,就像函数包装器(适配器),接受一个可调用对象,生成一个新的可调用对象来"适应"原对象的参数列表。对可调用对象,调整参数:调整参数的顺序、调整参数的个数。

  1. bind的一般形式:auto newCallale = bind(callable, args_list) 。

  2. newCallable本身是一个可调用对象,args_list是一个逗号分割的参数列表,对应给定callable的参数。当我们调用newCallable时,newCallable会调用callable,并传给它args_list中的参数。

  3. args_list的参数可能包含形如_n的名字,n是个整数,这些参数是"占位符",表示newCallable的参数,它们占据了传递给newCallable参数的"位置"。数值n表示生成的可调用对象中参数的位置:_1为newCallable的第一个参数、_2为newCallable的第一个参数,以此类推。

cpp 复制代码
#include<functional>

int Sub(int a, int b)
{
	return a - b;
}

int main()
{
	auto fc1 = bind(Sub, placeholders::_1, placeholders::_2);
	cout << fc1(2, 3) << endl;
	auto fc2 = bind(Sub, placeholders::_2, placeholders::_1);
	cout << fc2(2, 3) << endl;
}


cpp 复制代码
int main()
{
	//调整参数的个数
	//bind返回值是个新的可调用对象, plusd为可调用对象,成员函数默认第一个参数为this,所以传Plus()
	function<double(double, double)> f1 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);
	cout << f1(2, 3) << endl;
	//某些参数绑死
	function<double(double, double)> f2 = bind(&Plus::plusd, Plus(), placeholders::_1, 3);
	cout << f2(2, 3) << endl;
}
相关推荐
怀澈12243 分钟前
高性能服务器模型之Reactor(单线程版本)
linux·服务器·网络·c++
chnming19871 小时前
STL关联式容器之set
开发语言·c++
带多刺的玫瑰1 小时前
Leecode刷题C语言之统计不是特殊数字的数字数量
java·c语言·算法
爱敲代码的憨仔1 小时前
《线性代数的本质》
线性代数·算法·决策树
威桑1 小时前
MinGW 与 MSVC 的区别与联系及相关特性分析
c++·mingw·msvc
熬夜学编程的小王1 小时前
【C++篇】深度解析 C++ List 容器:底层设计与实现揭秘
开发语言·数据结构·c++·stl·list
yigan_Eins1 小时前
【数论】莫比乌斯函数及其反演
c++·经验分享·算法
Mr.132 小时前
什么是 C++ 中的初始化列表?它的作用是什么?初始化列表和在构造函数体内赋值有什么区别?
开发语言·c++
阿史大杯茶2 小时前
AtCoder Beginner Contest 381(ABCDEF 题)视频讲解
数据结构·c++·算法
C++忠实粉丝2 小时前
计算机网络socket编程(3)_UDP网络编程实现简单聊天室
linux·网络·c++·网络协议·计算机网络·udp