深度解析C++的函数模板与类模板

一、函数模板

1、定义

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

template <class T1, class T2> T2 print(T1 arg1, T2 arg2) {     cout<< arg1 << " "<< arg2<<endl;     return arg2; }

2、不通过参数实例化函数模板

#include <iostream> using namespace std; template <class T> T Inc(T n){     return 1 + n; } int main(){     cout << Inc<double>(4)/2; //输出 2.5     return 0; }

3、函数模板可以重载，只要它们的形参表或类型参数表不同即可

template<class T1, class T2> void print(T1 arg1, T2 arg2) {     cout<< arg1 << " "<< arg2<<endl; } template<class T> void print(T arg1, T arg2) {     cout<< arg1 << " "<< arg2<<endl; } template<class T,class T2> void print(T arg1, T arg2) {     cout<< arg1 << " "<< arg2<<endl; }

4、函数模板和函数的次序

在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句

• 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。

• 再找参数完全匹配的模板函数。

• 再找实参数经过自动类型转换后能够匹配的普通函数。

• 上面的都找不到，则报错。

template <class T> T Max( T a, T b) {     cout << "TemplateMax" <<endl; return 0; } template <class T,class T2> T Max( T a, T2 b) {     cout << "TemplateMax2" <<endl; return 0; } double Max(double a, double b){     cout << "MyMax" << endl; return 0; } int main() {     Max( 1.2,3.4);     // 输出MyMax     Max(4, 5);         //输出TemplateMax     Max( 1.2, 3);      //输出TemplateMax2     return 0; }

5、匹配模板函数时，不进行类型自动转换

template<class T> T myFunction( T arg1, T arg2) { cout<<arg1<<" "<<arg2<<"\n"; return arg1;} …… myFunction( 5, 7);      //ok ：replace T with int myFunction( 5.8, 8.4);  //ok： ： replace T with double myFunction( 5, 8.4);    //error ，no matching function for callto 'myFunction(int, double)'

二、类模板

1、定义

在定义类的时候，加上一个/多个类型参数。在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类。

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

（1）类模板里成员函数的写法： template <class 类型参数1，class 类型参数2，……> //类型参数表 返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）{ …… }（2）用类模板定义对象的写法： 类模板名 <真实类型参数表> 对象名(构造函数实参表);

// Pair类模板 template <class T1,class T2> class Pair{ public:     T1 key; //关键字     T2 value; //值     Pair(T1 k,T2 v):key(k),value(v) { };     bool operator < ( const Pair<T1,T2> & p) const; }; template<class T1,class T2> bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{  //Pair的成员函数 operator <     return key < p.key; } int main(){     Pair<string,int> student("Tom",19);   //实例化出一个类 Pair<string,int>     cout << student.key << " " << student.value;     return 0; } //输出： Tom 19

2、用类模板定义对象

• 编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。

• 同一个类模板的两个模板类是不兼容的。

3、函数模版作为类模板成员

template <class T> class A{     public:         template<class T2>         void Func( T2 t) { cout << t; } //成员函数模板 };

4、类模板与非类型参数：类模板的“<类型参数表>”中可以出现非类型参数

template <class T, int size> class CArray{     T array[size]; public:     void Print(){         for( int i = 0;i < size; ++i)         cout << array[i] << endl;     } }; CArray<double,40> a2; CArray<int,50> a3;     //a2和a3属于不同的类

5、类模板与派生

（1）类模板从类模板派生

template <class T1,class T2>              int main() { class A {                                        B<int,double> obj1;     T1 v1; T2 v2;                                C<int> obj2; };                                               return 0; template <class T1,class T2>              } class B:public A<T2,T1> {                 class B<int,double>:     T1 v3; T2 v4;                             public A<double,int>{ };                                            int v3; double v4; template <class T>                        }; class C:public B<T,T> {     T v5; };

（2）类模板从模板类派生

template <class T1,class T2> class A {     T1 v1; T2 v2; }; template <class T> class B:public A<int,double> {     T v; }; int main() {     B<char> obj1;     //自动生成两个模板类 ：A<int,double> 和 B<char>     return 0; }

（3）类模板从普通类派生

class A {     int v1; }; template <class T>     class B:public A { //所有从B实例化得到的类 ，都以A为基类     T v; }; int main() {     B<char> obj1;     return 0; }

（4）普通类从模板类派生

template <class T> class A {     T v1;     int n; }; class B:public A<int> {     double v; }; int main() {     B obj1;     return 0; }

void Func1() { } class A { }; class B{     public:         void Func() { } }; template <class T> class Tmpl{     friend void Func1();     friend class A;     friend void B::Func(); }; //任何从Tmp1实例化来的类 ，都有以上三个友元

（2）函数模板作为类模板的友元

#include <iostream> #include <string> using namespace std; template <class T1,class T2> class Pair{     private:         T1 key; //关键字         T2 value; //值     public:         Pair(T1 k,T2 v):key(k),value(v) { };         bool operator < ( const Pair<T1,T2> & p) const;         template <class T3,class T4>         friend ostream & operator<< ( ostream & o,const Pair<T3,T4> & p); }; template <class T1,class T2> bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //"小"的意思就是关键字小     return key < p.key; } template <class T1,class T2> ostream & operator<< (ostream & o,const Pair<T1,T2> & p){     o << "(" << p.key << "," << p.value << ")" ;     return o; } int main() {     Pair<string,int> student("Tom",29);     Pair<int,double> obj(12,3.14);     cout << student << " " << obj;     return 0; } //输出： (Tom,29) (12,3.14) 任意从 template <class T1,class T2>        ostream & operator<< (ostream & o,const Pair<T1,T2> & p) 生成的函数，都是任意Pair摸板类的友元

（3）函数模板作为类的友元

#include <iostream> using namespace std; class A {     int v; public:     A(int n):v(n) { }     template <class T>     friend void Print(const T & p); }; template <class T> void Print(const T & p){     cout << p.v; } int main() {     A a(4);     Print(a);     return 0; } //输出：4

（4）类模板作为类模板的友元

template <class T> class B {     T v; public:     B(T n):v(n) { }     template <class T2>     friend class A; }; template <class T> class A {     public:     void Func( )  {         B<int> o(10);         cout << o.v << endl;     } };

7、类模板与静态成员变量

类模板中可以定义静态成员 ，那么从该类模板实例化得到的所有类 ，都包含同样的静态成员 。

#include <iostream> using namespace std; template <class T> class A{     private:         static int count;     public:         A() { count ++; }         ~A() { count -- ; };         A( A & ) { count ++ ; }         static void PrintCount() { cout << count << endl; } }; template<> int A<int>::count = 0; template<> int A<double>::count = 0; int main(){     A<int> ia;     A<double> da;     ia.PrintCount();     da.PrintCount();     return 0; } //输出：1  1

相关推荐：

用C++对C++语法格式进行分析

c++11 - C++中如何定义一个指向函数的智能指针？

以上就是深度解析C++的函数模板与类模板的详细内容，更多内容请关注技术你好其它相关文章！