C++11那些不为人知的特性

2301_80658289

1057人浏览 · 2025-12-17 08:43:15

2301_80658289 · 2025-12-17 08:43:15 发布

列表初始化

C++98传统的{}

C++98中数组和结构体用{}进行初始化。

//c++98{}的使用方法
struct Point
{
	int _x;
	int _y;
};
int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };
	return 0;
}

C++11中的{}

C++11想实现同意初始化方式，试图一切对象初始化皆可用{},{}初始化教列表初始化。

内置类型和自定义类型都支持，自定义类型本质是类型转换，中间会产生临时对象，最后有优化了以后变为直接构造。

这个{}初始化的过程中，可以省略掉=

C++列表初始化的本意是想实现一个大一统的初始化方式，其次在它在有些场景下带来了不少便利，如容器的insert和push，{}初始化会很方便

struct Point
{
	int _x;
	int _y;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
// ⼀切皆可⽤列表初始化，且可以不加=
int main()
{
	// C++98⽀持的
	int a1[] = { 1, 2, 3, 4, 5 };
	int a2[5] = { 0 };
	Point p = { 1, 2 };

	// C++11⽀持的
	// 内置类型⽀持
	int x1 = { 2 };

	// ⾃定义类型⽀持
	// 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象
	// 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
	// 构造➕拷贝构造  优化为{ 2025, 1, 1}直接构造d1
	// 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
	Date d1 = { 2025, 1, 1 };
	// 这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象
	const Date& d2 = { 2024, 7, 25 };

	//// 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}
	Date d3 = { 2025 };
	Date d4 = 2025;

	// 可以省略掉=
	Point p1{ 1, 2 };
	int x2{ 2 };
	Date d6{ 2024, 7, 25 };
	const Date& d7{ 2024, 7, 25 };

	// 不⽀持，只有{}初始化，才能省略=
	//Date d8 2025;
	Date d8{ 2025 };

	vector<Date> v;
	v.push_back(d1);//有名对象
	v.push_back(Date(2025, 1, 1));//匿名对象

	// ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
	v.push_back({ 2025, 1, 1 });//列表初始化 走隐式类型转换

	return 0;
	
}

C++中的std::initializer_list

上面的初始化已经很好了，但对于容器的初始化还是不太方便，比如一个vector对象，我想用N个值去构造初始化，那么我们得实现很多个构造函数才能支持

vector<int> v1={1,2,3};

vector<int> v1={1,2,3,4,5};

为了解决这个问题C++11库中提出了一个std::initializer_list的类

auto il = { 10, 20, 30 };

// the type of il is an initializer_list

这个类的本质开一个数组，将数据拷贝过来，std::initializer_list内部有两个指针分别指向数组的开始和结束。

容器支持一个std::initializer_list的构造函数，也就支持多个值构成的类型进行初始化。

STL中的容器支持多个值进行初始化，也是通过std::initializer_list的构造函数支持的。

template<class T>
class vector {
public:
	typedef T* iterator;
	vector(initializer_list<T> l)
	{
		for (auto e : l)
			push_back(e)
	}
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;
};

int main()
{
	std::initializer_list<int> mylist;
	mylist = { 10,20,30 };
	cout << sizeof(mylist) << endl;

	// 这⾥begin和end返回的值initializer_list对象中存的两个指针
	// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
	int i = 0;
	cout << mylist.begin() << endl;//两个指针的值
	cout << mylist.end() << endl;
	cout << &i << endl;

	// {}列表中可以有任意多个值
	// 这两个写法语义上还是有差别的，第⼀个v1是直接构造，
	// 第⼆个v2是构造临时对象+临时对象拷⻉v2+优化为直接构造
	vector<int> v1({ 1,2,3,4,5 });?????????????????????????????????????????????????????????????????
								  实参传给形参      
	vector<int> v2 = { 1,2,3,4,5 };
	const vector<int>& v3 = { 1,2,3,4,5 };

	// 这⾥是pair对象的{}初始化和map的initializer_list构造结合到⼀起⽤了ok
	map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };//???????????????????????????????????????????????????????????????/
  
	// initializer_list版本的赋值⽀持
	v1 = { 10,20,30,40,50 };
	return 0;
}

右值引用和移动语义

左值和右值

C++11之前学的引用就叫左值引用。无论左值引用还是右值引用，都是给对象取别名。

左值是一个表示数据的表达式（变量名或解引用的指针），一般是持久状态，存储在内存中，我们可以获取它的地址，左值可以出现在赋值符号的左右两边。定义const 修饰后的左值，不能给他赋值，但是我们可以取它的的地址。

右值也是一个数据表达式（字面值常量，表达式求值所创建的临时对象）等，右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。

左值（lvalue）储存在内存中，有明确存储地址可以取地址的对象。

右值（rvalue）提供数据值，但是不可以寻址。如：临时对象，字面量常量，存储于寄存器中的变量，左值和右值的核心区别在于能否取地址。

//左值和右值
int main()
{
	// 左值：可以取地址   持久状态   上我们开空间
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);//指针
	int b = 1;			//变量
	const int c = b;	//const 修饰的边变量
	*p = 10;			//指针的解引用
	string s("111111"); //对象
	s[0] = 'x';			//????????????????????????????????????????/函数调用表达式
	cout << &c << endl;
	cout << (void*)&s[0] << endl;
	// 右值：不能取地址
	double x = 1.1, y = 2.2;
	// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
	10;					//字面值常量
	x + y;				//表达式返回值  的临时对象  临时开空间
	fmin(x, y);			//函数返回时   产生的临时对象 （临时对象可能存在寄存器里面）
	string("11111");	//匿名对象
	//cout << &10 << endl;
	//cout << &(x+y) << endl;
	//cout << &(fmin(x, y)) << endl;
	//cout << &string("11111") << endl;
	return 0;
}

左值引用和右值引用

Type& r1 =x; Type&& rr1=y;第一个语句就是左值引用，左值应用就是给左值取别名，第二个上右值引用，右值引用就是给右值取别名。

左值引用不能直接引用右值，但是const左值引用可以引用右值。

右值引用不能直接引用左值，但是右值引用可以引用move（左值）

move是库里面的一个模板函数，本质是内部进行强制类型转换，内部还有引用折叠的事情。

template <class T> typename remove_reference<T>::type&& move (T&&

arg);

变量表达式都是左值属性，也就意味着一个右值被右值应用绑定后，右值引用变量的变量表达式的属性是左值

语法层面看，左值引用和右值引用都是取别名，不开空间。汇编层面，底层都是用指针实现的，没什么区别。底层汇编层面和上层语法表达的意义上背离的。

//左值引用和右值引用
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';

	// 左值引⽤给左值取别名
	int& r1 = b;
	int*& r2 = p;
	int& r3 = *p;
	string& r4 = s;
	char& r5 = s[0];

	double x = 1.1, y = 2.2;
	// 右值引⽤给右值取别名
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	string&& rr4 = string("11111");

	// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
	const int& rx1 = 10;
	const double& rx2 = x + y;
	const double& rx3 = fmin(x, y);
	const string& rx4 = string("11111");

	// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
	int&& rrx1 = move(b);
	int*&& rrx2 = move(p);
	int&& rrx3 = move(*p);
	string&& rrx4 = move(s);
	string&& rrx5 = (string&&)s;

	// b、r1、rr1都是变量表达式，都是左值???????????????????????????
  b move以后还是左值
	cout << &b << endl;
	cout << &r1 << endl;
	cout << &rr1 << endl;

	// 这⾥要注意的是，rr1的属性是左值，所以不能再被右值引⽤绑定，除⾮move⼀下//右值引用的属性是左值
	int& r6 = r1;
	//int&& rrx6 = rr1;
	int&& rrx6 = move(rr1);

	return 0;
}

引用延长生命周期

右值引用可用于为临时对象延长生命周期。

const左值引用也能延长临时对象的生命周期，但这些对象都无法被修改。

//引用延长生命周期
//右值引用延长临时对象的生命周期，const的左值引用也可以延长生命周期，但是这些对象无法被修改
int main()
{
	std::string s1 = "Test";
	//std::string&& r1 = s1; // 错误：不能绑定到右值
	const std::string& r2 = s1 + s1; // OK：到 const 的左值引⽤延⻓⽣存期
	// r2 += "Test"; // 错误：不能通过到 const 的引⽤修改
	std::string&& r3 = s1 + s1; // OK：右值引⽤延⻓⽣存期  s1+s1产生的临时对象的生命周期和 r3相等都是在main函数销毁时结束

	r3 += "Test"; // OK：能通过到⾮ const 的引⽤修改
	std::cout << r3 << '\n';

	return 0;
}

左值和右值的参数匹配

C++98中，通过的const左值引用作为参数的函数，那么实参传递左值和右值都可以匹配。

C++11以后，分别重载左值引用，const左值引用，右值引用作为形参F的函数，那么实参上左值会匹配F（左值引用），实参是const左值会匹配F（const 左值引用），实参是右值会匹配F（右值引用）。


//左值和右值的参数匹配
//C++98中，通过 const左值引用作为参数的函数，那么实参传递左值和右值都可以
//C++11以后，分别重载左值引⽤、const左值引⽤、右值引⽤作为形参的f函数，那么实参是左值会
//匹配f(左值引⽤)，实参是const左值会匹配f(const 左值引⽤)，实参是右值会匹配f(右值引⽤)。

void f(int& x)
{
	std::cout << "左值引⽤重载 f(" << x << ")\n";
}

void f(const int& x)
{
	std::cout << "到 const 的左值引⽤重载 f(" << x << ")\n";
}

void f(int&& x)
{
	std::cout << "右值引⽤重载 f(" << x << ")\n";
}

int main()
{
	int i = 1;
	const int ci = 2;
	f(i); // 调⽤ f(int&)
	f(ci); // 调⽤ f(const int&)
	f(3); // 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)
	f(std::move(i)); // 调⽤ f(int&&)
	// 右值引⽤变量在⽤于表达式时是左值

	int&& x = 1;
	f(x); // 调⽤ f(int& x)
	f(std::move(x)); // 调⽤ f(int&& x)

	return 0;
}

右值引用和移动语义的使用场景

左值引用主要使用场景回顾

左值引用的主要使用场景在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。

有些场景下还是不能使用左值引用返回，C++98中的解决方案只能是被迫使用输出行参数解决。

右值引用也无法解决这个问题，这个问题的本质是返回一个局部对象，函数结束这个对象就析构销毁了，右值引用也无法解决对象已经析构销毁的事实。

class Solution {
public:
// 传值返回需要拷⻉
string addStrings(string num1, string num2) {
    string str;
    int end1 = num1.size()-1, end2 = num2.size()-1;
    // 进位
    int next = 0;
    while(end1 >= 0 || end2 >= 0)
    {
        int val1 = end1 >= 0 ? num1[end1--]-'0' : 0;
        int val2 = end2 >= 0 ? num2[end2--]-'0' : 0;
        int ret = val1 + val2+next;
        next = ret / 10;
        ret = ret % 10;
        str += ('0'+ret);
    }
    if(next == 1)
        str += '1';
        reverse(str.begin(), str.end());
        return str;
    }
};
class Solution {
public:
// 这⾥的传值返回拷⻉代价就太⼤了
vector<vector<int>> generate(int numRows) {
    vector<vector<int>> vv(numRows);
    for(int i = 0; i < numRows; ++i)
    {
        vv[i].resize(i+1, 1);
    }
    for(int i = 2; i < numRows; ++i)
    {
        for(int j = 1; j < i; ++j)
        {
        vv[i][j] = vv[i-1][j] + vv[i-1][j-1];
        }
    }
        return vv;
    }
};

移动构造和移动赋值

移动构造函数是一种构造函数，类似拷贝构造函数，移动构造函数要求是第一个参数是该类型的引用，是该类类型的右值引用，如果还有其他参数，额外的参数必须有缺省值。

移动赋值是一个赋值运算符重载，他跟拷贝赋值构成函数重载，类似拷贝赋值函数，移动赋值函数的第一个参数是该类类型的引用，但是要求不同的是这个参数是右值引用。

对于string/vector这样的深拷贝的类或者包括深拷贝成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值第一个参数都是右值引用的类型，他的本质是窃取引用的右值对象的资源，而不是像拷贝构造和拷贝赋值那样拷贝资源，从而提供效率。

//移动构造和移动赋值
namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			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);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		void swap(string& ss)
		{
			::swap(_str, ss._str);
			::swap(_size, ss._size);
			::swap(_capacity, ss._capacity);
		}

		//// 移动构造
		//string(string&& s)
		//{
		//	cout << "string(string&& s) -- 移动构造" << endl;
		//	// 转移掠夺你的资源
		//	swap(s);
		//}

		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			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];
				if (_str)
				{
					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)
		{
			push_back(ch);
			return *this;
		}

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

		size_t size() const
		{
			return _size;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};

}

class Solution {
public:
	// 传值返回需要拷贝
	bit::string addStrings(bit::string num1, bit::string num2) {
		bit::string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		// 进位
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		//cout << &str << endl;

		return str;
	}
};

int main()
{
	//构造
	bit::string s1("xxxxx");
	// 拷⻉构造	bit::string s2 = s1;
	 //构造+移动构造，优化后直接构造
	bit::string s3 = bit::string("yyyyy");
	 //移动构造
	bit::string s4 = move(s1);
	cout << "******************************" << endl;

	return 0;
}

右值引用和移动语义解决传值返回的问题

namespace bit
{
    string addStrings(string num1, string num2)
    {
        string str;
        int end1 = num1.size() - 1, end2 = num2.size() - 1;
        int next = 0;
        while (end1 >= 0 || end2 >= 0)
        {
            int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
            int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
            int ret = val1 + val2 + next;
            next = ret / 10;
            ret = ret % 10;
            str += ('0' + ret);
        }
        if (next == 1)
            str += '1';
            reverse(str.begin(), str.end());
            cout << "******************************" << endl;
        return str;
    }
}
// 场景1
int main()
{
    bit::string ret = bit::addStrings("11111", "2222");
    cout << ret.c_str() << endl;
    return 0;
}
// 场景2
int main()
{
    bit::string ret;
    ret = bit::addStrings("11111", "2222");
    cout << ret.c_str() << endl;
    return 0;
}

右值对象构造，只有拷贝构造，没有移动构造的场景（c++11以前）

不优化的情况下，是两次拷贝构造，第一次拷贝构造出临时对象，第二次用临时对象拷贝构造ret
简单优化连续的拷贝构造合二为一一次拷贝构造。
极致优化在vs2022下，会直接将str对象的构造，str拷贝构造临时对象，临时对象拷贝构造ret对象，合三为一，变为直接构造。

右值对象构造，有拷贝构造，也有移动构造的场景（c++11以后）

不优化的情况下，两次移动构造
简单优化连续的移动构造合二为一一次移动构造。
极致优化在vs2022下，会直接将str对象的构造，str拷贝构造临时对象，临时对象拷贝构造ret对象，合三为一，变为直接构造。

右值对象构造，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景（C++11以前）

不优化的情况下一次拷贝构造临时对象，一次拷贝赋值。
在vs2022的优化下，会直接构造要返回的临时对象，str对象本质是临时对象的引用，底层角度用指针实现。

右值对象赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景（c++11以后）

不优化的情况下，一次移动构造出临时对象，一次移动赋值出ret对象
在vs2022的优化下，会直接构造要返回的临时对象，str对象本质是临时对象的引用，底层角度用指针实现

类型分类

C++11以后，对类型进行了进一步分类，右值分为将亡值和纯右值，泛左值被分为左值和将亡值。

纯右值是指字面值常量或者求值结果相当于字面值或者是一个不具明的临时对象。

如42，true，nullptr或者类似str.substr(1,2),str1+str2传值返回函数调用，或者整形a,b,a++,a+b等

将亡值是指返回右值引用的函数调用表达式和转换为右值引用的转换函数的调用表达，如move（x），static_cast<X&&>(X);

引用折叠

C++中不能直接定义引用的引用，会报错，但是通过typedef中的类型操作或模板可以构成引用的引用。

通过typedef中的类型操作或模板可以构成引用的引用，这时C++11给出了引用折叠的规则：右值引用的右值引用为右值引用，所有的其他组合均折叠为左值引用。

f2这样的函数模板，T&& x参数看起来是右值引用参数，但是由于引用折叠规则，他传递左值时就是左值引用，传递右值时就是右值引用，这种函数模板的参数也叫万能引用。

Function（T&& t）函数模板程序中，假设实参是int右值，函数模板T的推导为int，实参是int的左值，模板参数T的推导int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参的Function，实参是右值，实例化出右值引用版本形参的Function。

// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤
template<class T>
void f1(T& x)
{
}

// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤
template<class T>
void f2(T&& x)
{
}

int main()
{
	typedef int& lref;
	typedef int&& rref;
	int n = 0;

	lref& r1 = n; // r1 的类型是 int&
	lref&& r2 = n; // r2 的类型是 int&
	rref& r3 = n; // r3 的类型是 int&
	rref&& r4 = 1; // r4 的类型是 int&&

	// 没有折叠->实例化为void f1(int& x)
	f1<int>(n);
	//f1<int>(0); // 报错

	// 折叠->实例化为void f1(int& x)
	f1<int&>(n);
	//f1<int&>(0); // 报错

	// 折叠->实例化为void f1(int& x)
	f1<int&&>(n);
	//f1<int&&>(0); // 报错

	// 折叠->实例化为void f1(const int& x)
	f1<const int&>(n);
	f1<const int&>(0);

	// 折叠->实例化为void f1(const int& x)
	f1<const int&&>(n);
	f1<const int&&>(0);

	// 没有折叠->实例化为void f2(int&& x)
	//f2<int>(n); // 报错
	f2<int>(0);

	// 折叠->实例化为void f2(int& x)
	f2<int&>(n);
	//f2<int&>(0); // 报错

	// 折叠->实例化为void f2(int&& x)
	//f2<int&&>(n); // 报错
	f2<int&&>(0);


	return 0;
}

template<class T>
void Function(T&& t)
{
	int a = 0;
	T x = a;
	//x++;
	cout << &a << endl 
	cout << &x << endl << endl;
}

int main()
{
	// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(10); // 右值

	int a;
	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)
	Function(a); // 左值

	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(std::move(a)); // 右值

	const int b = 8;
	// b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int&t)
	// 所以Function内部会编译报错，x不能++
	Function(b); // const 左值

	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&&t)
	// 所以Function内部会编译报错，x不能++
	Function(std::move(b)); // const 右值



	return 0;
}

完美转发

Function（T&& t）实现了实参是左值，实例化出左值引用版本形参的Function，实参是右值，实例化出右值引用版本形参的Function。

变量表达式都是左值属性，也就意味着一个右值被一个右值引用绑定后，右值引用变量表达式的属性是左值，也就是说Function函数中的t是左值，把t传给下一层函数Fun，那么匹配的都是左值版本的Fun，我们要实现t的属性不变，就需要完美转发实现。

完美转发的forword本质是一个函数模板，他主要是通过引用折叠实现的，Function的实参是右值，T被推导为int ，没有折叠，forward内部 t被强转为右值引用返回；传递给Function的实参是左值，T被推导为int&，引用折叠为左值引用，forward内部 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<class T>
void Function(T&& t)
{
	Fun(forward<T>(t));
}

int main()
{
	// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(10); // 右值

	int a;
	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)
	Function(a); // 左值

	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(std::move(a)); // 右值

	const int b = 8;
	// b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int&t)
	Function(b); // const 左值

	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&&t)
	Function(std::move(b));  //const 右值

	return 0;
}

list 中的pushback可以接受左值和右值两种参数

namespace bit
{
	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		/*list_node(const T& data = T())
			:_data(data)
			,_next(nullptr)
			,_prev(nullptr)
		{}

		list_node(T&& data)
			:_data(forward<T>(data))
			, _next(nullptr)
			, _prev(nullptr)
		{}*/

		list_node() = default;

		template<class X>
		list_node(X&& data)
			:_data(forward<X>(data))
			, _next(nullptr)
			, _prev(nullptr)
		{
		}
	};

	template<class T, class Ref, class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> Self;
		Node* _node;

		list_iterator(Node* node)
			:_node(node)
		{
		}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}

		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		Self& operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}

		bool operator==(const Self& s) const
		{
			return _node == s._node;
		}
	};


	/*template<class T>
	struct list_const_iterator
	{
		typedef list_node<T> Node;
		typedef list_const_iterator<T> Self;
		Node* _node;

		list_const_iterator(Node* node)
			:_node(node)
		{}

		const T& operator*()
		{
			return _node->_data;
		}

		const T* operator->()
		{
			return &_node->_data;
		}

		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		Self& operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}

		bool operator==(const Self& s) const
		{
			return _node == s._node;
		}
	};*/

	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		/*typedef list_iterator<T> iterator;
		typedef list_const_iterator<T> const_iterator;*/

		typedef list_iterator<T, T&, T*> iterator;
		typedef list_iterator<T, const T&, const T*> const_iterator;
		//typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		//typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

		//reverse_iterator rbegin()
		//{
		//	return reverse_iterator(--end());
		//}

		//reverse_iterator rend()
		//{
		//	return reverse_iterator(end());
		//}

		// 对称
	/*	reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}

		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}*/

		iterator begin()
		{
			return _head->_next;
		}

		iterator end()
		{
			return _head;
		}

		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const
		{
			return _head;
		}

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		list()
		{
			empty_init();
		}

		list(initializer_list<T> il)
		{
			empty_init();
			for (auto& e : il)
			{
				push_back(e);
			}
		}

		// lt2(lt1)
		list(const list<T>& lt)
		{
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

		// lt1 = lt3
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		// 16:18继续
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		//void push_back(const T& x)
		//{
		//	insert(end(), x);
		//}

		//void push_back(T&& x)
		//{
		//	insert(end(), forward<T>(x));
		//}

		// 万能引用
		template<class X>
		void push_back(X&& x)
		{
			insert(end(), forward<X>(x));
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		//iterator insert(iterator pos, const T& x)
		//{
		//	Node* cur = pos._node;
		//	Node* prev = cur->_prev;
		//	Node* newnode = new Node(x);

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

		//	++_size;

		//	return newnode;
		//}

		//iterator insert(iterator pos, T&& x)
		//{
		//	Node* cur = pos._node;
		//	Node* prev = cur->_prev;
		//	Node* newnode = new Node(forward<T>(x));

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

		//	++_size;

		//	return newnode;
		//}

		template<class X>
		iterator insert(iterator pos, X&& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(forward<X>(x));

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

			++_size;

			return newnode;
		}

		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(begin());
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._node;

			--_size;

			return next;
		}

		size_t size() const
		{
			return _size;
		}

		bool empty() const
		{
			return _size == 0;
		}
	private:
		Node* _head;
		size_t _size;
	};

	struct AA
	{
		int _a1 = 1;
		int _a2 = 1;
	};

	//// 按需实例化
	//// T* const ptr1
	//// const T* ptr2
	//template<class Container>
	//void print_container(const Container& con)
	//{
	//	// const iterator -> 迭代器本身不能修改
	//	// const_iterator -> 指向内容不能修改
	//	typename Container::const_iterator it = con.begin();
	//	//auto it = con.begin();
	//	while (it != con.end())
	//	{
	//		//*it += 10;

	//		cout << *it << " ";
	//		++it;
	//	}
	//	cout << endl;

	//	for (auto e : con)
	//	{
	//		cout << e << " ";
	//	}
	//	cout << endl;
	//}

}

可变参数模板

可变模板参数

c++11支持可变参数模板，也就是说支持可变数量参数（参数包）的函数模板和类模板，存在两种参数包 模板参数包，表示零个或多个模板参数；函数参数包：表示零个或多个函数参数。

用省略号来指出一个模板参数或函数参数的表示一个包，在模板参数列表中，class...或typename...指出接下来的参数表示零个或多个参数列表类型；在函数参数列表中，类型名后面跟...指出接下来表示零个或多个形参对象列表；函数参数包也可以左值应用和右值引用，跟前面模板一样，每个参数的实例化应该遵循引用折叠。

可以用sizeof...运算符计算参数包中参数的个数。

//一个函数模板可以实例化出参数类型不同的函数
// 可变参数模板  ，一个可变参数模板函数可以实例化出多个不同参数个数的模板函数
template<class ...Args>
void Print(Args&& ...args)
{
	cout << sizeof...(args) << endl;
}
int main()
{

	Print();
	Print(1);
	Print(1, string("1111111111"));
	Print(1, string("111111111"), 9.0);

	return 0;
}
//void Print()
//{
//	cout << 0 << endl;
//}
//void Print(int&& arg1)
//{
//	cout << 1 << endl;
//
//}
//void Print(int&& arg1,string&& arg2)
//{
//	cout << 2 << endl;
//
//}
//void Print(int&& arg1,string&& arg2,double&& arg3)
//{
//
//}
//void Print()
//{
//
//}
//template<class T1>
//void Print(T1&& arg1)
//{
//
//}
//template<class T1,class T2>
//void Print(T1&& arg1, T2&& arg2)
//{
//
//}
//template<class T1, class T2,class T3>
//void Print(T1&& arg1, T2&& arg2,T3&& arg3)
//{
//
//}

包扩展

扩展一个包就是将他分解为构成的元素，对每个元素应用模式（对于每个元素的一个的一个模式），获得扩展后的列表。

包扩展两种方式

一种是编译时递归展开

一种是将参数依次展开作为实参传给一个函数处理

void ShowList()
{
	cout << endl;
}
template<class T,class ...Args>
void ShowList(T x,Args ...args)
{
	cout << x << ' ';
	ShowList(args...);

}
template<class ...Args>
void Print(Args... args)
{
	ShowList(args...);
}

int main()
{

	Print();
	Print(1);
	Print(1, string("1111111111"));
	Print(1, string("111111111"), 9.0);

	return 0;
}

template<class T>
const T& GetArg(const T& x)
{
	cout << x << " ";
	return x;
}

template<class...Args>
void Arguments(Args... args)
{

}
//template<class ...Args>
//void Print(Args... args)
//{
//	// 注意GetArg必须返回或者到的对象，这样才能组成参数包给Argument
//	Arguments(GetArg(args)...);
//}
void Print(int&& arg1, string&& arg2, double&& arg3)
{
	Arguments(GetArg(arg1), GetArg(arg2), GetArg(arg3));
}

int main()
{

	//Print();
	//Print(1);
	//Print(1, string("1111111111"));
	Print(1, string("111111111"), 9.0);

	return 0;
}

emplace系列接口

传左值和push_back一样走拷贝构造

传右值和push_back一样走移动构造

直接传参 push_back会走隐式类型转换构造一个临时对象

深拷贝类型 push insert是走构造➕移动构造

浅拷贝类型push insert是走构造➕拷贝构造

emplace_back会直接构造

list里面存放pair对象，push_back会走隐式类型转换构造一个临时对象

emplace_back会将对象往下传直接构造

/////////////emplace系列的接口//////////////////////
深拷贝系列，emplace少一个移动构造快一点
 浅拷贝类型没有移动构造 更快一点
 
 
int main()
{
	list<bit::string> lt;
	//左值
	bit::string s1("1111111111111");
	bit::string s2("2222222222222");

	cout << "**********************" << endl;
	lt.emplace_back(s1);
	cout << "######################" << endl;
	lt.push_back(s1);
	cout << "**********************" << endl;

	//右值
	cout << "**********************" << endl;
	lt.emplace_back(move(s1));
	cout << "######################" << endl;
	lt.push_back(move(s2));
	cout << "**********************" << endl;
	
	//直接传参
	cout << "**********************" << endl;
	//直接识别出是  const char*
	lt.emplace_back("1111111111111");
	cout << "######################" << endl;
	//隐式类型转换 + 移动构造
	lt.push_back("11111111111111");
	cout << "**********************" << endl;


	return 0;
}
int main()
{
	list<pair<bit::string, int>> lt;
	pair<bit::string, int> kv("fly", 10);

	cout << "**********************" << endl;
	lt.emplace_back(kv);
	cout << "######################" << endl;

	lt.emplace_back(move(kv));
	cout << "**********************" << endl;


	cout << "**********************" << endl;
	//将这个参数包往下传，直接构造pair对象
	lt.emplace_back("fly", 250);
	cout << "######################" << endl;
	//构造临时对象+移动构造
	lt.push_back({ "fly",250 });
	cout << "**********************" << endl;
	return 0;
}

lambda表达式

定义

lambda表达式本质是一个匿名函数对象，和普通函数不同的是他可以定义在函数内部。

在语法层面是来讲是没有类型的，用 auto或者模板参数定义的对象来接收。

格式

auto add = [](int x, int y)->int {return x + y; };

[ ]捕捉列表，出现在lambda函数的开始位置，编译器根据捕捉列表判断后面的表达式是否为lambda函数，捕捉列表可以捕捉变量供lambda函数使用，捕捉列表可以传值捕捉和传引用捕捉。捕捉列表为空也不可以忽略。

( )参数列表，传参，如果不需要参数的传递，则可以连（）一起省略

-> 返回值类型，用 追踪返回类型形式 声明函数的返回值类型，没有返回值此部分可忽略。或者一般返回值类型明确的情况下，也可忽略，由编译器对返回值类型进行推导。

{ 函数体 }函数体内的实现和普通函数完全类似，在函数体内除了可以使用其参数以外，还可以使用所有捕获到的变量，函数体为空也不可以忽略。

/////////////////////////////////////////////////////lambda表达式//////

int main()
{
	auto add = [](int x, int y)->int {return x + y; };
	cout << add(1, 2) << endl;
	return 0;
}
 1、捕捉为空也不能省略
 2、参数为空可以省略
 3、返回值可以省略，可以通过返回对象⾃动推导
 4、函数题不能省略
int main()
{
	auto func1 = []
		{
			cout << "hello world" << endl;
			return 0;
		};
	func1();
	auto swap = [](int& x, int& y)
		{
			int tmp = x;
			x = y;
			y = tmp;
		};
	int a = 0, b = 10;
	swap(a, b);
	cout << a << b << endl;

	return 0;
}

[捕捉列表]

lambda表达式默认只能使用lambda函数体内和参数中的变量，如果想用外层的变量就需要进行捕捉。

第一种捕捉方式在捕捉列表中显示的传值捕捉和传引用捕捉，捕捉的多个变量用，分割[x,y,&z],x和y是传值捕捉，z是引用捕捉。

第二种捕捉方式是在捕捉列表中隐式捕捉，[=]隐式值捕捉，[&]隐式引用捕捉，这样的话，lambda中使用了哪些变量，编译器就会自动的捕捉那些变量。

第三种捕捉方式是混合捕捉，混合显示捕捉，混合隐式捕捉。当使用混合捕捉时，第一个元素必须是&或=，并且&混合捕捉时，后面的变量必须是值捕捉。

lambda表达式如果在函数的局部域中，它可以捕捉lambda之前定义的变量，不能捕捉静态局部变量和全局变量，（也不需要捕捉，lambda表达式中可以直接使用），定义在全局的lambda表达式，捕捉列表必须为空。

默认情况下，lambda捕捉列表是被const修饰的，传值过来的对象不能被修改，在参数列表后面（）mutable加在参数列表后面取消其常量性，传值捕捉对象可以被修改了，但是修改的是形参对象，不会影响实参。使用该修饰符后，参数列表不可忽略（即使参数列表为空）。

int x = 1;
auto fun1 = []()
	{
		x++;
		cout << x << endl;
	};



int main()
{
	fun1();


	int a = 10, b = 20, c = 100;
	
	//值捕捉（不可以修改）   引用捕捉（可以修改）
	auto fun2 = [a,b,&c]()
		{
			//a++;
			cout << a << ":" << b << ":" << c << endl;
			c++;
			int ret = c + a;
			return ret;
		};
	cout << fun2() << endl;

	//隐式捕捉（用哪个变量就捕捉哪个）
	auto fun3 = [=](int x)
		{
			return a + b + c;
		};
	cout << fun3(9) << endl;
	
	//引用捕捉
	auto fun4 = [&](int y)
		{
			a++;
			b++;
			c++;
			return y;
		};
	cout << fun4(10) << endl;

	//混合捕捉
	auto fun5 = [=, &c]()
		{
			int x = 200;
			//a++;
			int ret = a + b + c;
			c++;
			return x;
		};
	cout << fun5() << endl;

	auto fun6 = [&, c]()
		{
			int x = 200;
			a++;
			b++;
			int ret = a + b + c;
			//c++;
			return x;
		};
	cout << fun6() << endl;

	//全局变量和静态变量不需要捕捉，可以直接使用
	static int m = 1987;
	auto fun7 = []()
		{
			cout << m << endl;
			return ++x;
		};
	cout << fun7() << endl;

	
	//传值捕捉本质上是一种拷贝，并且被const修饰了
	//mutable相当于去掉const属性，可以修改了
	//修改了，不会影响外面被捕捉的值，因为这是一种拷贝

	auto fun8 = [a, b, &c]()mutable
		{
			a++;
			cout << a << ":" << b << ":" << c << endl;
			c++;
			int ret = c + a;
			return ret;
		};
	cout << fun8() << endl;
	cout << a << endl;

	return 0;
}



lambda底层是一个仿函数对象，我们写了一个lambda的表达式，编译器底层会生成一个对应仿函数的类

lambda的应用

可调用对象函数指针仿函数 lamda表达式

lambda的应用场景线程中定义线程的执行函数逻辑，智能指针定制删除器。

struct Good
{
	string _name;
	double _price;
	int _evenl;

	Good(const char* str, double price, int evenl)
		:_name(str)
		,_price(price)
		,_evenl(evenl)
	{ }
};
struct compare1
{
	bool operator()(const Good& gl, const Good& gr)
	{
		return gl._price < gr._price;
	}
};

struct compare2
{
	bool operator()(const Good& gl, const Good& gr)
	{
		return gl._evenl < gr._evenl;
	}
};
int main()
{
	vector<Good> v = { {"苹果",10,3},{"⾹蕉", 3, 4} };

	sort(v.begin(), v.end(), compare1());
	sort(v.begin(), v.end(), compare2());
	sort(v.begin(), v.end(), [](const Good& gl, const Good& gr) {return gl._price < gr._price; });
	sort(v.begin(), v.end(), [](const Good& gl, const Good& gr) {return gl._evenl < gr._evenl; });

	return 0;
}

lambda的原理

lambda从汇编角度看是一个仿函数对象，我们写了一个lambda表达式，编译器底层会生成一个对应仿函数的类。

仿函数的类名是按照一定规则生成的（uuid），保证不同的lambda生成的类名不同，lambda的参数，返回类型，函数体就是仿函数operator()的参数，返回类型，函数体，lambda捕捉列表的本质是仿函数的成员变量，捕捉列表的变量都是lambda类构造函数的实参。

lambda底层是一个仿函数对象，我们写了一个lambda的表达式，编译器底层会生成一个对应仿函数的类

class Rate
{
public:
	Rate(double rate)
		:_rate(rate)
	{

	}
	double operator()(int money,int year)
	{
		return money * _rate * year;
	}

private:
	double _rate;
};

int main()
{
	double rate = 0.49;

	////////////////函数对象
	Rate r1(rate);
	r1(1000, 10);

	//////lambda//
	auto r2 = [rate](int money, int year)
		{
			return money * rate * year;
		};
	r2(1000, 10);
	return 0;
}

新的类功能（默认的移动构造和移动赋值）

C++中的默认成员函数

构造析构，拷贝构造，拷贝赋值重载，取地址重载，const取地址重载，移动构造，移动赋值运算符重载。

移动构造

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

移动赋值

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

//////////////////////////////新的类功能（默认的移动构造和移动赋值）///////////////////////////////////////////////////


class Person
{
public:
	Person(const char* name = "zhangsan", int age = 0)
		:_name(name)
		, _age(age)
	{

	}



private:
	bit::string _name;
	int _age;
};

int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);



	Person s4;
	s4 = std::move(s2);
	return 0;
}

class Person
{
public:
	//构造
	Person(const char* name = "zhangsan", int age = 0)
		:_name(name)
		, _age(age)
	{

	}

	//拷贝构造
	Person(const Person& p)
		:_name(p._name)
		,_age(p._age)
	{}
	Person(Person&& p) = default;//强制生成默认构造
private:
	bit::string _name;
	int _age;
};

int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);

	return 0;
}

成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表用的，如果没有显示的在初始化列表初始化，就会在初始化列表用这个缺省值初始化。

defult和delete

defult强制生成默认函数

delete不生成对应函数的默认版本，=delete修饰的函数为删除函数。

final和override

STL中的变化

新容器 unordered_map和unordered_set

新接口 右值引用，移动语义相关的push/insert/emplace系列的接口和移动构造，移动赋值，还有initializer_list版本的构造。

包装器

function

function是一个类模板，也是一个包装器。function的实例对象可以包装储存其他的可以调用的对象（函数指针，仿函数，lambda表达式，bind），如果没有包装任何对象，会抛异常。

函数指针，仿函数，lambda可调用的对象类型各不相同，function优势就是统一类型，对他们进行包装，方便声明可调用对象的类型。

#include<functional>

int f(int a, int b)
{
	return a + b;
}

struct Funtor
{
	int operator()(int a,int b)
	{
		return a + b;
	}
};

class Plus
{
public:
	Plus() = default;
	Plus(int n)
		:_n(n)
	{ }
	static int plusi(int a, int b)
	{
		return a + b;
	}

	double plusd(double a, double b)
	{
		return a + b;
	}

private:
	int _n;
};



//int main()
//{
//	function<int(int, int) > f1= f;//函数指针
//	function<int(int, int) > f2 = Funtor();//仿函数对象
//	function<int(int, int) > f3 = [](int a, int b)->int {return a + b; };//lambda表达式
//	cout << f1(1, 2) << endl;
//	cout << f2(1, 2) << endl;
//	cout << f3(1, 2) << endl;
//	
//
//	//类里面的静态成员函数
    //包装静态成员函数
//    成员函数要指定类域并且前⾯加&才能获取地址
//	function<int(int, int)> f4 = &Plus::plusi;
//	cout << f4(1, 3) << endl;
//
//	//类里面的普通成员函数
//  //包装普通成员函数
//    普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
//	function<double(Plus,double, double)>f5 = &Plus::plusd;
//	cout << f5(Plus(),1.1, 3.6) << endl;
//
//
//	function<double(Plus*, double, double)>f6 = &Plus::plusd;
//	Plus pd;
//	cout << f6(&pd, 1.1, 3.6) << endl;
//
//	function<double(Plus&&, double, double)>f7 = &Plus::plusd;
//	cout << f7(move(pd), 1.1, 3.6) << endl;
//	cout << f7(Plus(), 1.1, 3.6) << endl;
//
//	return 0;
//}

bind

bind是一个函数模板，他也是一个可调用对象的包装器，函数适配器，对接收的对象进行处理返回一个可调用对象。bind调整参数个数和参数顺序。

调用bind的形式

using placeholders::_1;
using placeholders::_2;
using placeholders::_3;


int sub(int a, int b)
{
	return (a - b) * 10;
}
int main()
{
	//调整参数顺序
	auto sub1 = bind(sub, _1, _2);
	cout << sub1(10, 5) << endl;
    return 0;
}

//////////////////////////////////////////////bind 调整参数顺序 个数//////////////////////////////////////////
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;


int sub(int a, int b)
{
	return (a - b) * 10;
}

int subx(int a, int b, int c)
{
	return (a - b - c) * 10;
}



int main()
{
	//调整参数顺序
	//auto sub1 = bind(sub, _1, _2);
	//cout << sub1(10, 5) << endl;

	//auto sub2 = bind(sub, _2, _1);
	//cout << sub2(10, 5) << endl;

	//调整参数个数
	//auto sub3 = bind(sub,100,_1);
	//cout << sub3(10, 5) << endl;

	//auto sub4 = bind(sub,_1,100);
	//cout << sub4(10, 5) << endl;

	//auto sub5 = bind(subx, 100, _1, _2);
	//cout << sub5(20, 30, 40) << endl;
	//auto sub6 = bind(subx, _1, 100, _2);
	//cout << sub6(20, 30, 40) << endl;

	//auto sub7 = bind(subx, _1, _2, 100);
	//cout << sub7(20, 30, 40) << endl;
	// 
	
	////类里面的普通成员函数
	//function<double(Plus,double, double)>f5 = &Plus::plusd;
	//cout << f5(Plus(),1.1, 3.6) << endl;

	////类里面的普通成员函数  绑定死一些参数
	//function<double(double, double)>f6 = bind(&Plus::plusd,Plus(),_1,_2);
	//cout << f6( 1.1, 3.6) << endl;

	auto func1 = [](double rate, int money, int year)
		{
			int ret = money;
			for (int i = 0; i < year; i++)
			{
				ret += ret * rate;
			}
			return ret - money;
		};
	cout << func1(0.005, 5000000, 5) << endl;




	auto f1 = bind(func1, 0.015, _1, 3);
	cout << f1(10000) << endl;


	// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息
	function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
	function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
	function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
	function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);

	cout << func3_1_5(1000000) << endl;
	cout << func5_1_5(1000000) << endl;
	cout << func10_2_5(1000000) << endl;
	cout << func20_3_5(1000000) << endl;

	return 0;
}