背景

C++ 是很強大，有各種特性來提高代碼的可重用性，有助于減少開發(fā)的代碼量和工作量。

C++ 提高代碼的可重用性主要有兩方面：

繼承
模板

繼承的特性我已在前面篇章寫過了，本篇主要是說明「模板」的特性。

使用「模板」的特性設計，實際上也就是「泛型」程序設計。

函數(shù)模板

01 變量交換函數(shù)模板

假設我們設計一個交換兩個整型變量的值的函數(shù)，代碼如下：

// 交換兩個整型變量的值的Swap函數(shù)：
void Swap(int & x,int & y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

如果是浮點類型的變量的值交換，則替換 int 類型為 double 即可，代碼如下：

// 交換兩個double型變量的值的Swap函數(shù):
void Swap(double & x,double & y)
{
    double tmp = x;
    x = y;
    y = tmp;
}

那如果是其他變量類型的值交換，那不是每次都要重新寫一次 Swap 函數(shù)？是不是很繁瑣？且代碼后面會越來越冗余。

能否只寫一個 Swap 函數(shù)，就能交換各種類型的變量？

答案是肯定有的，就是用「函數(shù)模板」來解決，「函數(shù)模板」的形式：

template <class 類型參數(shù)1，class 類型參數(shù)2，...>
返回值類型 模板名 (形參表)
{
    函數(shù)體
};

具體 Swap 「函數(shù)模板」代碼如下：

template 就是模板定義的關鍵詞，T 代表的是任意變量的類型。

template <class T>
void Swap(T & x,T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

那么定義好「函數(shù)模板」后，在編譯的時候，編譯器會根據傳入 Swap 函數(shù)的參數(shù)變量類型，自動生成對應參數(shù)變量類型的 Swap 函數(shù)：

int main()
{
    int n = 1,m = 2;
    Swap(n,m); //編譯器自動生成 void Swap(int & ,int & )函數(shù)
    
    double f = 1.2,g = 2.3;
    Swap(f,g); //編譯器自動生成 void Swap(double & ,double & )函數(shù)
    
    return 0;
}

上面的實例化函數(shù)模板的例子，是讓編譯器自己來判斷傳入的變量類型，那么我們也可以自己指定函數(shù)模板的變量類型，具體代碼如下：

int main()
{
    int n = 1,m = 2;
    Swap<int>(n,m);     // 指定模板函數(shù)的變量類型為int
    
    double f = 1.2,g = 2.3;
    Swap<double>(f,g); // 指定模板函數(shù)的變量類型為double
    
    return 0;
}

02 查詢數(shù)組最大值函數(shù)模板

在舉一個例子，下面的 MaxElement 函數(shù)定義成了函數(shù)模板，這樣不管是 int、double、char 等類型的數(shù)組，都可以使用該函數(shù)來查數(shù)組最大的值，代碼如下：

// 求數(shù)組最大元素的MaxElement函數(shù)模板
template <class T>
T MaxElement(T a[], int size) // size是數(shù)組元素個數(shù)
{
    T tmpMax = a[0];
    for(int i = 1;i < size;++i)
    {
        if(tmpMax < a[i])
        {
            tmpMax = a[i];
        }
    }
    return tmpMax;
}

03 多個類型參數(shù)模板函數(shù)

函數(shù)模板中，可以不止一個類型的參數(shù)：

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

T1 是傳入的第一種任意變量類型，T2 是傳入的第二種任意變量類型。

04 函數(shù)模板的重載

函數(shù)模板可以重載，只要它們的形參表或類型參數(shù)表不同即可。

// 模板函數(shù) 1
template<class T1, class T2>
void print(T1 arg1, T2 arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

// 模板函數(shù) 2
template<class T>
void print(T arg1, T arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

// 模板函數(shù) 3
template<class T,class T2>
void print(T arg1, T arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

上面都是 print(參數(shù)1, 參數(shù)2) 模板函數(shù)的重載，因為「形參表」或「類型參數(shù)表」名字不同。

05 函數(shù)模板和函數(shù)的次序

在有多個函數(shù)和函數(shù)模板名字相同的情況下，編譯器如下規(guī)則處理一條函數(shù)調用語句：

先找參數(shù)完全匹配的普通函數(shù)（非由模板實例化而得的函數(shù)）；
再找參數(shù)完全匹配的模板函數(shù)；
再找實參數(shù)經過自動類型轉換后能夠匹配的普通函數(shù)；
上面的都找不到，則報錯。

代碼例子如下：

// 模板函數(shù) - 1個參數(shù)類型
template <class T>
T Max(T a, T b) 
{
    cout << "TemplateMax" <<endl; return 0;
}

// 模板函數(shù) - 2個參數(shù)類型
template <class T, class T2>
T Max(T a, T2 b) 
{
    cout << "TemplateMax2" <<endl; return 0;
}

// 普通函數(shù)
double Max(double a, double b)
{
    cout << "MyMax" << endl;
    return 0;
}

int main() 
{
    int i=4, j=5;
    
    // 輸出MyMax - 匹配普通函數(shù)
    Max( 1.2, 3.4 ); 
    
    //輸出TemplateMax - 匹配參數(shù)一樣的模板函
    Max( i, j );
    
    //輸出TemplateMax2 - 匹配參數(shù)類型不同的模板函數(shù)
    Max( 1.2, 3 );   
    
    return 0;
}

匹配模板函數(shù)時，當模板函數(shù)只有一個參數(shù)類型時，傳入了不同的參數(shù)類型，是不進行類型自動轉換，具體例子如下：

// 模板函數(shù) - 1個參數(shù)類型
template<class T>
T myFunction( T arg1, T arg2)
{ 
    cout<<arg1<<" "<<arg2<<"\n"; 
    return arg1;
}

...

// OK ：替換 T 為 int 類型
myFunction( 5, 7); 

// OK ：替換 T 為 double 類型  
myFunction(5.8, 8.4);

// error ：沒有匹配到myFunction(int, double)函數(shù)
myFunction(5, 8.4);

類模板

01 類模板的定義

為了多快好省地定義出一批相似的類,可以定義「類模板」，然后由類模板生成不同的類。

類模板的定義形式如下：

template <class 類型參數(shù)1，class 類型參數(shù)2，...> //類型參數(shù)表
class 類模板名
{
   成員函數(shù)和成員變量
};

用類模板定義對象的寫法：

類模板名<真實類型參數(shù)表> 對象名(構造函數(shù)實參表);

02 Pair類模板例子

接下來，用 Pair 類用類模板的方式的實現(xiàn)，Pair 是一對的意思，也就是實現(xiàn)一個鍵值對（key-value）的關系的類。

// 類模板
template <class T1, class T2>
class Pair
{
public:
    Pair(T1 k, T2 v):m_key(k),m_value(v) {};
    bool operator < (const Pair<T1,T2> & p) const;
private:
    T1 m_key;
    T2 m_value;
};

// 類模板里成員函數(shù)的寫法
template <class T1, class T2>
bool Pair<T1,T2>::operator < (const Pair<T1,T2> &p) const
{
    return m_value < p.m_value;
}

int main()
{
    Pair<string,int> Astudent("Jay",20); 
    Pair<string,int> Bstudent("Tom",21);
    
    cout << (Astudent < Bstudent) << endl;
    
    return 0;
}

輸出結果：

需要注意的是，同一個類模板的兩個模板類是不兼容的：

Pair<string,int> *p;
Pair<string,double> a;
p = & a; //錯誤?。?

03 函數(shù)模板作為類模板成員

當函數(shù)模板作為類模板的成員函數(shù)時，是可以單獨寫成函數(shù)模板的形式，成員函數(shù)模板在使用的時候，編譯器才會把函數(shù)模板根據傳入的函數(shù)參數(shù)進行實例化，例子如下：

// 類模板
template <class T>
class A
{
public:
    template<class T2>
    void Func(T2 t) { cout << t; } // 成員函數(shù)模板
};

int main()
{
    A<int> a;
    a.Func('K');     //成員函數(shù)模板 Func被實例化
    a.Func("hello"); //成員函數(shù)模板 Func再次被實例化

    return 0;
}

04 類模板與非類型參數(shù)

類模板的“<類型參數(shù)表>”中可以出現(xiàn)非類型參數(shù)：

template <class T, int size>
class CArray
{
public:
    void Print( )
    {
        for( int i = 0;i < size; ++i)
        cout << array[i] << endl;
    }
private:
    T array[size];
};

CArray<double,40> a2;
CArray<int,50> a3; //a2和a3屬于不同的類

類模板與派生

01 類模板從類模板派生

image

上圖的代碼例子如下：

// 基類 - 類模板
template <class T1,class T2>
class A 
{
    T1 v1; T2 v2;
};

// 派生類 - 類模板
template <class T1,class T2>
class B:public A<T2,T1> 
{
    T1 v3; T2 v4;
};

// 派生類 - 類模板
template <class T>
class C:public B<T,T> 
{
    T v5;
};

int main() 
{
    B<int,double> obj1; 
    C<int> obj2;
    return 0;
}

02 類模板從模板類派生

image

上圖的代碼例子如下：

template <class T1,class T2>
class A 
{
    T1 v1; T2 v2;
};

template <class T>
class B:public A<int,double>  // A<int,double> 模板類
{
    T v;
};

int main() 
{
    //自動生成兩個模板類 ：A<int,double> 和 B<char>
    B<char> obj1;
    return 0;
}

03 類模板從普通類派生

image

上圖的代碼例子如下：

// 基類 - 普通類
class A 
{
    int v1;
};

// 派生類 - 類模板
template <class T>
class B:public A  // 所有從B實例化得到的類 ，都以A為基類
{ 
    T v;
};

int main() 
{
    B<char> obj1;
    return 0;
}

04 普通類從模板類派生

image

上圖的代碼例子如下：

template <class T>
class A 
{
    T v1;
};

class B:public A<int> 
{
    double v;
};

int main() 
{
    B obj1;
    return 0;
}

類模板與友元

01 函數(shù)、類、類的成員函數(shù)作為類模板的友元

代碼例子如下：

// 普通函數(shù)
void Func1() { } 

// 普通類
class A { }; 

// 普通類
class B 
{
    public:
    void Func() { } // 成員函數(shù)
};

// 類模板
template <class T>
class Tmp
{
    friend void Func1();    // 友元函數(shù)
    friend class A;         // 友元類
    friend void B::Func();  // 友元類的成員函數(shù)
}; // 任何從 Tmp 實例化來的類 ，都有以上三個友元

02 函數(shù)模板作為類模板的友元

// 類模板
template <class T1,class T2>
class Pair
{
private:
    T1 key;   //關鍵字
    T2 value; //值
public:
    Pair(T1 k,T2 v):key(k),value(v) { };
    
    // 友元函數(shù)模板
    template <class T3,class T4>
    friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);
};

// 函數(shù)模板
template <class T3,class T4>
ostream & operator<< (ostream & o, const Pair<T3,T4> & 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)

03 函數(shù)模板作為類的友元

// 普通類
class A
{
private:
    int v;
public:
    A(int n):v(n) { }
    
    template <class T>
    friend void Print(const T & p); // 函數(shù)模板
};

// 函數(shù)模板
template <class T>
void Print(const T & p)
{
    cout << p.v;
}

int main() 
{
    A a(4);
    Print(a);
    return 0;
}

輸出結果：

04 類模板作為類模板的友元

// 類模板
template <class T>
class B 
{
private:
    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); // 實例化B模板類
        cout << o.v << endl;
    }
};

int main()
{
    A<double> a;
    a.Func ();
    return 0;
}

輸出結果：

類模板與靜態(tài)成員變量

類模板中可以定義靜態(tài)成員，那么從該類模板實例化得到的所有類，都包含同樣的靜態(tài)成員。

template <class T>
class A
{
private:
    static int count; // 靜態(tài)成員
public:
    A() { count ++; }
    ~A() { count -- ; };
    A( A & ) { count ++ ; }
    
    static void PrintCount() { cout << count << endl; } // 靜態(tài)函數(shù)
};

template<> int A<int>::count = 0;    // 初始化
template<> int A<double>::count = 0; // 初始化

int main()
{
    A<int> ia;  
    A<double> da; // da和ia不是相同模板類
    ia.PrintCount();
    da.PrintCount();
    return 0;
}

輸出：

1
1

上面的代碼需要注意的點：

類模板里的靜態(tài)成員初始化的時候，最前面要加template<>。
ia 和 da 對象是不同的模板類，因為類型參數(shù)是不一致，所以也就是不同的模板類。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

C++ 模板常見特性（函數(shù)模板、類模板）

C++ 模板常見特性（函數(shù)模板、類模板）

背景

函數(shù)模板

01 變量交換函數(shù)模板

02 查詢數(shù)組最大值函數(shù)模板

03 多個類型參數(shù)模板函數(shù)

04 函數(shù)模板的重載

05 函數(shù)模板和函數(shù)的次序

類模板

01 類模板的定義

02 Pair類模板例子

03 函數(shù)模板作為類模板成員

04 類模板與非類型參數(shù)

類模板與派生

01 類模板從類模板派生

02 類模板從模板類派生

03 類模板從普通類派生

04 普通類從模板類派生

類模板與友元

01 函數(shù)、類、類的成員函數(shù)作為類模板的友元

02 函數(shù)模板作為類模板的友元

03 函數(shù)模板作為類的友元

04 類模板作為類模板的友元

類模板與靜態(tài)成員變量

相關閱讀更多精彩內容

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

C++ 模板常見特性（函數(shù)模板、類模板）

背景

函數(shù)模板

01 變量交換函數(shù)模板

02 查詢數(shù)組最大值函數(shù)模板

03 多個類型參數(shù)模板函數(shù)

04 函數(shù)模板的重載

05 函數(shù)模板和函數(shù)的次序

類模板

01 類模板的定義

02 Pair類模板例子

03 函數(shù)模板作為類模板成員

04 類模板與非類型參數(shù)

類模板與派生

01 類模板從類模板派生

02 類模板從模板類派生

03 類模板從普通類派生

04 普通類從模板類派生

類模板與友元

01 函數(shù)、類、類的成員函數(shù)作為類模板的友元

02 函數(shù)模板作為類模板的友元

03 函數(shù)模板作為類的友元

04 類模板作為類模板的友元

類模板與靜態(tài)成員變量

相關閱讀更多精彩內容

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

C++ 模板常見特性（函數(shù)模板、類模板）

01 函數(shù)、類、類的成員函數(shù)作為類模板的友元