【C++篇】C++11：可变参数模板

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

int main()
{
	ShowList();
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 1.1, 'a');
	ShowList(1, 1.1, 'a', string("woxiangchiyu"));
	
	return 0;
}

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

template <class T, class ...Args>
void _ShowList(T val, Args... args)
{
	cout << val << " ";//打印分离出的第一个参数
	_ShowList(args...);//递归调用自身函数，调用时只传参数包
}

// 结束条件的函数
void _ShowList()
{
	cout << endl;
}

template <class ...Args>
void CppPrint(Args... args)
{
	_ShowList(args...);
}

// 结束条件的函数
void _ShowList()
{
	cout << endl;
}

//递归函数展开参数包
template <class T, class ...Args>
void _ShowList(T val, Args... args)
{
	cout << val << " ";
	_ShowList(args...);
}

//套一层，封装被添加的模板参数，调用时传参数包即可
template <class ...Args>
void CppPrint(Args... args)
{
	_ShowList(args...);
}

int main()
{
	CppPrint();
	CppPrint(1);
	CppPrint(1, 2);
	CppPrint(1, 2, 2.2);
	CppPrint(1, 2, 2.2, string("xxxx"));

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

int main()
{
	 std::list< std::pair<int, char> > mylist;
	 // emplace_back支持可变参数，可以用构建pair对象的参数后自己去创建一个匿名pair对象，然后用于构造list节点对象
	 mylist.emplace_back(10, 'a');//支持传入参数包构造
	 mylist.emplace_back(20, 'b');
	 //也可以像push_back一样直接用对象构造
	 mylist.emplace_back(make_pair(30, 'c'));
	 //不能像push_back一样直接用列表初始化，会报错
	 mylist.emplace_back({ 60, 'f' });//错误写法
	 
	 mylist.push_back(make_pair(40, 'd'));
	 mylist.push_back({ 50, 'e' });
	 
	 for (auto e : mylist)
	 cout << e.first << ":" << e.second << endl;
	 return 0;
}

#include <iostream>
using namespace std;

// 日期类
class Date
{
public:
    // 构造函数（带默认参数）
    // 参数：
    //   year - 年份（默认1）
    //   month - 月份（默认1）
    //   day - 日（默认1）
    Date(int year = 1, int month = 1, int day = 1)
        :_year(year)      // 初始化_year
        , _month(month)   // 初始化_month
        , _day(day)       // 初始化_day
    {
        cout << "Date构造" << endl;  // 构造时打印信息
    }

    // 拷贝构造函数
    // 参数：
    //   d - 要拷贝的Date对象
    Date(const Date& d)
        :_year(d._year)  
        , _month(d._month) 
        , _day(d._day)  
    {
        cout << "Date拷贝构造" << endl;  // 拷贝构造时打印信息
    }

private:
    int _year;   // 年
    int _month;  // 月
    int _day;    // 日
};

// 可变参数模板函数：创建Date对象
// 模板参数：
//   Args - 可变参数类型包
// 函数参数：
//   args - 可变参数包（可以匹配0到多个参数）
template <class ...Args>
Date* Create(Args... args)
{
    // 使用new在堆上创建Date对象，完美转发args参数
    Date* ret = new Date(args...);
    
    return ret;  // 返回创建的Date指针
}

int main()
{
   std::list<Date> lt;
   Date d(2023, 9, 27);
	// 只能传日期类对象
	lt.push_back(d);

	// 传日期类对象
	// 传日期类对象的参数包
	// 参数包，一路往下传，直接去构造或者拷贝构造节点中日期类对象
	lt.emplace_back(d);
	lt.emplace_back(2023, 9, 27);

    return 0;
}