【C++11】可变参数模板/新的类功能/lambda/包装器--C++

时间：2024-11-26 08:11:22

文章目录

  • 一、可变参数模板
    • 1、基本语法及原理
    • 2、包扩展
    • 3、empalce系列接口
  • 二、新的类功能
    • 1、默认的移动构造和移动赋值
    • 2、成员变量声明时给缺省值
    • 3、defult和delete
    • 4、final与override
  • 三、STL中一些变化
  • 四、lambda
    • 1、lambda表达式语法
    • 2、捕捉列表
    • 3、lambda的应用
    • 4、lambda的原理
  • 五、包装器
    • 1、function
    • 2、bind

一、可变参数模板

1、基本语法及原理

  1. C++11支持可变参数模板，也就是说支持可变数量参数的函数模板和类模板，可变数目的参数被称为参数包，存在两种参数包：模板参数包，表示零或多个模板参数；函数参数包：表示零或多个函数参数。
  2. template <class ...Args> void Func(Args... args) {}
  3. template <class ...Args> void Func(Args&... args) {}
  4. template <class ...Args> void Func(Args&&... args) {}
  5. 我们用省略号来指出一个模板参数或函数参数的表示一个包，在模板参数列表中，class…或typename…指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟…指出接下来表示零或多个形参对象列表；函数参数包可以用左值引用或右值引用表示，跟前面普通模板一样，每个参数实例化时遵循引用折叠规则。
  6. 可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。
  7. 这里我们可以使用sizeof…运算符去计算参数包中参数的个数。
template <class ...Args>
void Print(Args&&... args)
{
	cout << sizeof...(args) << endl;
} 

int main()
{
	double x = 2.2;
	Print(); // 包⾥有0个参数
	Print(1); // 包⾥有1个参数
	Print(1, string("xxxxx")); // 包⾥有2个参数
	Print(1.1, string("xxxxx"), x); // 包⾥有3个参数
	return 0;
} 

// 原理1：编译本质这⾥会结合引⽤折叠规则实例化出以下四个函数
void Print();
void Print(int&& arg1);
void Print(int&& arg1, string&& arg2);
void Print(double&& arg1, string&& arg2, double& arg3);

// 原理2：更本质去看没有可变参数模板，我们实现出这样的多个函数模板才能⽀持
// 		这⾥的功能，有了可变参数模板，我们进⼀步被解放，他是类型泛化基础
// 		上叠加数量变化，让我们泛型编程更灵活。
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);
// ...

2、包扩展

  1. 对于一个参数包，我们除了能计算他的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(…)来触发扩展操作。底层的实现细节如图1所示。
  2. C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理。

在这里插入图片描述

// 可变模板参数
// 参数类型可变
// 参数个数可变
// 打印参数包内容
//template <class ...Args>
//void Print(Args... args)
//{
// 		// 可变参数模板编译时解析
// 		// 下⾯是运⾏获取和解析，所以不⽀持这样⽤
// 		cout << sizeof...(args) << endl;
// 		for (size_t i = 0; i < sizeof...(args); i++)
// 		{
// 			cout << args[i] << " ";
// 		}
//		cout << endl;
//}

void ShowList()
{
	// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数
	cout << endl;
} 

template <class T, class ...Args>
void ShowList(T x, Args... args)
{
	cout << x << " ";
	// args是N个参数的参数包
	// 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包
	ShowList(args...);
} 
// 编译时递归推导解析参数
template <class ...Args>
void Print(Args... args)
{
	ShowList(args...);
} 
int main()
{
	Print();
	Print(1);
	Print(1, string("xxxxx"));
	Print(1, string("xxxxx"), 2.2);
	return 0;
} 
//template <class T, class ...Args>
//void ShowList(T x, Args... args)
//{
//	 cout << x << " ";
//	 Print(args...);
//}
// Print(1, string("xxxxx"), 2.2);调⽤时
// 本质编译器将可变参数模板通过模式的包扩展，编译器推导的以下三个重载函数函数
//void ShowList(double x)
//{
//	 cout << x << " ";
//	 ShowList();
//}
//
//void ShowList(string x, double z)
//{
//	 cout << x << " ";
//	 ShowList(z);
//}
//
//void ShowList(int x, string y, double z)
//{
//	 cout << x << " ";
//	 ShowList(y, z);
//}
//void Print(int x, string y, double z)
//{
//	 ShowList(x, y, z);
//}


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必须返回或者到的对象，这样才能组成参数包给Arguments
	Arguments(GetArg(args)...);
} 
// 本质可以理解为编译器编译时，包的扩展模式
// 将上⾯的函数模板扩展实例化为下⾯的函数
// 是不是很抽象，C++11以后，只能说委员会的⼤佬设计语法思维跳跃得太厉害
//void Print(int x, string y, double z)
//{
//	 Arguments(GetArg(x), GetArg(y), GetArg(z));
//}
int main()
{
	Print(1, string("xxxxx"), 2.2);
	return 0;
}

3、empalce系列接口

  1. template <class... Args> void emplace_back (Args&&... args);
  2. template <class... Args> iterator emplace (const_iterator position, Args&&... args);
  3. C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数，功能上兼容push和insert系列，但是empalce还支持新玩法，假设容器为container，empalce还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
  4. emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
  5. 第二个程序中我们模拟实现了list的emplace和emplace_back接口，这里把参数包不段往下传递，最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的empalce支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
  6. 传递参数包过程中，如果是 Args&&... args 的参数包，要用完美转发参数包，方式如下std::forward<Args>(args)... ，否则编译时包扩展后右值引用变量表达式就变成了左值。
#include<list>

// emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列
int main()
{
	list<bit::string> lt;
	// 传左值，跟push_back⼀样，⾛拷⻉构造
	bit::string s1("111111111111");
	lt.emplace_back(s1);
	cout << "*********************************" << endl;
	
	// 右值，跟push_back⼀样，⾛移动构造
	lt.emplace_back(move(s1));
	cout << "*********************************" << endl;
	
	// 直接把构造string参数包往下传，直接⽤string参数包构造string
	// 这⾥达到的效果是push_back做不到的
	lt.emplace_back("111111111111");
	cout << "*********************************" << endl;
	
	list<pair<bit::string, int>> lt1;
	// 跟push_back⼀样
	// 构造pair + 拷⻉/移动构造pair到list的节点中data上
	pair<bit::string, int> kv("苹果", 1);
	lt1.emplace_back(kv);
	cout << "*********************************" << endl;
	
	// 跟push_back⼀样
	lt1.emplace_back(move(kv));
	cout << "*********************************" << endl;
	
	// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair
	// 这⾥达到的效果是push_back做不到的
	lt1.emplace_back("苹果", 1);
	cout << "*********************************" << endl;
	
	return 0;
}

// List.h
namespace bit
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		
		T _data;
		
		ListNode(T&& data)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(move(data))
		{}
		
		template <class... Args>
		ListNode(Args&&... args)
			: _next(nullptr)
			, _prev(nullptr)
			, _data(std::forward<Args>(args)...)
		{}
	};

	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;
		
		ListIterator(Node* node)
			:_node(node)
		{}
		
		// ++it;
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		} 
		
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		} 
		
		Ref operator*()
		{
			return _node->_data;
		} 
		
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
	};
	
	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		
		iterator begin()
		{
			return iterator(_head->_next);
		} 
		
		iterator end()
		{
			return iterator(_head);
		} 
		
		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		} 
		
		list()
		{
			empty_init();
		} 
		
		void push_back(const T& x)
		{
			insert(end(), x);
		} 
		
		void push_back(T&& x)
		{
			insert(end(), move(x));
		} 
		
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;
			
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			
			return iterator(newnode);
		} 
		
		iterator insert(iterator pos, T&& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(move(x));
			Node* prev = cur->_prev;
			
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			
			return iterator(newnode);
		} 
		
		template <class... Args>
		void emplace_back(Args&&... args)
		{
			insert(end(), std::forward<Args>(args)...);
		} 
		
		// 原理：本质编译器根据可变参数模板⽣成对应参数的函数
		/*void emplace_back(string& s)
		{
			insert(end(), std::forward<string>(s));
		}
		
		void emplace_back(string&& s)
		{
			insert(end(), std::forward<string>(s));
		}
		
		void emplace_back(const char* s)
		{
			insert(end(), std::forward<const char*>(s));
		} 
		*/ 
		
		template <class... Args>
		iterator insert(iterator pos, Args&&... args)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(std::forward<Args>(args)...);
			Node* prev = cur->_prev;
			
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			
			return iterator(newnode);
		}
	private:
		Node* _head;
	};
} 
// Test.cpp
#include"List.h"

// emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列
int main()
{
	bit::list<bit::string> lt;
	// 传左值，跟push_back⼀样，⾛拷⻉构造
	bit::string s1("111111111111");
	lt.emplace_back(s1);
	cout << "*********************************" << endl;
	
	// 右值，跟push_back⼀样，⾛移动构造
	lt.emplace_back(move(s1));
	cout << "*********************************" << endl;
	
	// 直接把构造string参数包往下传，直接⽤string参数包构造string
	// 这⾥达到的效果是push_back做不到的
	lt.emplace_back("111111111111");
	cout << "*********************************" << endl;
	
	bit::list<pair<bit::string, int>> lt1;
	// 跟push_back⼀样
	// 构造pair + 拷⻉/移动构造pair到list的节点中data上
	pair<bit::string, int> kv("苹果", 1);
	lt1.emplace_back(kv);
	cout << "*********************************" << endl;
	
	// 跟push_back⼀样
	lt1.emplace_back(move(kv));
	cout << "*********************************" << endl;
	
	// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair
	// 这⾥达到的效果是push_back做不到的
	lt1.emplace_back("苹果", 1);
	cout << "*********************************" << endl;
	
	return 0;
}

二、新的类功能

1、默认的移动构造和移动赋值

  1. 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重载/const 取地址重载，最后重要的是前4个，后两个用处不大，默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
  2. 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
  3. 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
  4. 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
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& operator=(const Person& p)
	{
		if(this != &p)
		{
			_name = p._name;
			_age = p._age;
		}
		return *this;
	}*/
	
	/*~Person()
	{}*/

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

2、成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个却绳子初始化，这个我们在类和对象部分讲过了,点击跳转,可以查看我的主页哦.

3、defult和delete

  1. C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。
  2. 如果能想要限制某些默认函数的生成，在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)
		:_name(p._name)
		,_age(p._age)
	{}
	
	Person(Person&& p) = default;
	
	//Person(const Person& p) = delete;
private:
	bit::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

4、final与override

这个在继承和多态部分已经进行了详细讲过了，点击跳转.可以关注我,看我的主页哦.

三、STL中一些变化

  1. 下图1圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。这两个前面已经进行了详细讲解,可以看我的主页查看相关内容

相关文章