C++11 -- 可变参数模板 + 包装器_c++ 打包参数

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

template <class ...Args>
void ShowList1(Args... args) {
	//sizeof 后面也需要加上参数列表 ... ，不加直接报错
	cout << sizeof...(args) << endl; //获取参数包中参数的个数
}
 
int main() {
	//想传几个就传几个，想传什么类型就传什么类型
	ShowList1();
	ShowList1(1, 2);
	ShowList1(1, 2, '3');
 
	return 0;

void ShowList2() // 这里是当参数包中的个数为0时，调用函数就会去匹配我们重载的函数，结束递归
{
	cout <<  endl;
}
 
 //展开函数
template <class T, class ...Args>
void ShowList2(T value, Args... args)
{
	cout << value << " ";
	ShowList2(args...);
}
int main()
{
	ShowList2();
 
	ShowList2(1);
	ShowList2(1, 2);
	ShowList2(1, 'A');
	ShowList2(1, 'A', std::string("sort"));
	return 0;
}

// 逗号表达式
//		从左到右逐个计算；
//		它的值为最后一个表达式的值；
//		逗号表达式的优先级别在所有运算符中最低。
//	int a, b, c;
//	cout << (a = 3, b = 5, b += a, c = b * 5, b = 2); // 2
 
//数组可以通过列表进行初始化，比如:
//int a[] = { 1,2,3,4,5 };

//展开函数
template<class ...Args>
void ShowList3(Args... args)
{
	//如果参数包中各个参数的类型都是整型，那么也可以把这个参数包放到列表当中初始化这个整型数组，
	//	此时参数包中参数就放到数组中了
	int arr[] = { args... }; //列表初始化
	//打印参数包中的各个参数
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;
 
	cout << "第一个元素:" << arr[0] << endl;
}
 
int main()
{
	//C++规定一个容器中存储的数据类型必须是相同的，因此如果这样写的话，
	//	那么调用 ShowList函数时传入的参数只能是整型的，并且还不能传入0个参数，
	//	因为数组的大小不能为0，需要再重载一个无参的函数，在此基础上借助逗号表达式来展开参数包
	//ShowList3(); // 会报错
 
	ShowList3(1);
	ShowList3(1, 2);
	ShowList3(1, 2, 3);
	return 0;
}

//支持无参调用
void ShowList()
{
	cout << endl;
}
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();
 
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
 
	return 0;
}

template <class T>
int PrintArg(T t)
{
	cout << t << " ";
	return 0;
}
 
int PrintArg()   // 只用这个，不支持无参ShowList() 调用，需要重载一个无参的ShowList函数
{
	return 0;
}
 
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	//实际上我们也可以不用逗号表达式，因为这里的问题就是初始化整型数组时必须用整数，
	//	那我们可以将处理函数的返回值设置为整型，然后用这个返回值去初始化整型数组也是可以的
	int arr[] = { PrintArg(args)... };
	cout << endl;
}
int main()
{
	// ShowList(); // 重载一个无参的ShowList函数，才可调用
 
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
 
	return 0;
}

template <class... Args>
  void emplace_back (Args&&... args);

#include<list>
int main() {
 
	list<int> list1;
	list1.push_back(1);
	list1.emplace_back(2);
	list1.emplace_back();
 
	//参数过多就识别不了了,会报错
	//list1.emplace_back(3, 4);
	//list1.emplace_back(3, 4, 5);
 
	for (auto& e : list1)
	{
		cout << e << endl;
	}
 
	list< std::pair<int, char> > mylist;
	mylist.push_back(make_pair(1, 'a'));//构造+拷贝构造
	//mylist.push_back(1, 'a'); //push_back不支持
 
	mylist.emplace_back(10, 'a');//直接构造
	mylist.emplace_back(20, 'b');
	mylist.emplace_back(30, 'c');
 
	cout << "mylist contains:";
	for (auto& x : mylist)
		cout << " (" << x.first << "," << x.second << ")";
 
	cout << endl;
 
	return 0;
}

//emplace_back有时比push_back更快，就是因为其底层存在着参数包，不用进行拷贝构造。
// 当然，emplace_back也可以直接传对象。
//emlplace就是少拷贝一次，直接构造，没有参数上的拷贝过程，
// 因此如果对于没有实现移动构造的深拷贝的类，减少的就是一次深拷贝，性能就会提升很多。

// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args> class function<Ret(Args...)>;
std::function在头文件<functional>
 
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

#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()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	cout << endl;
	// 函数对象
	cout << useF(Functor(), 11.11) << endl;
	cout << endl;
	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	cout << endl;
 
	//由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印 count的地址也是不同的。
	// 但实际这里根本没有必要实例化出三份useF函数，因为三次调用 useF函数时传入的可调用对象虽然是不同类型的，
	// 但这三个可调用对象的返回值和形参类型都是相同的
	//
	//这时就可以用包装器分别对着三个可调用对象进行包装，
	// 然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
	//根本原因就是因为包装后，这三个可调用对象都是相同的function类型，
	// 因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的
 
	//函数名
	function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
 
	//函数对象
	function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
 
	//lambda表达式
	function<double(double)> func3 = [](double d)->double {return d / 4; };
	cout << useF(func3, 11.11) << endl;
 
	return 0;
}

int f2(int a, int b)
{
	return a + b;
}
struct Functor2
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
 
int main()
{
	// 函数名(函数指针)
	//int(int, int) 第一个int返回类型，（int, int）是参数列表
	function<int(int, int)> func1 = f2;
	cout << func1(1, 2) << endl;
 
	//也可以这样
	function<int(int, int)> func2(f2);
	cout << func2(1, 2) << endl;
	cout << endl;
 
	// 匿名函数对象
	function<int(int, int)> func3 = Functor2();
	cout << func3(1, 2) << endl;
 
	//这种匿名对象的写法，VS系列不支持，可能是编译器识别的问题
	//function<int(int, int)> func4(Functor2());
	//cout << func4(1, 2) << endl;
 
	// 仿函数对象
	Functor2 ft;
	function<int(int, int)> func5 = ft;
	cout << func5(1, 2) << endl;
	cout << endl;
 
	// lambda表达式
	function<int(int, int)> func6 = [](const int a, const int b) {return a + b; };
	cout << func6(1, 2) << endl;
 
	return 0;
}

//如果是类成员函数，使用有点区别
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)> func1 = &Plus::plusi;//类静态成员函数指针
	cout << func1(1, 2) << endl;
	//也可以不取地址
	function<int(int, int)> func2 = Plus::plusi;//类静态成员函数指针
	cout << func2(1, 3) << endl;
 
	//类普通成员函数
	//对于类普通成员函数，必须进行&，没有直接报错
	//参数列表还需要加上一个参数：类名，这个参数代表的是 this指针
	//this指针不能显示去传，所以需要用Plus替代
	function<double(Plus, double, double)> func8 = &Plus::plusd;//类普通成员函数指针
	//调用的时候必须要传多一个匿名对象，不传直接报错
	cout << func8(Plus(), 1.1, 2.2) << endl;
 
	return 0;
}