C++ 提高编程篇1.2：类模板

已于 2024-01-15 13:22:55 修改
阅读量599 收藏 8
点赞数 20
分类专栏： C++学习最全宝典(强烈建议订阅) 文章标签： c++ 算法 开发语言
于 2024-01-15 13:20:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Conan_0728/article/details/135589837
版权

类模板作用：建立一个通用类，类中的成员 数据类型可以不具体确定，用一个虚拟的类型代表

语法：
 

template<typename T>
类

解释：

template  —— 声明创建模板

typename —— 表面其后面的符号是一种数据类型，可以用class代替

T —— 通用的数据类型 名称可以替换 通常为大写字母

总结：类模板和函数模板相似，在声明模板template后面加类，此类称为模板

#include<iostream>
using namespace std;

#include<string>

// 类模板
template<class NameType,class AgeType>
class Person
{
public:
	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;
	}

	NameType m_Name;
	AgeType m_Age;
};

void test01()
{
	Person<string, int>p1("孙悟空", 999);
	p1.showPerson();
}

int main()
{
	test01();

	system("pause");

	return 0;
}

类模板与函数模板区分主要有两点：
1. 类模板没有自动类型推导的使用方式

2. 类模板在模板参数列表中可以有默认参数

总结：

类模板使用只能用显示指定类型方式

类模板中的模板参数列表可以有默认参数

#include<iostream>
using namespace std;

// 类模板与函数模板区别
template<class NameType, class AgeType = int>
class Person
{
public:
	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;
	}

	NameType m_Name;
	AgeType m_Age;
};

// 1、类模板没有自动类型推导使用方式
void test01()
{
	//Person p("孙悟空", 1000); // 错误，无法自动类型推导

	Person<string, int>p("孙悟空", 1000);

	p.showPerson();
}
// 2、类模板在模板参数列表中可以有默认参数
void test02()
{
	Person<string>p("猪八戒", 999);
	p.showPerson();
}


int main()
{
	test01();
	test02();

	system("pause");

	return 0;
}

类模板中成员函数和普通类中成员函数创建时机是有区别的：

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

int main()
{
	test01();

	system("pause");

	return 0;
}

类模板对象做函数参数

目标：类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

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

// 2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>& p)
{
	p.showPerson();
	cout << "T1 的类型为：" << typeid(T1).name() << endl;
	cout << "T1 的类型为：" << typeid(T2).name() << endl;
}

// 3、整个类模板化
template<class T>
void printPerson3(T& p)
{
	p.showPerson();
	cout << "T的数据类型为：" << typeid(T).name() << endl;
}

void test01()
{
	Person<string, int>p("孙悟空", 1000);
	printPerson1(p);
}

void test02()
{
	Person<string, int>p("猪八戒", 999);
	printPerson1(p);
}



void test03()
{
	Person<string, int>p("唐僧", 32);
	printPerson3(p);
}


	

int main()
{
	test01();

	test02();

	test03();

	system("pause");

	return 0;
}

类模板与继承

当类模板碰到继承时，需要注意一下几点：

1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型

2. 如果不指定，编译器无法给予子类分配内存

3. 如果想灵活指定出父类中T的类型，子类也需变为类模板

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

#include<iostream>
using namespace std;

// 类模板与继承

template<class T>
class Base
{
	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>
{
public:
	Son2()
	{
		cout << "T1的类型为：" << typeid(T1).name() << endl;
		cout << "T1的类型为：" << typeid(T2).name() << endl;
	}
	T1 obj;
};

void test02()
{
	Son2<int, char>S2;
}

int main()
{
	//test01();

	test02();

	system("pause");

	return 0;
}

类模板成员函数类外实现

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

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

// 构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

// 成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

void test01()
{
	Person<string, int>P("Tom", 20);
	P.showPerson();
}


int main()
{
	test01();

	system("pause");

	return 0;
}

类模板分文件编写

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

解决：

1. 解决方式1：直接包含.cpp源文件

2. 解决方式2：将声明和实现写到同一个文件中，并更改后缀名.hpp，hpp时约定的名称，并不是强制

总结：

主流的解决方式时第二种，将类模板成员函数写到一起，并将后缀改为.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;
};

person.cpp代码

#include "person.hpp"

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

类模板与友元

全局函数类内实现——直接在类内声明友元即可

全局函数类外实现——需要提前让编译器知道全局函数的存在

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

// 通过全局函数 打印Person信息
template<class T1, class T2>
class Person;

// 类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2>p)
{
	cout << "类外实现——姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

template<class T1, class T2>
class Person
{
	// 全局函数 类内实现
	friend void printPerson(Person<T1, T2>p)
	{
		cout << "姓名：" << p.m_Name << "年龄：" << p.m_Age << endl;
	}

	// 全局函数 类外实现
	// 加空模板参数列表
	// 如果全局函数 是类外实现，需要让编译器提前知道这个函数存在
	friend void printPerson2<>(Person<T1, T2>p);
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson()
	{
		cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
	}
private:
	T1 m_Name;
	T2 m_Age;

};

// 1、全局函数在类内实现
void test01()
{
	Person<string, int>p("Tom", 20);

	printPerson(p);
}

// 2、全局函数类外实现
void test02()
{
	Person<string, int>p("Jerry", 20);

	printPerson(p);
}

int main()
{
	test01();

	test02();

	system("pause");

	return 0;
}

类模板案例

案例描述：实现一个通用的数组类，要求如下

1. 可以对内置数据类型以及自定义数据类型的数据进行存储

2. 将数组中的数据存储到堆区

3. 构造函数中可以传入数组的容量

4. 提供对应的拷贝构造函数以及operator=防止浅拷贝问题

5. 提供尾插法和尾删法对数组中的数据进行增加和删除

6. 可以通过下标的方式访问数组中的元素

7. 可以获取数组中当前元素个数和数组的容量

MyArray.hpp代码如下：

// 自己通用的数据类
#pragma once
#include<iostream>
using namespace std;

template<class T>
class MyArray
{
public:

	// 有参构造 参数 容量
	MyArray(int capacity)
	{
		cout << "Myarray的有参构造调用" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}
	
	// 拷贝构造
	MyArray(const MyArray& arr)
	{
		cout << "Myarray的拷贝构造调用" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;

		// 深拷贝
		this->pAddress = new T[arr.m_Capacity];

		// 将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	// operator = 防止浅拷贝问题  a = b = c
	MyArray& operator=(const MyArray& arr)
	{
		cout << "Myarray的operator=调用" << endl;
		//先判断原来堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[]this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		// 深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}

	// 尾插法
	void Push_Back(const T& val)
	{
		// 判断容量是否等于大小
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val; // 在数组末尾插入数据
		this->m_Size++; //更新数组大小
	}

	// 尾删法
	void Pop_Back()
	{
		// 让用户访问不到最后一个元素，即为尾删，逻辑删除
		if (this->m_Size == 0)
		{
			return;
		}
		this->m_Size--;
	}

	// 通过下标方式访问数组中的元素 arr[0] = 100
	T& operator[](int index)
	{
		return this->pAddress[index];
	}

	// 返回数组容量
	int getCapacity()
	{
		return this->m_Capacity;
	}

	// 返回数组大小
	int getSize()
	{
		return this->m_Size;
	}

	// 析构函数
	~MyArray()
	{

		if (this->pAddress != NULL)
		{
			cout << "Myarray的析构函数调用" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}


private:
	T* pAddress; // 指针指向堆区开辟的真实数组

	int m_Capacity; // 数组容量

	int m_Size; // 数组大小
};

main.cpp代码如下：

	#include<iostream>
	using namespace std;
	#include"MyArray.hpp"
	#include<string>

	void printIntArray(MyArray<int>& arr)
	{
		for (int i = 0; i < arr.getSize(); i++)
		{
			cout << arr[i] << endl;
		}
	}

	void test01()
	{
		MyArray<int>arr1(5);

		for (int i = 0; i < 5; i++)
		{
			// 利用尾插法向数组中插入数据
			arr1.Push_Back(i);
		}

		cout << "arr1的打印输出为：" << endl;

		printIntArray(arr1);

		cout << "arr1的容量为：" << arr1.getCapacity() << endl;
		cout << "arr1的大小为：" << arr1.getSize() << endl;

		MyArray<int>arr2(arr1);

		cout << "arr2的打印输出为：" << endl;

		printIntArray(arr2);

		// 尾删
		arr2.Pop_Back();
		cout << "arr2尾删后：" << endl;
		cout << "arr2的容量为：" << arr2.getCapacity() << endl;
		cout << "arr2的大小为：" << arr2.getSize() << endl;

		//MyArray<int>arr3(100);
		//arr3 = arr1;
	}

	// 测试自定义数据类型
	class Person
	{
	public:

		Person() {};
		Person(string name, int age)
		{
			this->m_Name = name;
			this->m_Age = age;
		}

		string m_Name;
		int m_Age;
	};

	void printPersonArray(MyArray<Person>& arr)
	{
		for (int i = 0; i < arr.getSize(); i++)
		{
			cout << "姓名：" << arr[i].m_Name << " 年龄：" << arr[i].m_Age << endl;
		}
	}

	void test02()
	{
		MyArray<Person>arr(10);

		Person p1("孙悟空", 1000);
		Person p2("猪八戒", 999);
		Person p3("妲己", 18);
		Person p4("赵云", 22);
		Person p5("韩信", 20);
	
		// 将数据插入数组中
		arr.Push_Back(p1);
		arr.Push_Back(p2);
		arr.Push_Back(p3);
		arr.Push_Back(p4);
		arr.Push_Back(p5);

		// 打印数组
		printPersonArray(arr);

		// 输出容量
		cout << "arr容量为：" << arr.getCapacity() << endl;
		// 输出大小
		cout << "arr大小为：" << arr.getSize() << endl;

	}

	int main()
	{
		test01();

		test02();

		system("pause");
	
		return 0;
	}

万喵字节
关注
  • 20
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++语言基础：模板——函数模板和类模板
changlif的博客
05-05 696
1、模板的概念 1.1、模板就是建立通用的工具，大大提高复用性 1.2、C++的另一种编程思想称为泛型编程，主要利用的技术就是模板 C++提供两种模板机制：函数模板和类模板 2、函数模板 2.1 函数模板语法 函数模板作用 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： 语法定义： 1. template<typename T> 2. 函数声明或定义 语法定义的解释
【C++ 泛型编程 入门篇】C++ 元编程 :模板结构体的的使用教程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-13 2233
C++模板结构体，就是使用了模板的结构体（Struct）。它的设计理念是"编写一次，用于多种数据类型"。换句话说，通过使用模板结构体，你可以创建一个可适应多种类型的代码，而不是为每种可能的类型创建不同的代码。这一点类似于Java和C#中的泛型，但是C++的模板比这两种语言的泛型功能更强大和灵活。
【C++ 泛型编程 进阶篇】：C++ 元模版编程 typename关键字的多种用法全解析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-22 798
【C++ 泛型编程 中级篇】：C++ 元模版编程 typename关键字的多种用法全解析
【C++ 泛型编程 高级篇】 C++ 17 解析std::apply 的多种应用场景
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-27 1106
std::apply的作用是将一个函数应用于一个元组，但这并不意味着它会对元组的每个元素分别执行函数。相反，它会将元组的每个元素作为参数传递给函数。
【C++ 泛型编程 入门篇】 C++ 模板元编程之枚举内嵌 实战教程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-22 743
在C++模板元编程中，枚举可以被用作在编译时执行计算的工具。这是因为枚举的值在编译时被确定，而不是在运行时。这使得它们非常适合用于模板元编程，因为模板元编程需要在编译时执行计算和操作。
C++类模板
weixin_50560109的博客
05-09 543
1 模板 1.1 模板的概念 模板：所谓模板就是建立通用的摸具，大大提高复用性 模板的特点： 模板不可以直接使用，它只是一个框架 模板的通用性并不是万能的 1.2 函数模板 C++另一种编程思想称为泛型编程，主要利用的技术就是模板 C++提供两种模板机制：函数模板和类模板 1.2.1 函数模板语法 函数模板的作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表 语法： template<typename T> 函数声明或定义 例子： templat
【C++】C++泛型编程 | 模板初阶
Welcome home | Jian Liao 's blog
05-20 883
🌀 本章给大家带来的是C++泛型编程—模板。C++是C语言的扩展，注重面向对象编程及泛型编程。泛型编程是一种基于参数化的编程方式，简单来说就是编写具有通用性，可以适用于不同类型数据的代码。模板就是C++中实现泛型编程的一种重要手段。🌀C++中的模板允许程序员编写一套泛型代码，可以适用于不同的数据类型，因此称之为“模板”。模板可以分为函数模板和类模板两种形式。函数模板可以让程序员编写一个通用的函数（函数的参数或返回值是泛型类型），可以适用于各种不同的数据类型。
C++ 泛型编程 之模板（template）
qq_24472227的博客
04-29 3730
C++的 函数模板与类模板
【C/C++ 泛型编程 进阶篇】C++模板推导的迷宫：导致编译错误的原因及其解决策略
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
12-12 957
在深入探讨模板函数和编译器的复杂性之前，让我们先回顾一下编程作为一种创造性活动的本质。正如哲学家亚里士多德在《尼各马可伦理学》中所述：“人类的本质在于追求知识。”（"The nature of a human being is to pursue knowledge."）这句话在编程世界中尤为适用，因为每一行代码都是对知识的探索和实践。
【C++ 泛型编程 入门篇】C++模板类精讲：探索通用编程的魅力与实战应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-10 1412
C++模板是一种泛型编程技术，它使得程序员能够为一个类或函数定义通用的框架。通过这种方式，程序员可以编写一个适用于不同数据类型的算法，而无需针对每一种数据类型编写单独的版本。这使得代码更加简洁，易于维护，提高了程序的可重用性。
实现一个模板类的链表（c++）
06-03
1. 请创建一个数据类型为T的链表类模板List，实现以下成员函数： 1） 默认构造函数List()，将该链表初始化为一个空链表（10分） 2） 拷贝构造函数List(const List<T>& list)，根据一个给定的链表构造当前链表（10...
C++编程思想.pdf
09-30
《C++编程思想》，原名《Thinking in C++》，作者：Bruce Eckel，翻译：刘宗田等，出版社：机械工业出版社，ISBN：7111071166，pdf 格式，大小 4MB。本资源仅包括前七章的内容。 内容简介： 本书作者根据自己学习C++...
c++学习经典图书：C++ 编程思想(全).rar
05-04
本书作者根据自己学习C++的亲身体会及多年教学经验，用简单的例子和简练的叙述讲解C++编程，别具特色。 全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流...
VISUAL C++MFC扩展编程实例
10-21
本书主要介绍了运用Visual C++ 5.0或6.0的高级编程技巧，内容涉及MFC程序设计的最新概念，全书提供了大量VC的编程实例，旨在帮助读者较为全面地掌握VC编程知识、技巧和方法。全书分为三个部分和附录。第一部分介绍...
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
Ddddddd_158的博客
06-04 327
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
C++/Python/Java AWS S3认证
一个大佬的博客
06-01 919
【代码】C++/Python/Java AWS S3认证。
C语言从头学17——sizeof 运算符
最新发布
m0_72128260的博客
06-07 115
介绍sizeof，C 语言中的一个运算符，我们也可以理解为是一个函数。
c++实战知识点
qq_24867003的博客
06-03 1045
如果一个函数既可以用全局变量也可以用静态局部变量满足该函数要求，优先考虑静态局部变量，因为更安全。- 假如我们需要的参数越来越多，那么普通函数所需要的参数也就会越来越多，我们的框架(算法findif)也需要一同修改，这个不符合代码规范。如果函数的实参不是左值或与const引用形参的类型不匹配，那么c++将创建正确类型的匿名变量，将实参的值传递给匿名变量，让形参来引用该变量。重载的operator new 和 operator delete函数都是静态函数，因此无法使用类的普通成员变量。
C++类模板与STL编程
05-19
C++类模板是一种通用的类定义，可以用来定义任意类型的类。STL（Standard Template Library）是C++...总之，C++类模板和STL是C++中非常重要的特性，可以方便地实现通用的数据结构和算法，提高程序的可读性和可维护性。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

万喵字节

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值