C++模板

• 什么是模板
• • 书写的方式和作用
• 函数模板
• • 案例一(模板与普通函数)
  • 案例二(模板与模板)
  • 函数模板缺省
  • 函数模板传常量
• 模板的嵌套

什么是模板

模板编程也叫泛型编程，忽略数据类型的一种编程方式。

书写的方式和作用

模板的书写方式：
1.template<class T1, class T2>
2.template

函数模板

这里主要是讲诉函数模板重载的问题，以及调用情况的问题

案例一(模板与普通函数)

#include<iostream>
#include<string>

using namespace std;

template<class T1>
//template<typename _T>

T1 Max(T1 a, T1 b)
{
  
	cout << "调用函数模板" << endl;
	return a > b ? a : b;
}

int Max(int a, int b)
{
  
	cout << "调用普通函数" << endl;
	return a > b ? a : b; 
}

int main()
{
  
	//编译器优先调用类型确定的函数
	cout << Max(1, 2) << endl; //调用的普通函数 
	cout << Max<int>(1, 2) << endl; //调用函数模板(显式调用)

	system("pause");
	return 0;
}

案例二(模板与模板)

#include<iostream>

using namespace std;

template<class T>

void print(T a, T b, T c)
{
  
	cout << "一个类型" << endl;
}

template<class T1, class T2>

void print(T1 a, T1 b, T2 c)
{
  
	cout << "两个类型" << endl;
}

template<class T11, class T22, class T33>

void print(T11 a, T22 b, T33 c)
{
  
	cout << "三个类型" << endl;
}

int main()
{
  
	print<int>(1, 2, 3); //调用的第一个
	print<int, string>(1, 2, "3"); //调用第二个
	print<int, double, string>(1, 2.9, "3");//调用第三个

	print(1, 2, 3);  //传参类型少的先调用
	print(1, "1", "1");

	system("pause");
	return 0;

}

函数模板缺省

函数模板缺省跟函数缺省规则一样，都是从右往左缺省

#include<iostream>

using namespace std;

template<typename T1, class T2 = string>

int main()
{
  
	system("pause");
	return 0;
}

函数模板传常量

函数模板里写常量，在传参的时候，也应该传常量，而不是变量。

#include<iostream>
#include<string>

using namespace std;

class MM
{
  
public:
	MM (){
  }
	MM(int age, string name) : age(age), name(name) {
  }

private:
	int age;
	string name;
};

template<typename T>

void print(T date)
{
  
	cout << date << endl;
}

int main()
{
  
	MM mm(10,"温柔了岁月");

	print(mm);

	system("pause");
	return 0;
}

如图所示，不能够直接打印出，要使用运算法重载，打印自定义类型

#include<iostream>
#include<string>
#include<iomanip>

using namespace std;

class MM
{
  
public:
	MM() {
  }
	MM(int age, string name) : age(age), name(name) {
  }

	friend ostream& operator << (ostream & out,MM & object)
	{
  
		out << object.age << setw(5) << object.name << endl;
		return out;
	}

private:
	int age;
	string name;
};

template<typename T>

void print(T date)
{
  
	cout << date << endl;
}

int main()
{
  
	MM mm(10,"温柔了岁月");

	print(mm);

	system("pause");
	return 0;
}

将一个类名，当做模板的一个类型

#include<iostream>
#include<string>
#include<iomanip>

using namespace std;

class MM
{
  
public:
	MM() {
  }
	MM(int age, string name) : age(age), name(name) {
  }

	friend ostream& operator << (ostream& out, MM& object)
	{
  
		out << object.age << setw(5) << object.name << endl;
		return out;
	}

private:
	int age;
	string name;
};

template<class T1, class T2, class T3>

class MM1
{
  
public:
	MM1(T1 A, T2 B, T3 C): A(A), B(B), C(C) {
  }

	void printDate()
	{
  
		cout << A << B << C << endl;
	}

private:
	T1 A;
	T2 B;
	T3 C;
};

int main()
{
  

	MM1<MM,int,int> mm(MM(19,"NI"),90,90); //MM这个类，当做模板的类型，所传的参数要与之相对应

	mm.printDate(); //因为在MM那个类中写了运算符重载，所以这里不不要写运算符重载

	system("pause");
	return 0;
}

模板的嵌套

这里用的是类的模板嵌套
注意的是:这里类名时候，必须要、
类名<类型>的形式

#include<iostream>
#include<string>

using namespace std;

template<class T1, class T2>
class MM
{
  
public:
	MM(T1 a, T2 b): a(a),b(b) {
  }
private:
	T1 a;
	T2 b;
};

template<class T>
class mm
{
  
public:
	mm(T c): c(c) {
  }
private:
	T c;
};

int main()
{
  
	MM<int ,int> mm1(1,2);
	mm<int> mm2(1);
 
	MM<mm<int>, mm<int>> mm3(mm<int>(1), mm<int>(2));  //嵌套

	//可以通过起别名的方式，是代码变得简洁；

	using type = mm<int>;

	MM<type, type> mm5(type(1), type(3));

	//如果要打印的话,自然还是要是使用运算符重载
	system("pause");
	return 0;
}