C++11简单介绍

最新推荐文章于 2024-04-25 20:49:52 发布
最新推荐文章于 2024-04-25 20:49:52 发布
阅读量2.6k 收藏 17
点赞数 7
分类专栏： C++日常笔记 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sakeww/article/details/125143508
版权

目录

1.列表初始化

{}

//多参数
struct Point
{
	int _x;
	int _y;

	Point(int x,int y)
		:_x(x)
		,_y(y)
	{
		cout << "Point(int x,int y)" << endl;
	}
};

class A
{
public:
	//explicit A(int a)//不让他进行隐式类型转化
	//	:_a(a)
	//{}

	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

int main()
{
	Point p={ 1,2 };
	int a = 1;
	int b = { 2 };
	int c{ 3 };
	int array1[]{ 1,2,3,4 };
	int array2[4]{ 0 };
	Point pp{ 3,4 };

	//C++98需要先new，然后再初始化
	int* ptr1 = new int[5];
	//C++11
	int* ptr2 = new int[5]{ 1,2,3 };//1,2,3,0,0
	Point* ptr2 = new Point[2]{ {1,1},{2,2} };
	//Point* ptr3=new Point[2{1,1,1,2};//这样不行，可以编译通过，但是达不到目的
	//new是C++的特性，如果需要支持那么需要自己提供构造函数

	A aa1(1);
	A aa2 = 2;//会发生隐式类型转化

	//隐式类型转化支持
	string s1("hello");
	string s2 = "world";
	vector<string> v;
	v.push_back(s1);
	v.push_back("sakeww");

	return 0;
}

initializer_list

引入：

int main()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	vector<int> v2 = { 1,2,3,4 }; 
	v2={2,3,6};//重新初始化成2，3，6。

	initializer_list<int> lt1 = { 1,2,3,4,5,6,7 };
	vector<int> v3 = lt1;

	list<int> lt2 = { 1,2,3,4,5,6 };
	pair<string, string> pr("mid", "中间");
	map<string, string> mss = { {"left","左边"},pr,make_pair("right","右边")};

	return 0;
}

这里有一份我们自己实现的list代码，只不过这个代码不支持：initializer_list，可以用它来看效果。
链接: List的模拟实现和实现中遇见的一些问题C++

	void test1()
	{
		list<int> lt = { 1,2,3,4 };
		for (auto e : lt)
		{
			cout << e << endl;
		}
		cout << endl;
	}

在这里插入图片描述
增添：

		list(initializer_list<T> ilt)
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;

			for (auto e : ilt)
			{
				push_back(e);
			}
		}

或者

		list(initializer_list<T> ilt)
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
			
			list<T> temp(ilt.begin(), ilt.end());
			std::swap(_head, temp._head);
		}

或者

		list(initializer_list<T> ilt)
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;

			typename initializer_list<T>::iterator it = ilt.begin();
			while (it != ilt.end())
			{
				push_back(*it);
				++it;
			}
		}

声明

auto

会根据右边的值推到左边的对象的类型，（自动推导）
便利用处：
1.迭代器
2.范围for，不要形成思维定势，范围for只能用auto

decltype

int main()
{
	int x = 1;
	double y = 0.2;
	cout << typeid(x).name() << endl;//int

	decltype(x) z = 3;
	cout << typeid(z).name() << endl;//int

	decltype(x * y) xy;
	cout << typeid(x*y).name() << endl;//double

	decltype(&x) p;
	cout << typeid(p).name() << endl;//int*
	return 0;
}

用处：
vector<这里不能用auto>
可以用decltype

nullptr

主要解决
C++将空定义为0，和特殊情况下有点混

STL中的一些变化

1.新增了一些容器

array，

固定大小的数组，静态数组，
array价值：
1.支持迭代器，更好兼容STL容器的玩法
2.对于越界的检查（最核心的地方）
C/C++对于越界的检查是一种抽查的行为（在OJ上面跑不过，在vs可以过）

unorganized_XXX,

forward_list

单向链表
支持头插头删，不支持尾插尾删，
不支持在当前位置前面插入和当前位置的删除，支持在当前位置后面插入和删除当前位置后面的
价值：每个节点省了一个指针

对已有容器，增加一些接口，

1.列表初始化initializer，
2.类似cbegin，cend
3.移动构造，移动赋值
4.右值引用版本的插入接口

右值引用和移动语义

左值引用

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

价值：
减少拷贝，做一些输出性参数，修改返回值

//可以取地址对象，就是左值
int main()
{
	int a = 10;
	int& r1 = a;
	int* p = &a;
	int& r2 = *p;

	const int b = 10;
	const int& r3 = b;
	int b=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);

	return 0;
}

交叉引用问题

//交叉引用
//左值引用能否引用右值
//右值引用能否引用左值
int main()
{
	//右值
	double x = 1.1, y = 2.2;
	10;
	x + y;
	fmin(x, y);

	//以下*p，b，c都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;

	//左值引用能否引用右值->不能直接引用
	//int& r1 = 10;
	//double& r2 = x + y;
	//double& r3 = fmin(x, y);
	//但是可以加const
	const int& r1 = 10;
	const double& r2 = x + y;
	const double& r3 = fmin(x, y); 

	//右值引用能否引用左值->不能，
	//int*&& rr1 = p;
	//int&& rr2 = *p;
	//int&& rr3 = b;
	//int&& rr4 = c;
	//但是右值引用可以引用move以后左值
	int*&& rr1 = move(p);
	int&& rr2 = move(*p);
	int&& rr3 = move(b);
	const int&& rr4 = move(c);//不行

	return 0;
}

举个栗子，左值引用需要引用右值
void push_back(const T& x)
我们传递的可能是 左值，也可能是右值

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

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	double&& rr2 = x + y;
	const double&& rr2 = x + y;

	cout << &rr1 << endl;
	cout << &rr2 << endl;
	//都可以取地址

	rr1 = 10;//还可以赋值
	rr2 = 3;
	//rr3不能被赋值
	return 0;
}

左值引用的使用场景

右值引用的产生是要弥补左值引用的不足
引出问题：

namespace sakeww
{
	class string
	{
	public:

		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)
			, _size(0)
			, _capacity(0)
		{
			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()
		{
			//cout << "~string()" << endl;

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

		//只能使用传值返回
		string operator+(char ch)
		{
			string tmp(*this);
			push_back(ch);

			return tmp;
		}
		const char* c_str() const
		{
			return _str;
		}

	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

//场景1
//左值引用做参数，基本完美解决所有问题
void func1(sakeww::string s)
{}

void func2(const sakeww::string& s)
{}

// 场景2
// 左值引用做返回值，只能解决部分问题
// string& operator+=(char ch) 解决了
// string operator+(char ch)   没有解决

int main()
{
	sakeww::string str("hello world");
	func1(str);
	func2(str);

	str += '!';
	str + '!';//会多两次深拷贝
	return 0;
}

解决问题：

namespace sakeww
{
	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)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str);
			swap(tmp);
		}
//
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 资源转移" << endl;

			this->swap(s);
		}
//

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);

			return *this;
		}

		~string()
		{
			cout << "~string()" << endl;

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

		string operator+(char ch)
		{
			string tmp(*this);
			push_back(ch);

			return tmp;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

// 场景1
// 左值引用做参数，基本完美的解决所有问题
void func1(sakeww::string s)
{}

void func2(const sakeww::string& s)
{}

// 场景2
// 左值引用做返回值，只能解决部分问题
// string& operator+=(char ch) 解决了
// string operator+(char ch)   没有解决

// 右值引用，如何解决operator+传值返回存在拷贝的问题呢？
// C++11 将右值分为：纯右值，将亡值
sakeww::string func3()
{
	sakeww::string str("hello world!");

	return str;
}

int main()
{
	sakeww::string str("hello world");

	func3();

	return 0;
}

右值引用解决问题

无论是自己写的还是库里面的都是这样的
在这里插入图片描述
右值引用延长了对象的生命周期
右值对象并没有延长了对象的生命周期
右值引用只不过是作为一个属性匹配上移动构造，把资源转移走了，

完美转发

模板中的&& 万能引用（引入）

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 左值引用

右值引用之后，全部变成了左值

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; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
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 右值引用

新的类功能

强制生成默认函数的关键字default：

类成员变量初始化：C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化

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

class Person
{
public:
	Person() = default;
	Person(const char* name, int age)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
private:
	sakeww::string _name;
	int _age=0;
};
int main()
{
	Person s1;
	return 0;
}

禁止生成默认函数的关键字delete:

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已（但是这样只能显示外界访问类里面的，不能限制类里面的函数访问这个默认函数），这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

引入：
有一种设计模式叫做单例模式，
要求：只能生成一个唯一的对象，不允许拷贝，不允许赋值

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p) = delete;
private:
	sakeww::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	return 0;
}

移动构造函数和移动赋值运算符重载

默认成员函数
原来C++类中，有6个默认成员函数：

  1. 构造函数
  2. 析构函数
  3. 拷贝构造函数
  4. 拷贝赋值重载
  5. 取地址重载
  6. const 取地址重载
    最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。

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

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

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

可变参数模板

可变参数模板


//template <class ...Args>
//void ShowList(Args... args)
//{
//  打印个数
//	cout << sizeof...(args) << endl;
//	cout << sizeof...(Args) << endl;
//}
//int main()
//{
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}

//递归函数方式展开参数包
//template<class T>
//void ShowList(T t)
//{
//	cout << t << endl;
//}
//template <class T, class ...Args>
//void ShowList(T val, Args... args)
//{
//	cout << typeid(val).name() <<":"<<val<< endl;
//	ShowList(args...);
//}
//int main()
//{ 
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}

//逗号表达式展开参数包
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;
}

//改进版本
template <class T>
int PrintArg(T t)
{
	cout << t << " ";
	return 0;
}

template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { PrintArg(args)... };
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

emplace

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' });
	return 0;
}

lambda表达式

引入：

可调用对象：
1.函数指针，qsort--------------C
2.仿函数，sort------------------C++98

排序的数据有很多项，我们需要根据其中一种数据进行排序（C++98）

#include<algorithm>
//lambda
struct Goods
{
	string _name;//名字
	double _price;//价格
	Goods(const char* str, double price)
		:_name(str)
		,_price(price)
	{}
};
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;
	}
};
struct ComparePriceLess;
struct ComparePriceGreater;

int main()
{
	vector<Goods> v = { { "苹果", 2.1 }, { "香蕉", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
	return 0;
}

需要写很多仿函数

lambda------C++11

匿名函数

struct Goods
{
	string _name;//名字
	double _price;//价格
	Goods(const char* str, double price)
		:_name(str)
		,_price(price)
	{}
};
int main()
{
	Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝",1.5} };
	sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& l, const Goods& r)->bool
		{
			return l._price < r._price;
		});
	return 0;
}
  1. [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
  2. (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
  3. mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
  4. ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导。
  5. {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
  6. 注意： 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

捕捉列表

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(成员函数中包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(成员函数中包括this

普通实现交换两个数

int main()
{
	int a = 1, b = 2;
	auto swap1 = [](int a, int b)->void {int c = a; a = b; b = c; };
	
	swap(a, b);
	cout << a << " " << b << endl;

	swap1(a, b);
	cout << a << " " << b << endl;

	cout << " -------------------------" << endl;
	auto swap2 = [](int& a, int& b)->void {int c = a; a = b; b = c; };

	swap2(a, b);
	cout << a << " " << b << endl;
	return 0;
}

使用捕捉

int main()
{
	int a = 1, b = 2;
	auto swap1 = [&a, &b]()mutable{int c = a; a = b; b = c; };
	swap1();
	cout << a << " " << b << endl;

	auto swap2 = [=, &b](int a)mutable {int c = a; a = b; b = c; };
	swap2(a);
	cout << a << " " << b << endl;
	return 0;
}

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

解决引入的那个问题：

struct Goods
{
	string _name;//名字
	double _price;//价格
	Goods(const char* str, double price)
		:_name(str)
		, _price(price)
	{}
};

int main()
{
	vector<Goods> gds = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝",1.5} };
	auto compare1 = [](const Goods& g1, const Goods& g2) {
		return g1._price < g2._price;
	};
	
	sort(gds.begin(), gds.end(), compare1);
	sort(gds.begin(), gds.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price;});
	return 0;
}

lambda 类型

int main()
{
	auto swap1 = []() {};

	cout << typeid(swap1).name() << endl;
	return 0;
}
class <lambda_e135540ea225bb5a54d182ae61f85d7a>

lambda的类型是：class
class的名称是：lambda_+字符串
这个字符串是uid，
uid是有人通过算法生成的一段字符串，在当前程序中不会重复

lambda本质

仿函数

底层原理：
被处理成一个匿名仿函数，lambda+uid的一个反函数类

包装器

引入 function：

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

在这里插入图片描述
通过上面的程序验证，我们会发现useF函数模板实例化了三份。

解决 引入function

#include <functional>
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()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double { return d /
		4; };
	cout << useF(func3, 11.11) << endl;
	return 0;
}

在这里插入图片描述

使用 function：

#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()
{
	// 函数名(函数指针)
	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;
	return 0;
}

应用：150. 逆波兰表达式求值

链接: 150. 逆波兰表达式求值

常规写法：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s;

        for(int i = 0;i<tokens.size();i++)
        {
            string& str = tokens[i];

            if(!(str=="+" || str=="-"||str=="*"||str=="/"))
                s.push(stoi(str));
            else
            {
                int right = s.top();
                s.pop();
                int left = s.top();
                s.pop();

                if(str=="+")
                    s.push(right+left);
                else if(str == "-")
                    s.push(left-right);
                else if(str == "*")
                    s.push(left*right);
                else 
                    s.push(left/right);
            }
        }
        return s.top();
    }
};

运用包装器之后：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s;
        map<string, function<int(int, int)>> opFuncMap =
            {
            { "+", [](int i, int j) {return i + j; } },
            { "-", [](int i, int j) {return i - j; } },
            { "*", [](int i, int j) {return i * j; } },
            { "/", [](int i, int j) {return i / j; } }
            };

        for(int i = 0;i<tokens.size();i++)
        {
            string& str = tokens[i];

            if(!(str=="+" || str=="-"||str=="*"||str=="/"))
                s.push(stoi(str));
            else
            {
                int right = s.top();
                s.pop();
                int left = s.top();
                s.pop();

                s.push(opFuncMap[str](left, right));
            }
        }
        return s.top();
    }
};

bind

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

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

int main()
{
	function<int(int, int)> f1 = SubFunc;
	cout << f1(10, 3) << endl;

	function<int(int, int)> f2 = bind(SubFunc, placeholders::_1, placeholders::_2);
	cout << f2(10, 3) << endl;

	// 通过bind调整参数顺序
	function<int(int, int)> f3 = bind(SubFunc, placeholders::_2, placeholders::_1);
	cout << f3(10, 3) << endl;

	// 通过bind调整参数个数
	function<int(Sub, int, int)> f4 = &Sub::sub;
	cout << f4(Sub(), 10, 3) << endl;

	function<int(int, int)> f5 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << f5(10, 3) << endl;

	function<int(int)> f6 = bind(&Sub::sub, Sub(), 100, placeholders::_1);
	cout << f6(10) << endl;
	
	auto f7 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << f7(10, 3) << endl;

	return 0;
}

线程库

优势：

  1. C++11 的thread库可以跨平台，运用条件编译，先判断是那个系统，然后调用对应的库
  2. 面向对象的方式写的

1.问题描述：两个线程对同一个变量x++

在这里插入图片描述

解决问题（加锁），讨论问题（里外加锁问题）

在这里插入图片描述

在这里插入图片描述
加锁加在外面，t1和t2就变成串行运行
加锁加在里面，t1和t2能交替并行运行
理论而言，加在里面更好，但是这个题的++x太快，所以为了 安全 只能加在外面
也就是说当++x处的内容比较多时，加在里面更好

改进加在里面的锁：如果要加锁在里面，不要使用互斥锁，使用自旋锁更好
C++11 没有自旋锁

改进讨论问题 原子操作

2.问题描述：thread可执行函数对象参数不能是左值引用

void func(int& x)
{
	cout << &x << endl;
	x += 10;
}
int main()
{
	int n = 1;
	cout << &n << endl;
	thread t1(func, n);
	t1.join();
	cout << n << endl;
	return 0;
}

vs2013：
在这里插入图片描述
vs2019：
在这里插入图片描述
我们想象中的结果：
在这里插入图片描述
问题解释：
这是vs2013支持C++11的bug

解决方案一：采用指针

在这里插入图片描述

解决方案二：std::ref()

在这里插入图片描述

3.lock_guard与unique_lock

问题引入：

vs2013下
在这里插入图片描述

vs2019下：
在这里插入图片描述
即这段代码存现线程安全问题， 会出现交替打印的情况，两个线程同时插入，会出现覆盖的情况

解决方案一：加锁

void func(vector<int>& v, int n, int j, mutex& mtx)
{
	for (int i = 0; i < n; i++)
	{
		mtx.lock();
		v.push_back(i + j);
		mtx.unlock();
	}
}

int main()
{
	vector<int> v;
	mutex mtx;
	thread t1(func, std::ref(v), 10000, 100, std::ref(mtx));
	thread t2(func, std::ref(v), 10000, 200, std::ref(mtx));
	t1.join();
	t2.join();

	//for (auto e : v)
	//{
	//	cout << e << " ";
	//}
	//cout << endl;
	cout << v.size() << endl;
	return 0;
}

出现问题：加锁和解锁的过程中，中间代码出现问题该如何？

解决（解决方案一引申出的问题）：

初步解决：
void func(vector<int>& v, int n, int j, mutex& mtx)
{
	try {
		for (int i = 0; i < n; i++)
		{
			mtx.lock();
			v.push_back(i + j);
			mtx.unlock();
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
		mtx.unlock();
	}

}

int main()
{
	vector<int> v;
	mutex mtx;
	thread t1, t2;
	try {
		t1 = thread(func, std::ref(v), 10000, 100, std::ref(mtx));
		t2 = thread(func, std::ref(v), 10000, 200, std::ref(mtx));
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	t1.join();
	t2.join();
	//for (auto e : v)
	//{
	//	cout << e << " ";
	//}
	//cout << endl;
	cout << v.size() << endl;
	return 0;
}

延伸问题：当加锁中间的代码出现问题的时候，锁可以用try catch回收，但是如果中间的 new delete出现问题呢？

使用lock_guard 和 unique_guard解决问题

手写 lock_guard


template<class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lock)
		:_lock(lock)
	{
		_lock.lock();
	}
	~LockGuard()
	{
		_lock.unlock();
	}
private:
	Lock& _lock;
};

void func(vector<int>& v, int n, int j, mutex& mtx)
{
	try {
		for (int i = 0; i < n; i++)
		{
			LockGuard<mutex> lgm(mtx);
			v.push_back(i + j);

			if (j == 1000 && i == 200)
				throw bad_alloc();
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
		mtx.unlock();
	}

}

int main()
{
	vector<int> v;
	mutex mtx;
	thread t1, t2;
	try {
		t1 = thread(func, std::ref(v), 10000, 100, std::ref(mtx));
		t2 = thread(func, std::ref(v), 10000, 200, std::ref(mtx));
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	t1.join();
	t2.join();
	//for (auto e : v)
	//{
	//	cout << e << " ";
	//}
	//cout << endl;
	cout << v.size() << endl;
	return 0;
}

调用库函数lock_guard

void func(vector<int>& v, int n, int j, mutex& mtx)
{
	try {
		for (int i = 0; i < n; i++)
		{
			lock_guard<mutex> lock(mtx);
			v.push_back(i + j);

			if (j == 1000 && i == 200)
				throw bad_alloc();
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

}

int main()
{
	vector<int> v;
	mutex mtx;
	thread t1, t2;
	try {
		t1 = thread(func, std::ref(v), 10000, 100, std::ref(mtx));
		t2 = thread(func, std::ref(v), 10000, 200, std::ref(mtx));
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	t1.join();
	t2.join();
	//for (auto e : v)
	//{
	//	cout << e << " ";
	//}
	//cout << endl;
	cout << v.size() << endl;
	return 0;
}

unique_guard 也可以达到相同的目的
lock_guard 只是加锁和解锁
unique_guarf 在加锁的过程，也可以进行一些其他操作
例如：
中途解一下锁，然后去执行一些别的事情，然后再把锁加回来

4.支持两个线程交替打印，一个打印奇数，一个打印偶数

错误代码展示：

（这段代码看起来没什么问题，在vs2013下面是正确的，但是在vs2019就会出现问题，并且这段代码本身就有问题）

int main()
{
	int n = 100;
	int i = 0;
	mutex mtx;

	//t1 打印偶数
	thread t1([n,&i,&mtx] {
		while (i < n)
		{
			unique_lock<mutex> lock(mtx);
			cout << this_thread::get_id() << ":" << i << endl;
			++i;
		}
	});

	//t2 打印奇数
	thread t2([n,&i,&mtx] {
		while (i < n)
		{
			unique_lock<mutex> lock(mtx);
			cout << this_thread::get_id() << ":" << i << endl;
			++i;
		}
	});

	t1.join();
	t2.join();
	return 0;
}

错误分析：
因为时间片的原因，t1在执行一次加锁解锁的时候没有用一个时间片的时间，那么他会接着继续执行加锁和解锁并打印

解决：


#include<condition_variable>
int main()
{
	mutex mtx;
	condition_variable c;
	int n = 100;
	bool flag = true;
	thread t1([&]() {
		int i = 0;
		while (i < n)
		{
			unique_lock<mutex> lock(mtx);
			//最开始flag=true,那么这里将会首先运行
			c.wait(lock, [&flag]()->bool {return flag; });
			cout << this_thread::get_id() << ": " << i << endl;
			flag = false;
			i += 2; // 偶数
			c.notify_one();
		}
		});
	thread t2([&]() {
		int j = 1;
		while (j < n)
		{
			unique_lock<mutex> lock(mtx);
			c.wait(lock, [&flag]()->bool {return !flag; });
			cout << this_thread::get_id() << ": " << j << endl;
			j += 2; // 奇数
			flag = true;
			c.notify_one();
		}
		});
	t1.join();
	t2.join();
	return 0;
}
sakeww
关注
  • 7
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
C++11新特性
xjp_xujiping的博客
07-17 7652
什么是C++11 C++11是曾经被叫做C++0x，是对目前C++语言的扩展和修正，C++11不仅包含核心语言的新机能，而且扩展了C++的标准程序库（STL），并入了大部分的C++ Technical Report 1（TR1）程序库(数学的特殊函数除外)。 C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进。 本文将对C++11的以上新特性进行简单的讲解，以便大家能够快速了解到C++11对C++的易用性方面起到的巨大作用。 C++11
【C++】c++11学习-常用特性总结
QiHai的博客
11-24 1902
C++ - c++11新增实用特性笔记记录！
c++11详解
最新发布
huajiahhhh的博客
04-25 869
的类型使用初始化列表, 可以加。
C++ 11 介绍 —— 基础概念
weixin_30654419的博客
08-02 265
C++的基本目的是为了兼容C，因此C++11是基于C99的（ISO/IEC 9899:1999），C++主要是在其基础上扩展了一些特性，这包括基础数据类型（bool）、类（class）、模板（template）、异常（exception）、名字空间（namespace）、操作符重载（operator +）、函数名重载（function name mangle）、引用（&）、自由存储管理操作...
c++11 你需要知道这些就够了
tangliguantou的专栏
01-20 2万+
c++11新特性 举着火把寻找电灯 今天我就权当抛砖引玉，如有不解大家一起探讨。有部分内容是引用自互联网上的内容，如有问题请联系我。 T&& 右值引用 std::move 右值引用出现之前我们只能用const引用来关联临时对象（右值）所以我们不能修临时对象的内容，右值引用的出现就让我们可以取得临时对象的控制权，终于可以修改临时对象了！ int main()
C++ ：C++11特性(了解)
du_lijun的博客
07-24 356
1.什么是C++11 C++11是曾经被叫做C++0x，是对目前C++语言的扩展和修正，C++11不仅包含核心语言的新机能，而且扩展了C++的标准程序库（STL），并入了大部分的C++ Technical Report 1（TR1）程序库(数学的特殊函数除外)。C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进。 C++11相对于C+...
C++11特性简单介绍
08-31
C++11基本点整理介绍，1、auto，2、decltype，3、尾置返回值类型，4、右尖括号特性 ，5、类内初始化 6、初始化列表 7、统一初始化 8、委托构造函数 9、override和final指示符 10、区间迭代
C++11的新特性简单汇总介绍 (一)
09-02
C++11是C++语言的一个重要更新，它引入了许多新特性和改进，极大地提升了C++的易用性和效率。以下是一些主要的C++11新特性详解： 1. **Lambda表达式**： Lambda表达式使得在C++中可以方便地创建匿名函数，即可以...
完整的诠释了C++ 11的标准
02-02
从最初的代号 C++0x 到最终的名称 C++11，C++ 的第二个真正意义上的标准姗姗来迟。 可以想象，这个迟来的标准...度对所有的 C++11 新特性进行分类，并依据这种分类对一些特性进行简单的介绍，从而一览 C++11 的全景。
高速上手 C++11/14
03-21
简单介绍了c++11/14的新功能。 通过这本书，大家可以快速了解c++11/14.
深入理解C++11-C++11新特性解析与应用
08-27
深入理解C++11-C++11新特性解析与应用, 文件小而清晰,
C++11 新特性简介
06-11 131
1.auto auto是旧关键字，在C++11之前，auto用来声明自动变量，表明变量存储在栈，很少使用。在C++11中被赋予了新的含义和作用，用于类型推断。 auto关键字主要有两种用途：一是在变量定义时根据初始化表达式自动推断该变量的类型，二是在声明或定义函数时作为函数返回值的占位符，此时需要与关键字decltype连用。 1.1用法示例 （1）auto用于推断变量类型示例。 aut...
深入理解C++11
技术栈
08-17 1万+
第2章 保证稳定性和兼容性 finaloverride 控制 局部和匿名类型作模板实参 第3章 通用为本专用为末 继承构造函数 委派构造函数 右值引用移动语义和完美转发 移动语义 右值和左值的区别 stdmove 强制转化为右值 完美转发 列表初始化 初始化列表 POD类型 模板别名 第4章 新手易学老兵易用 auto类型推导 　decltype decltype四规则 追踪返回类型 第5章 提高类
c++11新特性总结
u010246947的专栏
09-03 1万+
1、类型与变量相关 1.1、nullptr： 取代了NULL，专用于空指针 1.2、constexpr： 近似const, 可以修饰变量，也可以修饰函数， 修饰变量如： const int global = 100; int main () { int temp = 100； constexpr int a = 1; //right constexpr int b
Ｃ++学习总结11--类和对象，类的定义和实例化
RedDrn的博客
12-15 959
小记：静默如初，安之若素 1. 类和对象 1. 什么是对象 万物皆对象，任何一种事物都可以看做是对象。 2. 如何描述对象 通过对象的属性（名词，数量词，形容词）和行为（动词）来描述对象。 eg：描述冰箱对象 属性：品牌，容量，颜色，功耗 行为：装东西，冷冻，冷藏 3. 面向对象的程序设计 对自然世界中对象的描述引入到编程实践的方法，这种方法称为“数据抽象”，即在描...
VS2019，C++11自定义类
weixin_44806233的博客
02-19 2262
在VS2019中，自定义类使用时，头文件需加.h 不然会报错
C++11 using定义类型别名、模板别名
xupeng1644的博客
02-26 4180
在C++98/03里，我们可以通过typedef 关键字定义一个类型的别名，比如 typedef unsigned int uint_t;在这里我们定义了unsigned int类型的别名和uint_t，在以后需要使用unsigned int的时候我们都可以用uint_t替换，但是uint_t仅仅是作为unsigned int的一个别名，如下的定义是不合法的： typedef unsigned i...
C++11常用新特性快速一览
热门推荐
jiange_zh的博客
02-23 12万+
最近工作中，遇到一些问题，使用C++11实现起来会更加方便，而线上的生产环境还不支持C++11，于是决定新年开工后，在组内把C++11推广开来，整理以下文档，方便自己查阅，也方便同事快速上手。（对于异步编程十分实用的Future/Promise以及智能指针等，将不做整理介绍，组内使用的框架已经支持并广泛使用了，用的是自己公司参考boost实现的版本） 1. nullptr nullptr ...
c++11标准 书籍推荐
07-13
这本书适合11岁的孩子阅读，因为它不仅故事简单易懂，而且包含着很多深刻的哲理。通过阅读《小王子》，孩子们可以学习到一些关于友谊、爱与责任的道理，同时也可以从中对自己和世界有更多的思考。 此外，《小王子》...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值