C++模板

系列文章目录

---

文章目录

• 系列文章目录
• 前言
• 一、函数模板
• 二、类模板
• 三、自定义类型当做模板参数
• 四、模板嵌套
• 五、函数模板重载
• 六、类模板特化
•  
• 总结

---

前言

---

一、函数模板

什么是模板 ： 把类型当做未知量，可以忽略类型影响

使用模板后就可以使用一个函数对不同类型的对象经行处理，不必再为其独自另写一个重载；

声明模板的语法：
 

#include <iostream> 
using namespace std;
//typename可以使用class替换
template<typename _ty>//创建模板
_ty jiaf(_ty i,_ty p)
{
	return i + p;
}

int main()
{
	int ji = jiaf(90, 78);//隐式调用
	double p = jiaf<double>(97.6, 56.98);//显示调用
    //上面两个调用的是同一个函数
	return 0;
}

不仅普通函数可以创建模板；类中的成员函数也可以创建模板；

#include <iostream> 
using namespace std;
class A
{public:
	template<class T, class TP>
	T pand(T i, TP o)
	{
		return i+o;
	}
protected:
};
int main()
{
	A a;
	int ji = a.pand(90, 78);//隐式调用
	double p = a.pand<double,double>(97.6, 56.98);//显示调用
	
	return 0;
}

模板也存在缺省的写法

template<class T, class TP=int>
	T pand(T i, TP o)
	{
		return i+o;
	}

 也存在传参操作

template<class T, int ii=3>
T ppp(T i, T p)
{
	return i + p + ii;
}
int main()
{
	int y = ppp<int, 9>(8, 5);//输出22
	int y1 = ppp(5, 8);//输出16
	return 0;
}

 

二、类模板

类也可以通过模板来实现，称为模板类

模板类创建：

template<class T, class TP=int>//此处采用缺省
class A
{public:
	
	T pand(T i, TP o)
	{
		return i+o;
	}
protected:
};

 类模板调用：

注意调用模板类时必须采用   "类名<类型>"     的方式创建对象

#include <iostream> 
using namespace std;
template<class T>
class A
{public:
	
	T pand(T i, T o)
	{
		return i+o;
	}
protected:
	T std;
};
int main()
{
	A<int> a;//调用
}

 在多文件中，类模板 中的声明和实现一定要在通一个文件中，不能分开写。

三、自定义类型当做模板参数

简单来说就是使用自己的类或类型来操作函数模板；

例子：

#include <iostream> 
using namespace std;
class MM//自己创建的类型
{
public:
	MM(const char* i) :uu(i) {}
	friend ostream& operator<<(ostream& pp,MM& i)//运算符重载
	{
		pp << i.uu.c_str() << endl;
		return pp;
	}
protected:
	string uu;
};
template<class T>
class A
{public:
	A(T i) :std(i) {}
	T pand(T i, T o)
	{
		return i+o;
	}
	void print()
	{
		cout << std;
	}
protected:
	T std;
};
int main()
{
	A<MM>a(MM("爱你"));//创建对象
	a.print();
		return 0;
}

四、模板嵌套

简单说就是将两个模板嵌套来使用；

例子：
 

template<class T1 ,class T2>
class PP
{
public:
	PP(T1 i, T2 ii) :p1(i), p2(ii) {}
	friend ostream& operator<<(ostream& pp, PP& i)
	{
		pp << i.p1<<"    "<<i.p2<< endl;

		return pp;
	}
protected:
	T1 p1;
	T2 p2;
};

template<class T>
class A
{public:
	A(T i) :std(i) {}
	T pand(T i, T o)
	{
		return i+o;
	}
	void print()
	{
		cout << std;
	}
protected:
	T std;
};
int main()
{
	A<PP<string,int>>a(PP<string, int>("张三",23));//嵌套了一个模板类
	a.print();
		return 0;
}

 

五、函数模板重载

• 模板和普通函数 ，调用函数函数类型一致情况 优先调用普通函数

• 两个模板同时成立，优先调用类型相似度搞的那个

什么叫相似度高比如一个模板类只有一个可调节的值而另外一个有两可变的值；

例如：

template<class T>//优先调用
void A(T i)
{}
template<class T1, class T2>
void A(T1 i,T2 o)
{}
int main()
{
	A(56,89);//这种情况调用上面那种都能实现，但会优先调用上面的那一个函数
return 0;
}

 

六、类模板特化

特化有两种，局部特化与完全特化；

特化是用来处理一些特殊的情况的；

使用：

template<class T1 ,class T2>
class PP//本体
{
public:
	PP(T1 i, T2 ii) :p1(i), p2(ii) {}
	friend ostream& operator<<(ostream& pp, PP& i)
	{
		pp << i.p1<<"    "<<i.p2<< endl;

		return pp;
	}
protected:
	T1 p1;
	T2 p2;
};
template<class T>
class PP<class T,class T>//局部特化
{
public:
protected:
	T p1;
	T p2;
};
template<>
class PP<string,string>//完全特化
{
public:
protected:
	string p1;
	string p2;
};

---

总结

说的有什么不对的地方还望指出谢谢