第七章 2.泛型编程（模板）

作用：提高程序可复用性，程序编译时自动生成相应函数

函数模板和类模板中的类型参数表中class和typename可相互替换

函数模板

2. 格式

   template
   返回值类型 模板名（参数表）{
       函数体
   }
   

3. 匹配顺序

   • 参数完全匹配的普通函数
   • 参数完全匹配的模板函数（匹配模板函数时，不会进行自动类型转换）
   • 实参经过自动类型转换 后匹配的普通函数
   • 上述匹配均不存在则报错

4. 可通过模板函数名<类型>不通过参数实例化

5. 模板函数也可以重载，只要形参表或类型参数表不同即可

6. 支持函数指针类型

   #include
   using namespace std;
   template
   void Map(T s,T e,T x,Pred op){
   	for(;s!=e;s++,x++)  *x=op(*s);
   }
   double Square(double x){return x*x;}
   int Cube(int x){return x*x*x;}
   
   template
   void Output(T &arr){
   	for(int i=0;i<(sizeof(arr)/sizeof(*arr));++i) cout<

类模板

1. 定义方式：

   template
   class ClassName{
       Member Function;
       Member Variable;
       ReturnType Func(Parameter Table);
   }
   //在类外定义成员函数
   template
   ReturnType ClassName::Func(Parameter Table){ ... }
   //通过类模板定义对象
   ClassName Obj;
   
   //类模板的类型参数表可以包含非类型参数
   template
   class Count{
       public:
       	T arr[size];
       	void Output(){
               for(int i=0;i test;
   

2. 在类模板内定义函数模板

   class Test{
   	public:
   		template
   		void Func(T2 a){
   			cout< a;
   	a.Func("Test");
   	return 0;
   }
   

3. 编译器由类模板生成类的过程称为类的实例化，生成的类称为模板类

4. 同一类模板生成的不同模板类不兼容（即两个独立不同的类型）

类模板与派生

1. 类模板从类模板派生

2. 类模板从模板类派生

3. 类模板从普通类派生

4. 普通类从模板类派生

   template
   class A{
       T1 v1;
       T2 v2;
   }
   //类模板从类模板中派生
   template 
   class B:public A{ //A模板实例化顺序不一定相同
       T1 v3;
       T2 v4;
   }
   //类模板从模板类派生
   template
   class B:public A{}
   //类模板从普通类中派生
   class C{int a;}
   template 
   class B:public C{
       T val;
   }
   //普通类从模板类中派生
   class D:public A{ int a;}
   

类模板与友元

1. 函数、类、类成员函数作为类模板友元

   void Func1(){}
   class A{
       int a;
       public:
       void Func(){}
   }
   template
   class B{
       T a;
       public:
       friend void Func1(); //友元函数
       friend class A; //友元类
       friend void A::Func(); //类成员函数作为友元类
   }
   

2. 函数模板作为类模板友元

   template
   class Pair{
   	T1 key;
   	T2 value;
   public:
        Pair(T1 k,T2 v):key(k),value(v){}
        //函数模板作为类模板友元
        template //不能写T1、T2，否则可能报错
        friend ostream& operator<< (ostream &out,const Pair &p); 
   };
   template
   ostream& operator<< (ostream& out,const Pair &p){
   	return out<<"("<

3. 函数模板作为类的友元

   class A{
       int v;
   public:
       A(int n):v(n){}
       template
       friend void Print(const T& p); 
   }
   template
   void Print(const T& p){cout<

4. 类模板作为类模板友元

   template
   class A{
       T v;
       public:
       A(int n):v(n){}
       template //不能写成T，可能报错
       friend class B;
   }
   template
   class B{
      public:
           void Func(){
               A o(10);
               cout<

类模板中的static成员

1. 统一类模板的不同类型的实例static相互独立，相同类型示例共用

   class A{
   	static int count;
   	public:
   		void PrintCnt(){ cout< int A::count=0; //类模板中static变量声明方式
   template<> int A::count=0;
   int main(){
   	A a,c;
   	a.PrintCnt(); //2
   	A b;
   	b.PrintCnt(); //1
   	return 0;
   }