函数模板以及类模板的使用

函数模板的使用

// 模板头 template <typename T > 定义任意类型
template<typename T>
void fun(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 3, b = 6;
	fun(a,b);  // 隐式推导类型 
	char c = 't';
	fun(c,a);  // 报错 要使用同一种类型
	fun<int>(a,c);  // 显示指定类型
	return 0; 
}
// 在定义模板的时候可以使用多个任意类型
template<typename T1, typename T2>

函数模板与普通函数

// 1 函数模板和普通函数可以重载
template<typename T>
void fun(T a)
{
	cout<<"这是函数模板"<<endl;
}
void fun(int a)
{
	cout<<"这是普通函数"<<endl;
}

int main()
{
	int a = 10;
	fun(a); // 2 函数模板和普通函数发生重载时，优先调用普通函数
	fun<int>(a);  // 强制调用函数模板
	// 3 普通函数在传参的时候,如果类型不匹配会进行强转,但是函数模板没有
	char c = 'a';
	fun(c);
	return 0;
}

函数模板的简单使用

// 对 char 和 int 类型的数组进行排序
template<typename T>  
void Swap(T& a,T& b)  // 交换函数
{
	T temp = a;
	a = b;
	b = temp;
}
template<typename T>  // 排序函数
void Sort(T arr[],int len)
{
	for(int i = 0; i < len; i++)
	{
		int min = i;
		for(int j = i + 1; j < len; j++)
		{
			if(arr[min] > arr[j])
			min = j;
		}
		if(min ! = i)
			Swap(arr[min],arr[i]);
	}
}

int main()
{
	char str[] = "abcdfghdjg";
	int len = strlen(str);
	Sort(str,len);
	int arr[5] = {1,3,7,5,8};
	Sort(arr,5);
	return 0;
}

函数模板的局限性

class Person
{
public:
	int age;
	Person(int age)
	{
		this->age = age;
	}
}

template<typename T>
bool Compare(T& a,T& b)
{
	cout<<"111"<<endl;
	if(a == b)
		return true;
	return false;
}
// 如果传入的参数是类对象的话，不能直接进行比较
// 有一个语法可以解决这个问题
// template<> 返回值类型 函数名<实参类型>(参数列表)
template<> bool Compare<Person>(Person& a,Person& b)
{
	cout<<"222"<<endl;
	if(a.age == b.age)
		return true;
	return false;
}
//  也可以直接定义一个函数 来进行比较
int main()
{
	Person A(20);
	Person B(21);
	int C = 10;
	int D = 15;
	Compare(A,B); // 222
	Compare(C,D); // 111
	return 0;
}

类模板的使用

template<typename T1, typename T2 = int>  // T2 默认为 int 类型
class Person
{
public:
	T1 name;
	T2 age;
	Person(T1 name,T2 age)
	{
		this->age = age;
		this->name = name;
	}
}

// 如果定义一个函数，函数的参数是类模板实例化的对象
// 1 指定参数类型
void fun1(Person<string,int>& p)
{
	cout<<"这是fun1函数"<<endl;
}
// 2 参数模板化
template<typename T1,typename T2>
void fun2(Person<T1,T2>& p)
{
	cout<<"这是fun2函数"<<endl;
}
// 3 整体模板化
template<typename T>
void fun3(T& p)
{
	cout<<"这是fun3函数"<<endl;
}

int main()
{
	// 类模板实例化对象时不会自动推导类型，需要自己指定类型
	Person<string> p1("gou",5);  
	Person<string,int> p2("mao",4);
	fun1(p1);
	fun2(p2);  // 或者 fun2<string,int>(p2);
	fun3(p1);
	return 0;;
}

类模板和继承

template<typename T>
class Base
{
public:
	T a;
	virtual void fun()
	{
		cout<<"base"<<endl;
	}
}

// 在继承的时候，父类是类模板，子类需要知道父类的类型
template<typename T>
class Child : public Base<T>  // 要指定父类的类型
{
public:
	virtual void fun()
	{
		cout<<"child"<<endl;
	}
}

int main()
{
	Base<int> *b = new child<int>;
	return 0;
}

类模板类外实现成员函数

template<typename T1, typename T2 = int>  // T2 默认为 int 类型
class Person
{
public:
	T1 name;
	T2 age;	
	Person(T1 name,T2 age);
	// 友元函数类内声明需要加 <> 说明是模板函数
	friend void print<>(Person<T1,T2> &p);
}

template<typename T1,typename T2 = int>
Person<T1,T2>::Person(T1 name,T2 age)
{
	this->name = name;
	this->id = id;
}
// 分文件编写后缀名改成 .hpp