2020.11.27 第15课 C++新标准模板篇

2020.11.27 第15课 C++新标准模板篇

01_初始列表initializer_list

#include <iostream>
#include <vector>
#include <initializer_list>
using namespace std;
/*
	初始列表
	{1,2,3,4,5};
	initializer_list有两种构造方式
	1.当初始化的时候使用的是大括号的初始化,被自动构造,包括函数调用和赋值的
	2.当涉及到for(initializer_list)的时候,会自动把大括号内容构造成一个initializer_list对象
	主要就是用在初始化容器
*/
template <class T>
class MM
{
public:
	MM(initializer_list<T> x) :v(x)
	{
		cout << "初始化列表的构造函数" << endl;
	}
	void append(initializer_list<T> x)
	{
		v.insert(v.end(), x.begin(), x.end());
	}
	vector<T> getV()
	{
		return v;
	}
protected:
	vector<T> v;
};

template <class T>    // 模板
void print(T data)
{
	for (auto v : data)
	{
		cout << v << "\t";
	}
	cout << endl;
}

int main()
{
	for (auto m : { 1,2,3,4,5,6 }) //for_each
	{
		cout << m << "\t";
	}
	cout << endl;

	vector<int> vec = { 1,2,3,4 };
	for (auto m : vec)
	{
		cout << m << "\t";
	}
	cout << endl;
	vector<int> vecInt = { 1,2,3,4,5,6,7,8,9,10 };
	MM<int> mm{ 1,2,3,4,5,6 };
	MM<int> mm1{ 1,2,3 };
	MM<int> mm2{ 1,2 };
	mm.append({ 5,6,7,8,9 });
	for (auto v : mm.getV())
	{
		cout << v << "\t";
	}
	cout << endl;
	print<initializer_list<int>>({ 1,2,3,5 });
	print<initializer_list<int>>({ 1,3,4 });
	//vector<int> 为X
	//print<X>({1,3,4});
	return 0;
}

02_可变模板参数

#include <iostream>
#include <string>
using namespace std;
/*
	可变模板参数：可以表示0到任意个数的参数
	声明语法：
	template<class ...T>
	void print(T ...arg);
	省略号：
		1.声明一个参数包T ...arg 可以包含任意个数的模板参数
		2.在实现可变模板参数的时候需要把参数包一个一个独立展开
	展开参数包：
		1.递归方式展开
		2.是通过,表达式去展开
*/
template<class ...Type>
void print(Type ...data)
{
	cout << sizeof...(data) << endl;		//统计参数个数
}
int main()
{
	print<>();		//0;
	print<int>(1);  //1
    //显示调用  隐式调用
	print<int, string, string>(1, "string", "ILoveyou");
	print<int, string, string, double>(1, "string", "ILoveyou", 2.4);
	print<int, string, string, double, string>(1, "string", "Iloveyou", 2.4, "Love");
	return 0;
}

03_递归展开参数包

#include <iostream>
#include <string>
using namespace std;
/*
	递归展开参数包
	1.具有递归终止函数
	2.展开函数--->可变模板参数
*/
//打印 无参的终止函数
void print()
{
	cout << endl;
}
//展开函数
template <class T,class...Type>
void print(T data, Type...exData)
{
	cout << data << "\t";
	print(exData...); //{2,3,4}
}

//模板充当终止函数
template <class Type>
Type sum(Type t)
{
	return t;
}
template <class T,class...Type>
T sum(T a, Type...b)
{
	return a + sum<T>(b...);
}
int main()
{
	print(1, 2, 3, 4);
	print(1, "Loveyou", "Imissyou");
	print(1);
	//print(); 错误 以终止函数为最低个数的标准表述
	//print("Iloveyou");
	cout << sum(1, 2) << endl;
	cout << sum(1, 2, 4) << endl;
	cout << sum(1, 3, 4, 5.5) << endl;
	return 0;
}

04_逗号表达式解包过程

#include <iostream>
#include <string>
using namespace std;
template <class Type>
void print(Type data)
{
	cout << data << "\t";
	//return 0;
}
//逗号表达式有效值最后一个
template<class ...Type>
void print(Type...data)
{
	int array[] = { (print(data),0)... };
	//  (print(1),0)  (print(2),0)  (print(3),0)
	//  从左往右运行
}
int main()
{
	print(1, 2, 3);		//(print(1),0)  (print(2),0)  (print(3),0)
	cout << endl;
	print("张三", "丹心", 133);
	return 0;
}

05_元组的一些东西

/*
	可变模板类：元组：tuple
		make_tuple 产生一个元素
	不同类型的数据集合
*/
#include <tuple>
#include <iostream>
using namespace std;
int main()
{
	tuple<int> tp1 = make_tuple(1);
	tuple<int, double> tp2 = make_tuple(1, 2.4);
	tuple<int, double, string> tp3 = make_tuple(1, 2.4, "string");
	//get<0>()
	cout << get<0>(tp3) << endl;
	cout << get<1>(tp3) << endl;
	cout << get<2>(tp3) << endl;
	return 0;
}

06_可变模板类

/*
	C# 构造委托
	了解下
	模板的特化展开参数包
	继承的方式展开包
*/
#include <iostream>
using namespace std;

template <class...args>
struct Sum;

template <class First,class...args>
struct Sum<First, args...>
{
    //统计字节数 value整数 
	enum { value = Sum<First>::value + Sum<args...>::value };
    //调用和定义写在一起
};

//递归终止
template<class Type>
struct Sum<Type>
{
	enum{value=sizeof(Type) }; //统计字节数
};
int main()
{
	cout << Sum<int, double, short, char>::value << endl;
	return 0;
}

07_可变模板函数消除重复代码

/*
	1.消除重复代码
	2.委托的实现（万能函数）
*/
#include <iostream>
using namespace std;
template<class T,class...Type>
T* Instance(Type...args)
{
	return new T(args...);
}
class A
{
public:
	A(int a){}
	A(int a,int b){}
	A(int a,int b,int c){}
	A(int a,int b,string c){}
	void print()
	{
		cout << "A中函数" << endl;
	}
protected:
};
class B
{
public:
	B(int a){}
	B(int a,int b){}
	B(int a,int b,int c){}
	void print()
	{
		cout << "B中函数" << endl;
	}
protected:
};

int main()
{
	A* pA = Instance<A>(1, 2);
	pA->print();
	B* pB = Instance<B>(1, 3);
	pA = Instance<A>(1, 3, "Loveyou");
	pB = Instance<B>(1, 2, 3);

	return 0;
}