C++泛型編程函(數(shù)模板+類模板)

更新時間：2022年02月24日 16:09:59 作者：酷爾。

這篇文章主要介紹了C++泛型編程函(數(shù)模板+類模板),類模板與函數(shù)模板一樣也會經(jīng)過兩次編譯,在此文中重點區(qū)分一下類模板與模板類,函數(shù)模板與模板函數(shù)的概念,泛型編程是C++開發(fā)的一大精髓,靈活地運用泛型編程,需要的朋友可以參考一下

由于C++是靜態(tài)語言,也就是說使用一個數(shù)據(jù)的時候必須先指定類型,這樣的操作在編譯后變量的類型是無法輕易改變的,就導(dǎo)致擴展性太差。或者一個函數(shù)需要很多次重載的時候，代碼顯得冗雜，由此產(chǎn)生了C++函數(shù)模板。

一、函數(shù)模板

1.函數(shù)模板介紹

① 函數(shù)模板的產(chǎn)生背景:

在編程時多多少少會因為函數(shù)參數(shù)不同寫幾個重載函數(shù)；
函數(shù)模板的出現(xiàn)解決了僅僅因為參數(shù)類型不同而進行的函數(shù)重載;

解決方法:讓類型作為參數(shù)傳進函數(shù)或者自動類型推導(dǎo),從而實現(xiàn)不同的功能;

② 函數(shù)模板的語法：

tmplate<typename T>

返回類型函數(shù)名(參數(shù)列表){函數(shù)體}

③ 函數(shù)模板的調(diào)用方式:

1.明顯的調(diào)用函數(shù)名<參數(shù)類型>（實參）;-------------常用
2.自動函數(shù)推導(dǎo) 函數(shù)名（實參）

④ 函數(shù)模板的本質(zhì):類型參數(shù)化！

函數(shù)模板舉例

重載了三次的max函數(shù),使用函數(shù)模板一次就可以解決

#include<iostream>
using namespace std;
//--------------------------------函數(shù)模板前的比較大小
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);
}
//--------------------------------用函數(shù)模板進行比較大小
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.函數(shù)模板與重載函數(shù)的關(guān)系

① 普通函數(shù)的特性:

可以(隱式)進行參數(shù)類型自動轉(zhuǎn)換；

② 函數(shù)模板的特性:

數(shù)參數(shù)類型相同的話傳進來的實參類型也必須相同(不允許自動轉(zhuǎn)換);

調(diào)用規(guī)則:

調(diào)用函數(shù)時優(yōu)先考慮普通函數(shù)
如果函數(shù)模板會有一個更好的匹配,那么選擇模板函數(shù)；
可以通過空模板實參列表的語法限定編譯器只通過模板匹配；
函數(shù)模板像普通函數(shù)一樣也可以被重載

使用規(guī)則如下：

clude<iostream>
using namespace std;
//此函數(shù)模板T1 T2代表兩個不同類型的參數(shù)
//所以傳進來的參數(shù)也要是不同類型（可以通過簡單的操作改為傳相同類型的參數(shù)）
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;//----------調(diào)用add(int,int)-----優(yōu)先匹配的普通函數(shù)
?? ?cout << myadd(a,c) << endl;//----------調(diào)用add(int ,char)
?? ?cout << myadd(c,a) << endl;//----------調(diào)用add(t1,t2)-------沒有該類型的普通函數(shù)就調(diào)用模板函數(shù)
?? ?cout << myadd(c,c) << endl;//----------調(diào)用add(t1,t2)
?? ?cout << myadd<>(a, b) << endl;//-------強制調(diào)用add(t1,t2)
?? ?return 0;
}

3.函數(shù)模板實現(xiàn)機制

① 函數(shù)模板與模板函數(shù)：

1.函數(shù)模板:------------------------------僅僅是一個模板,并未被實例化(空殼子)

template <typename T>

返回類型函數(shù)名 (參數(shù)列表){函數(shù)體}

2.模板函數(shù):------------------------------通過類型的傳入,將函數(shù)模板實例化

函數(shù)模板的函數(shù)名<類型名>(參數(shù)列表);

② 函數(shù)模板機制剖析：

函數(shù)模板并不會直接產(chǎn)生能處理任意類型的參數(shù)的函數(shù);
而是通過產(chǎn)生對應(yīng)的模板函數(shù)實現(xiàn)對不同類型參數(shù)的處理；

函數(shù)模板進行兩次編譯：
1.函數(shù)模板聲明的地方,對函數(shù)模板代碼本身進行編譯
2.將類型插入后在調(diào)用的地方對插入?yún)?shù)后的代碼進行編譯

二、類模板

1.類模板基本語法

① 單個模板類:

基本語法:

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

注意事項:

模板類是一個抽象類,定義對象時需要參數(shù)類型的傳入

具體實現(xiàn)如下:

#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 模板類名<參數(shù)類型>{};

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

實現(xiàn)方法如下:

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

具體實現(xiàn)方法:

#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.類模板內(nèi)函數(shù)的整體布局【分文件使用類模板】

①所有函數(shù)均在類的內(nèi)部

實現(xiàn)方法如下:

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

②所有函數(shù)均在類的外部,但在同一文件

員函數(shù)實現(xiàn)語法:

原型: 類名函數(shù)名（參數(shù)列表）;

修改后的形式:
template <typename T>
類名<T> 函數(shù)名（參數(shù)列表）------參數(shù)列表該加T的就加T

流運算符友元函數(shù)實現(xiàn)語法:
原型(聲明): friend 返回類型函數(shù)名（參數(shù)列表）；

修改后的形式:
   (聲明) ：friend 返回類型函數(shù)名 <T> (參數(shù)列表) ；
   template<typename T>
   (函數(shù)實現(xiàn)): 返回類型函數(shù)名（參數(shù)列表）{};------類的對象做參數(shù)時修改為類名<T>;

具體實現(xiàn)如下：

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

③ 所有函數(shù)均在類的外部,但在不同文件

將類分文件寫后,將類函數(shù)實現(xiàn)的部分包含進主函數(shù)所在的文件

實現(xiàn)方法:

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

函數(shù)實現(xiàn)：

#include<iostream>
using namespace std;
#include"復(fù)數(shù)類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;
}

主函數(shù)：

#include<iostream>
using namespace std;
#include"復(fù)數(shù)類3h.cpp"http://重點
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

類模板定義了變量,函數(shù)實現(xiàn)的步驟,但沒有數(shù)據(jù)類型的插入,所以類模板僅僅是模板;
類模板的實現(xiàn)機制是程序員給出數(shù)據(jù)類型,編譯器對具體的類進行實現(xiàn),產(chǎn)生不同類型的類;
所以,類模板中的靜態(tài)成員變量是某個類型的具體類獨有的成員變量;只是被該類型對象所公有

區(qū)別如下：

模板類中的static變量可以被該模板類的對象公用
類模板的static經(jīng)過類不同方式的實例化,會產(chǎn)生不同的static變量，
且該變量只供初始化他的類使用

4.數(shù)組實現(xiàn)萬能容器

testarray類是一個類模板，里面有一個指針類型,所以通過程序員主動實現(xiàn)模板類傳參可以存儲不同類型的數(shù)據(jù),也就是說testarray理論可以存儲任意類型的數(shù)據(jù)。

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

效果圖：