C++泛型程式設計函(數模板+類別範本)

2022-02-24 19:00:35

一、函數模板

1.函數模板介紹

① 函數模板的產生背景:

在程式設計時多多少少會因為函數引數不同寫幾個過載函數；
函數模板的出現解決了僅僅因為引數型別不同而進行的函數過載;

解決方法:讓型別作為引數傳進函數或者自動型別推導,從而實現不同的功能;

② 函數模板的語法：

tmplate<typename T>

返回型別函數名(參數列){函數體}

③ 函數模板的呼叫方式:

1.明顯的呼叫函數名<引數型別>（實參）;-------------常用
2.自動函數推導函數名（實參）

④ 函數模板的本質:型別引數化！

函數模板舉例

過載了三次的max函數,使用函數模板一次就可以解決

#include<iostream>
using namespace std;
//--------------------------------函數模板前的比較大小
int  max(int a,char b) {
    return (a > b ? a : b);
}
float max(float a, float b) {
    return (a > b ? a : b);
}
long int max(long int a, long int b) {
    return (a > b ? a : b);
}
//--------------------------------用函數模板進行比較大小
template<typename T>
T max(T& a, T& b) {
    return (a > b ? a : b);
}
int main_001() {
    int a = 10;
    int b = 20;
    char a2 = 'a',b2='b';
    cout << max<int >(a, b) << endl;
    cout<<max(a, b)<<endl;
    cout << max(a2, b2) << endl;;
    return 0;
}

2.函數模板與過載函數的關係

① 普通函數的特性:

可以(隱式)進行引數型別自動轉換；

② 函數模板的特性:

數引數型別相同的話傳進來的實參型別也必須相同(不允許自動轉換);

呼叫規則:

呼叫函數時優先考慮普通函數
如果函數模板會有一個更好的匹配,那麼選擇模板函數；
可以通過空模板實參列表的語法限定編譯器只通過模板匹配；
函數模板像普通函數一樣也可以被過載

使用規則如下：

clude<iostream>
using namespace std;
//此函數模板T1 T2代表兩個不同型別的引數
//所以傳進來的引數也要是不同型別（可以通過簡單的操作改為傳相同型別的引數）
template<typename T1,typename T2>
int  myadd(T1 a, T2 b) {
    return a + b;
}
int myadd(int a, int b) {
    return a + b;
}
int myadd(int a, char b) {
    return a + b;
}
int main() {
    int a = 10;
    int b = 20;
    char c = 'c';
    cout << myadd(a,b) << endl;//----------呼叫add(int,int)-----優先匹配的普通函數
    cout << myadd(a,c) << endl;//----------呼叫add(int ,char)
    cout << myadd(c,a) << endl;//----------呼叫add(t1,t2)-------沒有該型別的普通函數就呼叫模板函數
    cout << myadd(c,c) << endl;//----------呼叫add(t1,t2)
    cout << myadd<>(a, b) << endl;//-------強制呼叫add(t1,t2)
    return 0;
}

3.函數模板實現機制

① 函數模板與模板函數：

1.函數模板:------------------------------僅僅是一個模板,並未被範例化(空殼子)

template <typename T>

返回型別函數名 (參數列){函數體}

2.模板函數:------------------------------通過型別的傳入,將函數模板範例化

函數模板的函數名<型別名>(參數列);

② 函數模板機制剖析：

函數模板並不會直接產生能處理任意型別的引數的函數;
而是通過產生對應的模板函數實現對不同型別引數的處理；

函數模板進行兩次編譯：
1.函數模板宣告的地方,對函數模板程式碼本身進行編譯
2.將型別插入後在呼叫的地方對插入引數後的程式碼進行編譯

二、類別範本

1.類別範本基本語法

① 單個模板類:

基本語法:

template<typename T>或template<class T>
class 類名{private: T a;};

注意事項:

模板類是一個抽象類,定義物件時需要引數型別的傳入

具體實現如下:

#include<iostream>
using namespace std;
template <class T>
class A {
public:
    void seta(T &a) {
        this->a = a;
    }
    void printA() {
        cout << this->a << endl;
    }
protected:
    T a;
};
int main() {
    int x = 888;
    A<int> a1;
    a1.seta(x);
    a1.printA();
    char xx = 'x';
    A<char> a2;
    a2.seta(xx);
    a2.printA();
    return 0;
}

② 模板類被具體類繼承:

基本語法:

定義: class 具體類名 :public 模板類名<引數型別>{};

繼承後的操作與普通類之間繼承一樣;

實現方法如下:

#include<iostream>
using namespace std;
template <class T>
class A {
public:
    void seta(T &a) {
        this->a = a;
    }
    void printA() {
        cout << this->a << endl;
    }
protected:
    T a;
};
class B :public A<int> {
private:
    int b;
public:
    void setb(int b) {
        this->b = b;
    }
    void printB() {
        cout << this->b << endl;
    }
};
int main() {
    int x = 888;
    B b1;
    b1.setb(999);
    b1.printB();
    b1.seta(x);
    b1.printA();
    return 0;
}

③ 模板類被模板類繼承

類繼承:

基本語法:
template<typename T>
class 模板類名 :public 基礎類別模板類名<T>{ };

具體實現方法:

#include<iostream>
using namespace std;
template <class T>
class A {
public:
    void seta(T &a) {
        this->a = a;
    }
    void printA() {
        cout << this->a << endl;
    }
protected:
    T a;
};
template <class T>
class C :public A<T> {//----------語法所在地
private:
    T c;
public:
    void setC(T &c) {
        this->c = c;
    }
    void printC() {
        cout << this->c << endl;
    }
};
class B :public A<int> {
private:
    int b;
public:
    void setb(int b) {
        this->b = b;
    }
    void printB() {
        cout << this->b << endl;
    }
};
int main() {
    int p = 99;
    C<int> c1;
    c1.setC(p);
    c1.printC();
    char pp = '6';
    C<char> c2;
    c2.setC(pp);
    c2.printC();
    return 0;
}

2.類別範本內函數的整體佈局【分檔案使用類別範本】

①所有函數均在類的內部

實現方法如下:

#include<iostream>
using namespace std;
template<typename T>
class complex1 {
    friend ostream& operator<< <T>(ostream &out, complex1 &obj);
private:
    T a;
    T b;
public:
    complex1(T a=0, T b=0) {
        this->a = a;
        this->b = b;
    }
    complex1 operator+(complex1 obj) {
        complex1 tem(a+obj.a,b+obj.b);
        return tem;
    }
    void printa() {
        cout << a << endl;
    }
    void printb() {
        cout << b << endl;
    }
    
};
template<typename T>
ostream& operator<<(ostream &out, complex1<T> &obj) {
        out << obj.a << "+" << obj.b << "i" << endl;
        return out;
    }
int main_11() {
    complex1<int> a(1, 2), b(3, 4);
    complex1<int>c = a + b;
    cout << c << a << b;
    a.printa();
    a.printb();
    return 0;
}

②所有函數均在類的外部,但在同一檔案

員函數實現語法:

原型: 類名函數名（參數列）;

修改後的形式:
template <typename T>
類名<T> 函數名（參數列）------參數列該加T的就加T

流運運算元友元函數實現語法:
原型(宣告): friend 返回型別函數名（參數列）；

修改後的形式:
   (宣告) ：friend 返回型別函數名 <T> (參數列) ；
   template<typename T>
   (函數實現): 返回型別函數名（參數列）{};------類的物件做引數時修改為類名<T>;

具體實現如下：

#include<iostream>
using namespace std;
template<typename T>
class complex2 {
    friend ostream& operator<< <T>(ostream& out, complex2& obj);
private:
    T a;
    T b;
public:
    complex2(T a = 0, T b = 0);
    complex2 operator+(complex2 obj);
    void printa();
    void printb();
};
template<typename T>
complex2<T>::complex2<T>(T a , T b ) {
    this->a = a;
    this->b = b;
}
template<typename T>
complex2<T> complex2<T>::operator+(complex2 obj) {
    complex2 tem(a + obj.a, b + obj.b);
    return tem;
}
template<typename T>
void complex2<T>::printa() {
    cout << a << endl;
}
template<typename T>
void complex2<T>::printb() {
    cout << b << endl;
}
template<typename T>
ostream& operator<<(ostream& out, complex2<T>& obj) {
    out << obj.a << "+" << obj.b << "i" << endl;
    return out;
}
int main_dd() {
    complex2<int> a(1, 2), b(3, 4);
    complex2<int>c = a + b;
    cout << c << a << b;
    a.printa();
    a.printb();
    return 0;
}

③ 所有函數均在類的外部,但在不同檔案

將類分檔案寫後,將類函數實現的部分包含進主函數所在的檔案

實現方法:

include"xxxx.cpp"

範例:

標頭檔案：

#pragma once
#include<iostream>
using namespace std;
template<typename T>
class complex {
    friend ostream& operator<< <T>(ostream& out, complex& obj);
private:
    T a;
    T b;
public:
    complex(T a = 0, T b = 0);
    complex operator+(complex obj);
    void printa();
    void printb();
};

函數實現：

#include<iostream>
using namespace std;
#include"複數類3.h"
template<typename T>
complex<T>::complex<T>(T a, T b) {
    this->a = a;
    this->b = b;
}
template<typename T>
complex<T> complex<T>::operator+(complex obj) {
    complex tem(a + obj.a, b + obj.b);
    return tem;
}
template<typename T>
void complex<T>::printa() {
    cout << a << endl;
}
template<typename T>
void complex<T>::printb() {
    cout << b << endl;
}
template<typename T>
ostream& operator<<(ostream& out, complex<T>& obj) {
    out << obj.a << "+" << obj.b << "i" << endl;
    return out;
}

主函數：

#include<iostream>
using namespace std;
#include"複數類3h.cpp"//重點
int main() {
    complex<int> a(1, 2), b(3, 4);
    complex<int>c = a + b;
    cout << c << a << b;
    a.printa();
    a.printb();
    return 0;
}

3.類別範本的static與模板類的static

類別範本定義了變數,函數實現的步驟,但沒有資料型別的插入,所以類別範本僅僅是模板;
類別範本的實現機制是程式設計師給出資料型別,編譯器對具體的類進行實現,產生不同型別的類;
所以,類別範本中的靜態成員變數是某個型別的具體類獨有的成員變數;只是被該型別物件所公有

區別如下：

模板類中的static變數可以被該模板類的物件公用
類別範本的static經過類不同方式的範例化,會產生不同的static變數，
且該變數只供初始化他的類使用

4.陣列實現萬能容器

testarray類是一個類別範本，裡面有一個指標型別,所以通過程式設計師主動實現模板類傳參可以儲存不同型別的資料,也就是說testarray理論可以儲存任意型別的資料。

#include<iostream>
using namespace std;
class teacher {
private:
    char *name;
    char *sex;
    int age;
public:
    teacher() {
        name = NULL;
        sex = NULL;
        age = 0;
    }
    teacher(teacher& obj) {
        if (name != NULL) {
            delete [] name;
            delete[] sex;
        }
        age = obj.age;
        name = new char [sizeof(obj.name)];
        sex = new char[sizeof(obj.sex)];
        strcpy_s(name, sizeof(obj.name), obj.name);
        strcpy_s(sex, sizeof(obj.sex), sex);
    }
    void setname(char *name) {
        this->name = new char[strlen(name)+1];
        strcpy_s(this->name, strlen(name)+1, name);
    }
    void setage(int age) {
        this->age = age;
    }
    void setsex(char* sex) {
        this->sex = new char[strlen(sex)+1];
        strcpy_s(this->sex, strlen(sex)+1, sex);
    }
    friend ostream& operator<<(ostream& out, teacher& obj);
};
ostream& operator<<(ostream& out, teacher& obj) {
    cout << "姓名" << "t" << "性別" << "t" << "年齡" << endl;
    cout << obj.name << "t" << obj.sex << "t" << obj.age << endl;
    return out;
}
ostream& operator<<(ostream& out, teacher& obj);
template <typename T>
class testarray {
    friend ostream& operator<< <T>(ostream& out, testarray& obj);
private:
    int len;
    T* myarray;
public:
    testarray() {
        len = 0;
        myarray = NULL;
    }
    testarray(int len) {
        this->len=len;
        myarray = new T[len];
    }
    testarray(testarray & obj) {
        len = obj.len;
        myarray = new testarray;
        strcmp_s(myarray, len, obj.myarray);
    }
    T& operator[](int xx) {
        return myarray[xx];
    }    
};
template<typename T>
ostream& operator<<(ostream& out,testarray<T>& obj) {
    for (int i = 0;i < obj.len;i++) {
        cout << obj[i] <<" ";
    }
    cout << endl;
    return out;
}
int main() {
    testarray<int> aint(10);
    testarray<char> bchar(10);
    testarray<teacher> tea(3);
    teacher t1, t2, t3;
    char name1[]="小李",name2[]="小朱",name3[]="小黃";
    char sex1[] = "男", sex2[] = "女";
    t1.setname(name1);
    t1.setsex(sex2);
    t1.setage(40);
    t2.setname(name2);
    t2.setsex(sex1);
    t2.setage(20);
    t3.setname(name3);
    t3.setsex(sex1);
    t3.setage(28);
    tea[0] = t1;
    tea[1] = t2;
    tea[2] = t3;
    for (int i = 0;i < 10;i++) {
        aint[i] = i;
    }
    for (int i = 0;i < 10;i++) {
        bchar[i] = i + 97;
    }
    cout << aint;
    cout << bchar;
    cout << tea;
    return 0;
}

效果圖：