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

2401_84011114

于 2024-04-22 03:52:10 发布

阅读量683

点赞数 17

分类专栏：程序员文章标签： c++ java 开发语言

本文链接：https://blog.csdn.net/2401_84011114/article/details/138054271

版权

程序员专栏收录该内容

200 篇文章 0 订阅

订阅专栏

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

};

函数实现

#include

using namespace std;

#include"复数类3.h"

template

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

this->a = a;

this->b = b;

}

template

complex complex::operator+(complex obj) {

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

return tem;

}

template

void complex::printa() {

cout << a << endl;

}

template

void complex::printb() {

cout << b << endl;

}

template

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

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

return out;

}

主函数

#include

using namespace std;

#include"复数类3h.cpp"//重点

int main() {

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

complexc = a + b;

cout << c << a << b;

a.printa();

a.printb();

return 0;

}

3.类模板的static与模板类的static

类模板定义了变量,函数实现的步骤,但没有数据类型的插入,所以类模板仅仅是模板;

类模板的实现机制是程序员给出数据类型,编译器对具体的类进行实现,产生不同类型的类;

所以,类模板中的静态成员变量是某个类型的具体类独有的成员变量;只是被该类型对象所公有

区别如下：

模板类中的static变量可以被该模板类的对象公用

类模板的static经过类不同方式的实例化,会产生不同的static变量，

且该变量只供初始化他的类使用

4.数组实现万能容器

testarray类是一个类模板，里面有一个指针类型,所以通过程序员主动实现模板类传参

可以存储不同类型的数据,也就是说testarray理论可以存储任意类型的数据。

#include

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

class testarray {

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

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

for (int i = 0;i < obj.len;i++) {

cout << obj[i] <<" ";

}

cout << endl;

return out;

}

int main() {

testarray aint(10);

testarray bchar(10);

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

}

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

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

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

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

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

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

for (int i = 0;i < 10;i++) {

bchar[i] = i + 97;

}

cout << aint;

cout << bchar;

cout << tea;

return 0;

}

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

[外链图片转存中…(img-8TFLTXFH-1713729118907)]

[外链图片转存中…(img-zmho7iAn-1713729118907)]

[外链图片转存中…(img-HH5936Zz-1713729118908)]

[外链图片转存中…(img-HdFjXVSy-1713729118908)]

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

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

2401_84011114

关注

17
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
一文搞懂C++泛型编程【函数模板、类模板】(1)

i < 10;i++) {return 0;
复制链接

扫一扫

专栏目录

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

② 模板类被具体类继承:

③ 模板类被模板类继承

①所有函数均在类的内部

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

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

“相关推荐”对你有帮助么？