一文搞懂C++泛型编程【函数模板、类模板】

---

① 函数模板的产生背景:

在编程时多多少少会因为函数参数不同写几个重载函数；

函数模板的出现解决了仅仅因为参数类型不同而进行的函数重载;

解决方法:让类型作为参数传进函数或者自动类型推导,从而实现不同的功能;

② 函数模板的语法：

template

返回类型 函数名(参数列表){函数体}

③ 函数模板的调用方式:

1.明显的调用 函数名<参数类型>（实参）;-------------常用

2.自动函数推导 函数名（实参）

④ 函数模板的本质:类型参数化！

函数模板举例

重载了三次的max函数,使用函数模板一次就可以解决

#include

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

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(a, b) << endl;

cout<<max(a, b)<<endl;

cout << max(a2, b2) << endl;;

return 0;

}

2.函数模板与重载函数的关系

---

① 普通函数的特性:

可以(隐式)进行参数类型自动转换；

② 函数模板的特性:

函数参数类型相同的话传进来的实参类型也必须相同(不允许自动转换);

调用规则:

• 调用函数时优先考虑普通函数

• 如果函数模板会有一个更好的匹配,那么选择模板函数；

• 可以通过空模板实参列表的语法限定编译器只通过模板匹配；

• 函数模板像普通函数一样也可以被重载

• 使用规则如下：

#include

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

返回类型 函数名 (参数列表){函数体}

2.模板函数:------------------------------通过类型的传入,将函数模板实例化

函数模板的函数名<类型名>(参数列表);

② 函数模板机制剖析：

函数模板并不会直接产生能处理任意类型的参数的函数;

而是通过产生对应的模板函数实现对不同类型参数的处理；

函数模板进行两次编译

1.函数模板声明的地方,对函数模板代码本身进行编译

2.将类型插入后在调用的地方对插入参数后的代码进行编译

二、类模板

=======================================================================

1.类模板基本语法

---

① 单个模板类:

基本语法:

template或template

class 类名{private: T a;};

注意事项:

模板类是一个抽象类,定义对象时需要参数类型的传入

具体实现如下:

#include

using namespace std;

template

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

a1.seta(x);

a1.printA();

char xx = ‘x’;

A a2;

a2.seta(xx);

a2.printA();

return 0;

}

② 模板类被具体类继承:

基本语法:

定义: class 具体类名 :public 模板类名<参数类型>{};

继承后的操作与普通类之间继承一样;

实现方法如下:

#include

using namespace std;

template

class A {

public:

void seta(T &a) {

this->a = a;

}

void printA() {

cout << this->a << endl;

}

protected:

T a;

};

class B :public A {

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

class 模板类名 :public 基类模板类名{ };

具体实现方法:

#include

using namespace std;

template

class A {

public:

void seta(T &a) {

this->a = a;

}

void printA() {

cout << this->a << endl;

}

protected:

T a;

};

template

class C :public A {//----------语法所在地

private:

T c;

public:

void setC(T &c) {

this->c = c;

}

void printC() {

cout << this->c << endl;

}

};

class B :public A {

private:

int b;

public:

void setb(int b) {

this->b = b;

}

void printB() {

cout << this->b << endl;

}

};

int main() {

int p = 99;

C c1;

c1.setC§;

c1.printC();

char pp = ‘6’;

C c2;

c2.setC(pp);

c2.printC();

return 0;

}

2.类模板内函数的整体布局【分文件使用类模板】

---

①所有函数均在类的内部

实现方法如下:

#include

using namespace std;

template

class complex1 {

friend ostream& operator<< (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

ostream& operator<<(ostream &out, complex1 &obj) {

out << obj.a << “+” << obj.b << “i” << endl;

return out;

}

int main_11() {

complex1 a(1, 2), b(3, 4);

complex1c = a + b;

cout << c << a << b;

a.printa();

a.printb();

return 0;

}

②所有函数均在类的外部,但在同一文件

成员函数实现语法:

原型: 类名 函数名 （参数列表）;

修改后的形式:

template

类名 函数名 （参数列表）------参数列表该加T的就加T

流运算符 友元函数实现语法:

原型(声明): friend 返回类型 函数名 （参数列表）；

修改后的形式:

(声明) ：friend 返回类型 函数名 (参数列表) ；

template

(函数实现): 返回类型 函数名 （参数列表）{};------类的对象做参数时修改为 类名;

具体实现如下

#include

using namespace std;

template

class complex2 {

friend ostream& operator<< (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

complex2::complex2(T a , T b ) {

this->a = a;

this->b = b;

}

template

complex2 complex2::operator+(complex2 obj) {

complex2 tem(a + obj.a, b + obj.b);

return tem;

}

template

void complex2::printa() {

cout << a << endl;

}

template

void complex2::printb() {

cout << b << endl;

}

template

ostream& operator<<(ostream& out, complex2& obj) {

out << obj.a << “+” << obj.b << “i” << endl;

return out;

}

int main_dd() {

complex2 a(1, 2), b(3, 4);

complex2c = a + b;

cout << c << a << b;

a.printa();

a.printb();

return 0;

}

③ 所有函数均在类的外部,但在不同文件

将类分文件写后,将类函数实现的部分包含进主函数所在的文件

实现方法:

#include"xxxx.cpp"

示例:

头文件

#pragma once

#include

using namespace std;

template

class complex {

friend ostream& operator<< (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();

};

函数实现
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）

complex(T a = 0, T b = 0);

complex operator+(complex obj);

void printa();

void printb();

};

函数实现
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-u4o3VyZx-1713729153899)]

[外链图片转存中…(img-pV2tSTLB-1713729153899)]

[外链图片转存中…(img-D7iY3fMu-1713729153900)]

[外链图片转存中…(img-SgBBNj4J-1713729153900)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）