泛型编程——类模板

已于 2023-04-15 21:57:35 修改
阅读量115 收藏
点赞数
分类专栏： c++核心编程 文章标签： c++ 算法
于 2023-04-13 23:41:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hm_uin/article/details/130122112
版权

一、语法

1、作用：建立一个通用类，类中成员数据类型可以不具体制定，用一个虚拟类型代替（类型参数化）

2、语法：template<typename T>或者template<class T>        类

 总结：类模板和函数模板类似，在模板后面紧跟着写一个类

3、类模板和函数模板的区别

（1）类模板没有自动类型推导的使用方式

（2）类模板在模板参数列表中可以有默认参数，函数模板中没有默认参数

#include<iostream>
using namespace std;
#include<string>

//类模板
template<class NameType,class AgeType>//如果两个类型一样的可以用一个typename
//template<class NameType,class AgeType = int>//类模板可以有默认类型参数,后续显示指定类型时就可以不写默认的那一个
class person
{
public:
	NameType m_Name;
	AgeType m_Age;
	person(NameType name,AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name：" << this->m_Name <<  << "age：" << this->m_Age << endl;
	}
};
void test01()
{
	person<string, int>p1("孙悟空", 99);  //类模板自动类型推导使用方式，只能用显示指定类型
	//person p2("猪八戒", 100);错误类型指定方式
	p1.showPerson();
}

int main()
{
	test01();
	system("pause");
	return 0;
}

二、类模板中成员函数创建时机

1、与普通类成员函数创建时机有区别

（1）普通类中的成员函数一开始就可以创建

（2）类模板中成员函数在调用时才创建

理解：

#include<iostream>
using namespace std;
class person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};
class person2
{
public:
	void showperson2()
	{
		cout << "person2 show" << endl;
	}
};
template<class T>
class MyClass
{
public:
	T obj;
	//类模板中的成员函数
	void func1()//只要不调用，就不会去创建
	{
		obj.showperson1();
	}
	void func2()
	{
		obj.showperson2();
	}
};
void test01()
{
	MyClass<person1>m;
	m.func1();
	m.func2();//错误，因为显示指定类型为person1，func2不是person1的成员函数
}
int main()
{
	test01();
	system("pause");
	return 0;
}

三、类模板对象做函数参数

1、类模板实例化出的对象，向函数传参的方式

（1）：指定传入类型——直接显示对象的数据类型

（2）：参数模板化

（3）：类模板化

总结：指定传入类型是最常见的

#include<iostream>
using namespace std;
#include<string>
//类模板对象做函数参数
template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "姓名：" << this->m_Name <<" " << "年龄：" << this->m_Age << endl;
	}
	T1 m_Name;
	T2 m_Age;
};
//1、指定传入类型
void printPerson1(Person<string, int>&p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int>p("孙悟空",100);
	printPerson1(p);
}
//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2> &p)
{
	p.showPerson();
}
void test02()
{
	Person<string, int>p("猪八戒",99);
	printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson3(T & p)
{
	p.showPerson();
}
void test03()
{
	Person<string, int>p("唐僧", 200);
	printPerson3(p);
}
int main()
{
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}

四、类模板与继承

1、注意：子类继承父类的类模板时，子类在声明时，要指定父类中T的类型

如果不指定，编译器无法给子类分配内存；如果想灵活指定父类中T的类型，子类也需变为类模板

2、示例：

#include<iostream>
using namespace std;
template<class T>
class Base
{
public:
	T m;
};
//class Son:public Base//错误，必须知道父类T类型，才能继承给子类
class Son:public Base<int>
{

};
void test01()
{
	Son s1;
}
//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
	T1 obj;
};
void test02()
{
	Son2<int, char>S2;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

五、类模板成员函数的类外实现

1、构造函数类外实现：person<T1,T2>表明这是类模板下的构造函数

 2、成员函数类外实现

 总结：成员函数类外实现时，需要加入模板的参数列表

六、类模板拆分文件编写

1、问题：类模板的成员函数创建时机是在调用阶段，导致分文件编写时链接不到

2、解决：（1）直接包含.cpp文件，（2）将声明和实现写到同一个文件中，并将后缀名改为.hpp

3、作用：多个类时分文编写

4、实现：
（1）person.h

#pragma once
#include<iostream>
using namespace std;
#include<string>
//声明
template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age);
	void ShowPerson();
	T1 m_Name;
	T2 m_Age;
};

(2)person.cpp

#include"person.h"
//类外实现
template<class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{
	m_Age = age;
	m_Name = name;
}
template <class T1, class T2>
void person<T1, T2>::ShowPerson()
{
	cout << this->m_Name << " " << this->m_Age << endl;
}

main.cpp

#include<iostream>
using namespace std;
#include"person.h"
void test01()
{
	/*person<string, int> p("张三", 18);
	p.ShowPerson();*/
}
int main()
{
	test01();
	system("pause");
	return 0;
}

如果不在test01中实例化对象，就不会报错，但是一旦取消注释，就会报错：有两个无法解析的外部命令。因为类模板的成员函数需要在对象实例化时才会实现，所以只包含头文件，编译器是看不见函数的实现的，实现的时候链接不到

第一种解决办法：将包含person.h改为包含person.cpp

#include<iostream>
using namespace std;
#include"person.cpp"
void test01()
{
	person<string, int> p("张三", 18);
	p.ShowPerson();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

第二种解决方式：将.h和.cpp内容写到一起，将后缀名改为.hpp文件

person.hpp

#pragma once
#include<iostream>
using namespace std;
#include<string>
//声明
template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age);
	void ShowPerson();
	T1 m_Name;
	T2 m_Age;
};
template<class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{
	m_Age = age;
	m_Name = name;
}
template <class T1, class T2>
void person<T1, T2>::ShowPerson()
{
	cout << this->m_Name << " " << this->m_Age << endl;
}

六、类模板与友元

1、类内实现

#include<iostream>
using namespace std;
#include<string>
template<class T1,class T2>
//通过全局函数，打印Person信息
class Person
{
private:
	T1 m_Name;
	T2 m_Age;
public:
	Person(T1 name, T2 age)
	{
		m_Name = name;
		m_Age = age;
	}
	//全局函数的类内实现
	friend void printPerson(Person<T1,T2>p)
	{
		cout << "姓名：" << p.m_Age << " " << "年龄：" << p.m_Age << endl;
	}
};
//1、测试
void test01()
{
	Person<string, int>p("Tom", 20);
	printPerson(p);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

2、类外实现：提前声明

#include<iostream>
using namespace std;
#include<string>
template<class T1,class T2>
//通过全局函数，打印Person信息
class Person
{
private:
	T1 m_Name;
	T2 m_Age;
public:
	Person(T1 name, T2 age)
	{
		m_Name = name;
		m_Age = age;
	}
	//全局函数的类外实现
	friend void printPerson(Person<T1, T2>p);
};
template<class T1,class T2>
void printPerson(Person<T1, T2>p)//不用加作用域，因为是全局函数
{
	cout << "姓名：" << p.m_Name << " " << "年龄：" << p.m_Age << endl;
}
//1、测试
void test01()
{
	Person<string, int>p("Tom", 20);
	printPerson(p);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

上述代码出错，无法解析的外部命令：因为声明的是普通函数，实现的确实函数模板

解决：在全局函数声明时，加空模板参数列表

#include<iostream>
using namespace std;
#include<string>
template<class T1, class T2>
class Person;
template<class T1, class T2>
void printPerson(Person<T1, T2>& p)//不用加作用域，因为是全局函数
{
	cout << "姓名：" << p.m_Name << " " << "年龄：" << p.m_Age << endl;
}
template<class T1, class T2>//通过全局函数，打印Person信息
class Person
{
	friend void printPerson<>(Person<T1, T2>& p);//全局函数配合友元，类外实现
private:
	T1 m_Name;
	T2 m_Age;
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//全局函数的类外实现
};
//1、测试
void test01()
{
	Person<string, int>p1("Tom", 20);
	printPerson(p1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}
//建议用类内实现

费马罗尔拉格朗日柯西……
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
泛型编程之模板
xuzhangze的博客
10-21 280
泛型编程        泛型编程是指编写与类型无关的逻辑代码，是代码复用的一种手段。进行泛型编程的基础是模板。 模板        这里的模板与我们生活中的模板类似，我们可以用一个模板产生非常多的实例，比如印刷试卷时，机器上用一个模板可以印刷成千上万张试卷，在这里我们也可以用一个模板来产生很多代码。        模板分类; 函数模板初介绍         一个函数模板代表着一种函
泛型编程——模板及模板的特例化
huangjh2017的博客
01-25 1020
1. 简介 　　面向对象编程（OOP）和泛型编程都能处理在编写程序时不知道类型的情况。不同之处在于：OOP能处理类型在程序运行之前都未知的情况；而泛型编程中，在编译时就能获知类型了。 　　模板是C++中泛型编程的基础。一个模板就是一个创建类或函数的蓝图或者说公式。当使用一个vector这样的泛型类型，或者find这样的泛型函数。这种转换发生在编译时。 　　编写单一模板，使之对任何可能的模板实
7.2泛型编程——类模板
qq_52563729的博客
05-23 329
类模板
泛型编程————浅析模板
SAKURAjinx的博客
10-24 173
通过调试，我们发现编译器调用的是int Add函数而非模板，因为模板不是函数，只是个样例，用户要使用加法函数的时候它才会推演生成对应函数实例，如果有现成的函数在（并且完全对应），那编译器为什么还要多此一举生成一个呢？在预处理阶段，编译器生成 .i文件，编译阶段生成 .s文件，经过汇编生成 .o文件，到此为止，是单线程的，两个文件分别经过上述流程，在链接阶段，联系到一起，生成.exe（g++下生成.out文件）。这是一个简单的加法函数模板，Add（a1,a2）编译器会进行推演，这是int类型的，那就实现为。
【C++】泛型编程——模板初阶
m0_70980326的博客
02-28 1767
泛型编程——模板初阶：函数模板的概念、使用、原理、实例化、匹配原则；类模板
C++ 泛型编程详解
01-21
这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程，这一篇主要介绍函数模板、类模板和成员模板三大部分 如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢 泛型编程 模板是泛型编程的一种重要...
数据结构——线性表类模板
12-19
在C++编程语言中，类模板被广泛用于实现抽象数据类型，它允许我们创建通用的数据结构，适用于多种数据类型。本主题将深入探讨如何使用C++类模板来实现一个线性表。 首先，我们需要定义一个线性表的基本操作，包括...
泛型编程与STL——侯捷译
04-10
这本书深入探讨了如何利用泛型编程的概念和技术，以及标准模板库（STL）来编写高效、可重用的代码。 泛型编程是一种编程范式，它允许程序员编写不依赖于特定数据类型的代码。这样，同一段代码可以应用于多种类型的...
关于C++泛型编程的一些杂感
03-02
所有的泛化所有的模板代码一旦实例化之后就落实到某一集特定的类型身上然后接受强类型系统的考验;-)有点像波函数的塌缩——本来是具有无数可能的，一旦有了一个观测者立即就塌缩成一个实体。在GP中，观测
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1242
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 701
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 288
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1151
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 1030
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
【C++初阶】string类
2301_78022459的博客
07-24 892
【C++初阶】string类
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
martian665的专栏
07-23 596
学懂C语言：C语言中的函数指针和回调函数详解
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 793
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
如何在C\#中创建HTML表格
程序员-张师傅
07-24 361
在C#中创建HTML表格通常不是直接由C#语言本身完成的，因为C#是一种面向对象的编程语言，主要用于后端逻辑处理。然而，在Web开发中，你可能会在C#代码（如在ASP.NET MVC、ASP.NET Core MVC或Razor Pages应用程序中）中生成HTML表格的字符串，或者更常见的是，使用Razor视图引擎来动态生成HTML表格。
【C#/C++】C#调C++的接口，给C++传结构体数组
一个努力写代码的小菜鸟，目前主要从事图像算法，目标检测/分割，模型量化与部署的工作
07-24 330
C#软件创建了一个结构体数组用来存储图像的区域信息，分别是矩形框的左上像素的xy坐标和矩形框右下像素的xy坐标。需要传入给调用的C++函数的参数列表中，我们选择使用C#传入一个结构体数组指针的方式，C++的参数列表中也使用数组指针来接收这个变量。首先要保证C#和C++两边定义的结构体要完全一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值