深度解析C++的函式模板與類別模板

一、函數模板

1、定義

   template c2ddccc03335de7990ad903b91664879
   傳回值型別範本名(形參表){
          函數體
   };

#

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 &#39;myFunction(int, double)&#39;

二、類別範本

1、定義

     在定義類別的時候，加上一個/多個型別參數。在使用類別模板時，指定類型參數應該如何替換成具體類型，編譯器據此產生對應的模板類別。

    template 7f7551420f5811d66c1d9d89c972df8b //類型參數表
    class 類模板名{
           成員函數和成員變量
};

（1）類別模板裡成員函數的寫法：
        template 87a385d740d46b5b2107c898e918df59 //類型參數表
傳回值型別範本名稱4830a6c95b785176baf1a8e30a8f30d0::成員函式名稱（參數表）{
             …
        }
（2）使用類別範本定義物件的寫入：

##類別模板名稱fe4bf377ef18fec23835d601328380bc 物件名稱(建構子實參表);

// 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、類別模板與非類型參數：類別模板的「80e842f336150fff8dd90ba36e3aca16」中可以出現非類型參數

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;
}

###6、類別模板與友員函數###（1 ）函數、類別、類別的成員函數作為類別模板的友元###

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++的函式模板與類別模板的詳細內容。更多資訊請關注PHP中文網其他相關文章！