黑马C++ 03 提高2 —— (泛型编程)模板_类模板

已于 2022-12-30 14:52:22 修改
阅读量275 收藏 1
点赞数 1
分类专栏： B站系统学习C++ 文章标签： c++ 开发语言 算法
于 2022-10-31 14:06:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42731062/article/details/127147936
版权

文章目录

1. 类模板语法

类模板作用：

  • 建立一个通用类，类中的成员 数据类型可以不具体指定，用一个虚拟的类型来代表。

语法：

template<typename T>
类

解释：

  • template — 声明创建模板
  • typename — 表面其后面的符号是一种数据类型，可以用class代替
  • T — 通用的数据类型，名称可以替换，通常为大写字母

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

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

// 类模板
template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

void test01()
{
	// 指定NameType 为string类型，AgeType 为 int类型
	Person<string, int>P1("孙悟空", 999);
	P1.showPerson();
}

int main() {

	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

2. 类模板与函数模板区别

类模板与函数模板区别主要有两点：

  1. 类模板没有自动类型推导的使用方式
  2. 类模板在模板参数列表中可以有默认参数

总结：

  • 类模板使用只能用显示指定类型方式
  • 类模板中的模板参数列表可以有默认参数
#include<vector>
#include<algorithm>
#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 fun1()
	{
		obj.showPerson1();
	}
	void fun2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	MyClass<Person1> m;
	m.fun1();
	// MyClass<Person2> m;
	// m.fun2();// 编译会出错，说明函数调用才会去创建成员函数
}

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

在这里插入图片描述

  • 总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

3. 类模板成员函数创建时机

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

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
#include<vector>
#include<algorithm>
#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 fun1()
	{
		obj.showPerson1();
	}
	void fun2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	MyClass<Person1> m;
	m.fun1();
	// MyClass<Person2> m;
	// m.fun2();// 编译会出错，说明函数调用才会去创建成员函数
}

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

4. 类模板对象做函数参数

学习目标：

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

一共有三种传入方式：

  • 指定传入的类型 — 直接显示对象的数据类型
  • 参数模板化 — 将对象中的参数变为模板进行传递
  • 整个类模板化 — 将这个对象类型 模板化进行传递

查看类型：typeid(T1).name()

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

// 类模板对象做函数参数
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age) 
	{
		this->m_Name = name;// name 是 string 类型
		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中
	printPerson1(p);
	cout << endl;
}

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

void test02()
{
	Person <string, int >p("猪八戒", 90);
	printPerson2(p);
	cout << endl;
}

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

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

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

在这里插入图片描述

5. 类模板与继承

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

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中T的类型，子类也需变为类模板
#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;

// 类模板与继承
template<class T>
class Base // 类型未知
{
	T m;
};
// Base不是一个类，只是一个模板，通过类模板实例化出来的是模板类，模板类才是一种类

// class Son:public Base  
// {    }；
// 错误，C++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> // 必须指定一个类型
{

};
void test01()
{
	Son s1;
}

// 如果想灵活指定父类中T类型，子类也需要变类模板
// 类模板继承类模板 ,可以用T2指定父类中的T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << "T1的数据类型为： " << typeid(T1).name() << endl;
		cout << "T2的数据类型为： " << typeid(T2).name() << endl;
	}
	T1 obj;
};

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


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

在这里插入图片描述

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

6. 类模板成员函数类外实现(重要)

  • 学习目标：能够掌握类模板中的成员函数类外实现
  • 总结：类模板中成员函数类外实现时，需要加上模板参数列表
#include<iostream>
#include <string>
using namespace std;

// 类模板中成员函数类外实现
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;
}

在这里插入图片描述

7. 类模板分文件编写(重要)

学习目标：

  • 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

  • 类模板中成员函数创建时机是在调用阶段,一开始不创建，导致分文件编写时链接不到

解决：

  • 解决方式1：直接包含.cpp源文件
  • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

7.1 解决方式1—— 直接包含源文件 #include"person.cpp"

7.1.1 person.h 头文件

  • .h头文件中进行类的声明，有哪些成员函数
// 防止头文件重复包含
#pragma once
#include<iostream>
#include<string>
using namespace std;

template<class T1, class T2>
class Person {
public:
	Person(T1 name, T2 age);

	void showPerson();

public:
	T1 m_Name;
	T2 m_Age;
};

7.1.2 person.cpp（成员函数说明）

#include"person.h"

// 构造函数 类外实现
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;
}

7.1.3 main.cpp

#include<iostream>
#include"person.cpp"
using namespace std;

// 类模板分文件编写问题及解决
void test01()
{
	Person<string, int> p("Jerry", 18);
	p.showPerson();
}

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

7.2 解决方式2(常用) —— 将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件 #include"person.hpp"

7.2.1 person.hpp 函数声明和实现都在一起

// 防止头文件重复包含
#pragma once
#include<iostream>
#include<string>
using namespace std;

// 函数声明和函数实现都在一个文件里
template<class T1, class T2>
class Person {
public:
	Person(T1 name, T2 age);

	void showPerson();

public:
	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;
}

7.2.2 main.cpp

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

void test01()
{
	Person<string, int> p("Jerry", 18);
	p.showPerson();
}

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

在这里插入图片描述

8. 类模板和友元(难点)

学习目标：

  • 掌握类模板配合友元函数的类内和类外实现
  1. 全局函数类内实现 - 直接在类内声明友元即可
  2. 全局函数类外实现 - 需要提前让编译器知道全局函数的存在
#include<iostream>
#include<string>
using namespace std;

// 通过全局函数 打印Person信息

// 提前让编译器知道，全局函数类外实现
template<class T1, class T2>
class Person;

// 成员函数 类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)// 函数模板的类外实现
{
	cout << "类外实现 —— 姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}

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

	// 通过友元类外访问类内私有权限的成员函数
	// 友元函数是非成员函数，但声明定义都可以在类中
	
	// 方式2：全局函数 类外实现 —— 只能写申明
	// 加空模板的参数列表<>
	// 如果全局函数是类外实现的话，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2> p);// 普通函数声明

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

private:
	T1 m_Name;
	T2 m_Age;
};

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

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

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

在这里插入图片描述

  • 总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

9. 类模板案例

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

  • 可以对内置数据类型以及自定义数据类型的数据进行存储
  • 将数组中的数据存储到堆区
  • 构造函数中可以传入数组的容量
  • 提供对应的拷贝构造函数以及operator = 防止浅拷贝问题
  • 提供尾插法和尾删法对数组中的数据进行增加和删除
  • 可以通过下标的方式访问数组中的元素
  • 可以获取数组中当前元素个数和数组的容量

9.1 myArray.hpp代码

#pragma once
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:
    
	//构造函数
	MyArray(int capacity)
	{
		this->m_Capacity = capacity;
		this->m_Size = 0;
		pAddress = new T[this->m_Capacity];
	}

	//拷贝构造
	MyArray(const MyArray & arr)
	{
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++)
		{
			//如果T为对象，而且还包含指针，必须需要重载 = 操作符，因为这个等号不是 构造 而是赋值，
			// 普通类型可以直接= 但是指针类型需要深拷贝
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//重载= 操作符  防止浅拷贝问题
	MyArray& operator=(const MyArray& myarray) {

		if (this->pAddress != NULL) {
			delete[] this->pAddress;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

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

	//重载[] 操作符  arr[0]
	T& operator [](int index)
	{
		return this->pAddress[index]; //不考虑越界，用户自己去处理
	}

	//尾插法
	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--;
	}

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

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


	//析构
	~MyArray()
	{
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
	}

private:
	T * pAddress;  //指向一个堆空间，这个空间存储真正的数据
	int m_Capacity; //容量
	int m_Size;   // 大小
};

9.2 类模板案例—数组类封装.cpp

在这里插入图片描述

#include "myArray.hpp"
#include <string>

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

//测试内置数据类型
void test01()
{
	MyArray<int> array1(10);
	for (int i = 0; i < 10; i++)
	{
		array1.Push_back(i);
	}
	cout << "array1打印输出：" << endl;
	printIntArray(array1);
	cout << "array1的大小：" << array1.getSize() << endl;
	cout << "array1的容量：" << array1.getCapacity() << endl;

	cout << "--------------------------" << endl;

	MyArray<int> array2(array1);
	array2.Pop_back();
	cout << "array2打印输出：" << endl;
	printIntArray(array2);
	cout << "array2的大小：" << array2.getSize() << endl;
	cout << "array2的容量：" << array2.getCapacity() << endl;
}

//测试自定义数据类型
class Person {
public:
	Person() {} 
		Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;
};

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

}

void test02()
{
	//创建数组
	MyArray<Person> pArray(10);
	Person p1("孙悟空", 30);
	Person p2("韩信", 20);
	Person p3("妲己", 18);
	Person p4("王昭君", 15);
	Person p5("赵云", 24);

	//插入数据
	pArray.Push_back(p1);
	pArray.Push_back(p2);
	pArray.Push_back(p3);
	pArray.Push_back(p4);
	pArray.Push_back(p5);

	printPersonArray(pArray);

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

}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}
2021 Nqq
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++类模板
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-09 1078
类模板 1.3.1 类模板语法 类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 类 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常为大写字母 示例： #include <string> //类模板 template<class NameType, c
练习 ~黑马程序员匠心之作-第五阶段-C++提高编程-P167~P173-模板-普通函数模板
qq_43964914的博客
10-28 453
黑马程序员匠心之作|C++教程从0到1入门编程 关于P167~P184-练习-模板1、模板的概念2、函数模板基本语法3、函数模板注意事项4、函数模板案例-数组排序5、普通函数与函数模板的区别6、7、模板的局限性8、类模板的基本语法9、类模板与函数模板区别 1、模板的概念 2、函数模板基本语法 3、函数模板注意事项 4、函数模板案例-数组排序 5、普通函数与函数模板的区别 6、 7、模板的局限性 8、类模板的基本语法 9、类模板与函数模板区别 ...
类模板详解
孤云出岫, 去留一无所系. 朗镜悬空,静躁两不相干.
08-27 1146
类模板的使用方法和属性
C++：类模板详解
青瓦松
12-16 958
C++：类模板 四、类模板 1、类模板不可使用自行类型推导，须显式指定类型 2、类模板可有默认类型参数 #include <iostream> #include <string> using namespace std; // AGETYPE = int: 指定AGETYPE默认类型参数为int template <class NAMETYPE, class AGETYPE=int> class Person { private: NAMETYPE name
模板类详解
zgg1985658560的博客
09-05 2053
函数模板就是函数参数使用了通用类型，就是函数模板。template <typename（旧用class）>// 类型参数列表，其中typename可以写成class{}// 以下是对函数模板的调用someFuncconst// 类型参数列表，其中typename可以写成class template < typename T1 , typename T2 > void someFunc(T1 a , T2 a) {
C++类模板使用详解
https://github.com/heatMa
09-02 2508
        转自：https://www.cnblogs.com/sevenyuan/p/3154346.html 1. 模板的概念。 我们已经学过重载(Overloading)，对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如，为求两个数的最大值，我们定义MAX()函数需要对不同的数据类型分别定义不同重载(Overload)版本。 ...
第三阶段 黑马程序员C++提高编程
最新发布
06-07
在本阶段的学习资料中，重点聚焦于C++的高级特性——泛型编程及其应用之一：标准模板库（Standard Template Library, STL）。泛型编程允许开发者编写代码时使用一种通用的方式处理不同类型的数据，从而极大地提高了...
黑马程序员匠心之作 C++教程_第6阶段实战-基于STL泛化编程的演讲比赛资料讲义.rar
03-19
6. **泛型编程**：泛型编程是STL的核心思想，它强调编写独立于具体类型和数据结构的代码。通过模板，可以创建可重用的代码，适应不同类型的参数。 本教程的实战部分，通过演讲比赛的场景，将这些理论知识与实际问题...
黑马程序员入学Java知识——精华总结.doc
05-09
以上只是Java知识体系的一部分，深入学习Java还需要掌握更多的概念和技术，如反射、注解、泛型、Lambda表达式、并发编程、Spring框架等。通过不断学习和实践，你可以成为一位出色的Java开发者。
黑马程序员入学Java知识——精华总结
u014563778的专栏
04-17 3579
黑马程序员入学Java知识——精华总结   J2SE部分，Java高新技术部分，7K面试题部分等黑马入学要求的知识点总结！   一、黑马程序员—java概述与基础知识 6 1、何为编程？ 6 2、Java语言概述，历史、特点 6 3、什么是跨平台性？原理是什么？JVM 7 4、Jre和Jdk的区别? 7 5、java虚拟机JVM 8 6、 Java程序运行机制 8 7
类模板深度剖析
weixin_46571142的博客
12-20 366
类模板可以定义任意多个不同类型的参数： template <typename T1, typename T2> class Test { public: void add(T1 a, T2 b); }; Test<int, float> t; 类模板可以被特化： (1)指定类模板的特定实现 (2)部分类型参数必须显示指定 (3)根据类型参数分开实现类模板 template <typename T1, typename T2> class Test {
C++ 模板编程 (类模板)
QuantumYou的博客
08-09 592
加油！当自己的实力不能满足自己的目标时，就静下心去学习！ 文章目录类模板类模板语法类模板与函数模板区别类模板中成员函数创建时机类模板对象做函数参数类模板与继承类模板成员函数类外实现类模板分文件编写类模板与友元 类模板 类模板语法 类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 类 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用cl.
c++写一个基于模板类的模板类
heraldww的博客
04-13 536
std::valarray 增强的类 valarrayX
C++模板剖析：函数模板、类模板解析
Sharp_UP的博客
11-29 2449
C++中关于模板&泛型编程问题：   问题引入：何编写一个通用加法函数？   （1）使用函数重载，针对每个所需相同行为的不同类型重新实现它 int Add(const int &_iLeft, const int&_iRight) { return (_iLeft +_iRight); } float Add(const float &_fLeft, constfloat &_f
C++ 函数模板&类模板详解
热门推荐
Stay Hungry
12-02 1万+
在 C++ 中，模板分为函数模板和类模板两种。函数模板是用于生成函数的，类模板则是用于生成类的。 函数模板&amp;模板函数     类模板&amp;模板类  必须区分概念 函数模板是模板，模板函数时具体的函数 类模板是模板，模板类时具体的类 由函数模板实例化而得到的函数称为模板函数 由类模板实例化得到的类叫模板类   一.函数模板 函数模板的基本写法为：template &lt;typ...
22.C++之类模板
菜鸟要爱学习
08-16 228
C++之类模板相关知识！！！
【深度C++】之“类模板”
不能自拔
08-11 445
来吧，一起了解类模板吧！
C++之类模板详解（一）
Bruce_0712的博客
05-22 815
C++ 除了支持函数模板，还支持类模板（Class Template）。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。 声明类模板的语法为： template class 类名{     //TODO: }; 类模板和函数模板都是以 template 开头（当然也可以使用 class，目前来
C++ 类模板与模板类详解
weixin_30907935的博客
11-18 6281
　　在C++的Template中很多地方都用到了typename与class这两个关键字，有时候这两者可以替换，那么这两个关键字是否完全一样呢？ 　　事实上class用于定义类，在模板引入c++后，最初定义模板的方法为:template<class T>,这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键...
C++进阶：STL课程详解与函数模板应用
此外，课程还涵盖了函数模板和类模板，这是C++模板编程的关键部分。函数模板允许编写通用的函数，根据实际参数类型进行动态调整，无需为每种数据类型单独编写函数，从而节省时间和提高代码复用性。例如，通过`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

2021 Nqq

你的鼓励是我学习的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值