C++模板常见特性（函数模板、类模板）-源码交易平台丞旭猿

// 交换两个整型变量的值的Swap函数：voidSwap(int&x,int&y){inttmp=x;x=y;y=tmp;}

// 交换两个double型变量的值的Swap函数:voidSwap(double&x,double&y){doubletmp=x;x=y;y=tmp;}

template<class类型参数1，class类型参数2，...>返回值类型模板名(形参表){函数体};

template<classT>voidSwap(T&x,T&y){Ttmp=x;x=y;y=tmp;}

intmain(){intn=1,m=2;Swap(n,m);//编译器自动生成 void Swap(int & ,int & )函数doublef=1.2,g=2.3;Swap(f,g);//编译器自动生成 void Swap(double & ,double & )函数return0;}

intmain(){intn=1,m=2;Swap<int>(n,m);// 指定模板函数的变量类型为intdoublef=1.2,g=2.3;Swap<double>(f,g);// 指定模板函数的变量类型为doublereturn0;}

// 求数组最大元素的MaxElement函数模板template<classT>TMaxElement(Ta[],intsize)// size是数组元素个数{TtmpMax=a[0];for(inti=1;i<size;++i){if(tmpMax<a[i]){tmpMax=a[i];}}returntmpMax;}

template<classT1,classT2>T2MyFun(T1arg1,T2arg2){cout<<arg1<<" "<<arg2<<endl;returnarg2;}

// 模板函数 1template<classT1,classT2>voidprint(T1arg1,T2arg2){cout<<arg1<<" "<<arg2<<endl;}// 模板函数 2template<classT>voidprint(Targ1,Targ2){cout<<arg1<<" "<<arg2<<endl;}// 模板函数 3template<classT,classT2>voidprint(Targ1,Targ2){cout<<arg1<<" "<<arg2<<endl;}

// 模板函数 - 1个参数类型template<classT>TMax(Ta,Tb){cout<<"TemplateMax"<<endl;return0;}// 模板函数 - 2个参数类型template<classT,classT2>TMax(Ta,T2b){cout<<"TemplateMax2"<<endl;return0;}// 普通函数doubleMax(doublea,doubleb){cout<<"MyMax"<<endl;return0;}intmain(){inti=4,j=5;// 输出MyMax - 匹配普通函数Max(1.2,3.4);//输出TemplateMax - 匹配参数一样的模板函Max(i,j);//输出TemplateMax2 - 匹配参数类型不同的模板函数Max(1.2,3);return0;}

// 模板函数 - 1个参数类型template<classT>TmyFunction(Targ1,Targ2){cout<<arg1<<" "<<arg2<<"\n";returnarg1;}...// OK ：替换 T 为 int 类型myFunction(5,7);// OK ：替换 T 为 double 类型myFunction(5.8,8.4);// error ：没有匹配到myFunction(int, double)函数myFunction(5,8.4);

template<class类型参数1，class类型参数2，...>//类型参数表class类模板名{成员函数和成员变量};

类模板名<真实类型参数表>对象名(构造函数实参表);

// 类模板template<classT1,classT2>classPair{public:Pair(T1k,T2v):m_key(k),m_value(v){};booloperator<(constPair<T1,T2>&p)const;private:T1m_key;T2m_value;};// 类模板里成员函数的写法template<classT1,classT2>boolPair<T1,T2>::operator<(constPair<T1,T2>&p)const{returnm_value<p.m_value;}intmain(){Pair<string,int>Astudent("Jay",20);Pair<string,int>Bstudent("Tom",21);cout<<(Astudent<Bstudent)<<endl;return0;}

1

Pair<string,int>*p;Pair<string,double>a;p=&a;//错误！！

// 类模板template<classT>classA{public:template<classT2>voidFunc(T2t){cout<<t;}// 成员函数模板};intmain(){A<int>a;a.Func(K);//成员函数模板 Func被实例化a.Func("hello");//成员函数模板 Func再次被实例化return0;}

template<classT,intsize>classCArray{public:voidPrint(){for(inti=0;i<size;++i)cout<<array[i]<<endl;}private:Tarray[size];};CArray<double,40>a2;CArray<int,50>a3;//a2和a3属于不同的类

// 基类 - 类模板template<classT1,classT2>classA{T1v1;T2v2;};// 派生类 - 类模板template<classT1,classT2>classB:publicA<T2,T1>{T1v3;T2v4;};// 派生类 - 类模板template<classT>classC:publicB<T,T>{Tv5;};intmain(){B<int,double>obj1;C<int>obj2;return0;}

template<classT1,classT2>classA{T1v1;T2v2;};template<classT>classB:publicA<int,double>// A 模板类{Tv;};intmain(){//自动生成两个模板类 ：A 和 BB<char>obj1;return0;}

// 基类 - 普通类classA{intv1;};// 派生类 - 类模板template<classT>classB:publicA// 所有从B实例化得到的类 ，都以A为基类{Tv;};intmain(){B<char>obj1;return0;}

template<classT>classA{Tv1;};classB:publicA<int>{doublev;};intmain(){Bobj1;return0;}

// 普通函数voidFunc1(){}// 普通类classA{};// 普通类classB{public:voidFunc(){}// 成员函数};// 类模板template<classT>classTmp{friendvoidFunc1();// 友元函数friendclassA;// 友元类friendvoidB::Func();// 友元类的成员函数};// 任何从 Tmp 实例化来的类 ，都有以上三个友元

// 类模板template<classT1,classT2>classPair{private:T1key;//关键字T2value;//值public:Pair(T1k,T2v):key(k),value(v){};// 友元函数模板template<classT3,classT4>friendostream&operator<<(ostream&o,constPair<T3,T4>&p);};// 函数模板template<classT3,classT4>ostream&operator<<(ostream&o,constPair<T3,T4>&p){o<<"("<<p.key<<","<<p.value<<")";returno;}intmain(){Pair<string,int>student("Tom",29);Pair<int,double>obj(12,3.14);cout<<student<<" "<<obj;return0;}

(Tom,29)(12,3.14)

// 普通类classA{private:intv;public:A(intn):v(n){}template<classT>friendvoidPrint(constT&p);// 函数模板};// 函数模板template<classT>voidPrint(constT&p){cout<<p.v;}intmain(){Aa(4);Print(a);return0;}

4

// 类模板template<classT>classB{private:Tv;public:B(Tn):v(n){}template<classT2>friendclassA;// 友元类模板};// 类模板template<classT>classA{public:voidFunc(){B<int>o(10);// 实例化B模板类cout<<o.v<<endl;}};intmain(){A<double>a;a.Func();return0;}

10

template<classT>classA{private:staticintcount;// 静态成员public:A(){count++;}~A(){count--;};A(A&){count++;}staticvoidPrintCount(){cout<<count<<endl;}// 静态函数};template<>intA<int>::count=0;// 初始化template<>intA<double>::count=0;// 初始化intmain(){A<int>ia;A<double>da;// da和ia不是相同模板类ia.PrintCount();da.PrintCount();return0;}

1
1