C++类模板

已于 2022-12-04 20:47:18 修改
阅读量485 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 算法
于 2022-12-04 20:44:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47207479/article/details/128108632
版权

目录

1，类模板基本语法

2，类模板和函数模板区别

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

4，类模板参数做函数参数 

5，类模板与继承 

6，类模板成员函数类外实现

7，类模板分文件编写

8，类模板与友元 

9，类模板案例

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

1，类模板基本语法

template<typename T>

类

template --- 声明创建模板

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

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

示例：

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

template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		m_Name = name;
		m_Age = age;
	}
	NameType m_Name;
	AgeType m_Age;

	void showPerson()
	{
		cout << "name:" << m_Name << " age:" << m_Age << endl;
	}
};

void test()
{
	Person<string, int> p("张三",18);
	p.showPerson();
}

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

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

2，类模板和函数模板区别

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

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

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

如下代码中，在定义类对象时，如不显示指定类型，因类模板没有自动类型推导，会报错。

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

template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		m_Name = name;
		m_Age = age;
	}
	NameType m_Name;
	AgeType m_Age;

	void showPerson()
	{
		cout << "name:" << m_Name << " age:" << m_Age << endl;
	}
};

void test()
{
	Person p("张三",18);
	p.showPerson();
}

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

 如下代码中，类模板参数列表中可以有默认参数：

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

template<class NameType,class AgeType = int>  //类模板参数列表有默认参数
class Person
{
public:
	Person(NameType name, AgeType age)  
	{
		m_Name = name;
		m_Age = age;
	}
	NameType m_Name;
	AgeType m_Age;

	void showPerson()
	{
		cout << "name:" << m_Name << " age:" << m_Age << endl;
	}
};

void test()
{
	//类模板在参数列表中有默认参数
	Person<string> p("张三",18);
	p.showPerson();
}

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

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

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

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

类模板中的成员函数在调用时才创建。

如下代码中类模板中的成员函数，只有

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

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 test()
{
	MyClass<Person1> m;
	m.func1();
	//m.func2();
}

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

4，类模板参数做函数参数 

 类模板实例化出的对象，作为实参传入函数时，有三种传入方式：

1，指定传入的类型 --- 直接显示对象的数据类型；

2，参数模板化 --- 将对象中的参数变为模板进行传递；

3，整个类模板化 --- 将对象类型 模板化进行传递。

第一种方式： 直接显示对象的数据类型；

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

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

	void showPerson()
	{
		cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
	}

	T1 m_Name;
	T2 m_Age;
};

void printPerson(Person<string, int>& p)
{
	p.showPerson();
}

void test()
{
	Person<string, int> p("张三",18);
	printPerson(p);
}

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

第二种方式： 将对象中的参数变为模板进行传递；

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

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

	void showPerson()
	{
		cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
	}

	T1 m_Name;
	T2 m_Age;
};

template<class T1,class T2>
void printPerson(Person<T1, T2>& p)
{
	p.showPerson();
	cout << "T1的类型：" << typeid(T1).name() << endl;
	cout << "T2的类型：" << typeid(T2).name() << endl;
}

void test()
{
	Person<string, int> p("张三",18);
	printPerson(p);
}

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

运行结果：

姓名：张三 年龄：18
T1的类型：class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
T2的类型：int
请按任意键继续. . .

第三种方式： 整个类模板化；

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

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

	void showPerson()
	{
		cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
	}

	T1 m_Name;
	T2 m_Age;
};

template<class T>
void printPerson(T & p)
{
	p.showPerson();
	cout << "T的类型：" << typeid(T).name() << endl;
}

void test()
{
	Person<string, int> p("张三",18);
	printPerson(p);
}

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

运行结果：

姓名：张三 年龄：18
T的类型：class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
请按任意键继续. . .

类模板对象传入函数时，函数形参的类型使用比较广泛的是第一种：指定传入的类型。

5，类模板与继承 

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

当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中T的类型，如果不指定，编译器无法给子类分配内存，如果想灵活指定出父类中T的类型，子类也需变为类模板。 

如下代码中，因为父类是类模板，子类在继承时需指定父类中T的类型：

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

template<class T>
class Base
{

};

class Son :public Base<int>
{

};


void test()
{
	Son s1;
}

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

如下代码中，可以将子类也设定为类模板，可以灵活指定父类中T的类型：

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

template<class T>
class Base
{

};

template<class T1,class T2>
class Son :public Base<T2>
{
public:
	T1 obj;

	Son()
	{
		cout << "T1的类型：" << typeid(T1).name() << endl;
		cout << "T2的类型：" << typeid(T2).name() << endl;
	}
};


void test()
{
	Son<int,char> s1;
}

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

 注意：如果父类是类模板，子类在继承时需要指定父类T的类型，如果要灵活指定父类T的类型，子类也要写成类模板的形式。

6，类模板成员函数类外实现

 如下代码为类模板成员函数在类外实现：

#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_Name = name;
	m_Age = age;
}

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

void test()
{
	Person<string, int> p("张三", 18);
	p.showPerson();
}

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

 注意：类模板中成员函数在类外实现时，需要加上模板参数列表。

7，类模板分文件编写

类模板分文件编写时，因为类模板成员函数创建时机是在调用阶段，导致程序编译时链接不到。

有两种解决办法：

1，直接包含.cpp文件；

2，将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制的（如果看到hpp文件，可以理解为类模板的分文件编写）。

以下代码，主要介绍第二种方法：

主函数中包含hpp文件：

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

#include "Person.hpp"

void test()
{
	Person<string, int> p("张三", 18);
	p.showPerson();
}

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

hpp文件定义类模板及成员函数：

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_Name = name;
	m_Age = age;
}

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

主流的解决方式是第二种，将类模板成员函数写到一起，并将文件后缀名改为.hpp。

8，类模板与友元 

全局函数做友元两种实现方法：

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

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

以下代码为友元全局函数在类内实现：

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

template<class T1, class T2>
class Person
{
	friend void printPerson(Person<T1, T2> p)
	{
		cout << "姓名：" <<p.m_Name << " 年龄：" << p.m_Age << endl;
	}

public:
	Person(T1 name, T2 age);
private:
	T1 m_Name;
	T2 m_Age;
};

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

void test()
{
	Person<string, int> p("张三", 18);
	printPerson(p);
}

int main()
{
	test();
	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>
class Person
{
	friend void printPerson<>(Person<T1, T2> p); //需要加空模板参数列表

public:
	Person(T1 name, T2 age);
private:
	T1 m_Name;
	T2 m_Age;
};

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

void test()
{
	Person<string, int> p("张三", 18);
	printPerson(p);
}

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

注意：友元全局函数在类外实现时，在类内声明友元时，需要加空模板参数列表。

需要提前让编译器知道友元全局函数的存在。

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

9，类模板案例

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

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

将数组中的数据存储到堆区；

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

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

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

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

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

通过案例描述可知，要建立一个类模板，对类模板进行分 文件编写时，使用.hpp后缀文件保存类模板的声明和定义。

后缀为.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[capacity];
	}

	myArray(const myArray& arr)
	{
		//cout << "myArray拷贝构造函数" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			
		}
		this->pAddress = new T[arr.m_Capacity];

		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	myArray& operator=(const myArray& arr)
	{
		//cout << "myArray operator=函数" << endl;
		if (this->pAddress != NULL)
		{
			delete[] pAddress;
			pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		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(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--;
	}

	T& operator[](int index)
	{
		return this->pAddress[index];
	}

	int get_Capacity()
	{
		return this->m_Capacity;
	}

	int get_Size()
	{
		return this->m_Size;
	}

	~myArray()
	{
		//cout << "myArray析构函数" << endl;
		if (pAddress != NULL)
		{
			delete[] pAddress;
			pAddress = NULL;
		}
	}
private:
	T* pAddress;

	int m_Capacity;

	int m_Size;
};

.cpp后缀文件中的代码：（需要包含上边后缀为.hpp的文件）

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

#include "myArray.hpp"

class Person
{
public:

	Person()
	{

	}

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

	string m_Name;
	int age;
};

void printPerson(myArray<Person>& arr)
{
	for (int i = 0; i < arr.get_Size(); i++)
	{
		cout << "姓名：" << arr[i].m_Name << " 年龄：" << arr[i].age << endl;
	}
}

void test()
{
	myArray<Person> arr(5);
	Person p1("孙悟空",1000);
	Person p2("唐僧", 20);
	Person p3("猪八戒",100);
	Person p4("沙僧", 30);

	arr.Push_Back(p1);
	arr.Push_Back(p2);
	arr.Push_Back(p3);
	arr.Push_Back(p4);

	printPerson(arr);

	myArray<Person> arr1(arr);

	printPerson(arr1);

	myArray<Person> arr2(10);
	arr2 = arr1;
	printPerson(arr2);
	cout << arr2.get_Size() << endl;
	arr2.Pop_Back();
	printPerson(arr2);
}

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

weixin_47207479
关注
专栏目录
C++ 类模板、函数模板全特化、偏特化的使用
08-25
C++ 类模板、函数模板全特化、偏特化的使用 类模板全特化和偏特化是 C++ 编程语言中非常重要的概念，它们都是模板元编程的基础。类模板全特化和偏特化可以让开发者更好地控制模板的行为，提高代码的灵活性和可维护...
C++中的类模板
weixin_33887443的博客
09-08 101
我们在定义函数时，可以通过定义函数模板，来简化一些功能相同而数据类型不同的函数的定义和调用过程。 C++中的函数模板 对于类的声明来说，也有同样的问题。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，如下面语句声明了一个类： class Compare_int { public: Compare(int a,int b) { x=a; y=b;...
C++ 函数模板和类模板
最新发布
Levon123的博客
08-07 1254
因此，为了避免在每个编译单元都定义函数模板，建议在头文件中对函数模板进行声明定义（即将函数模板的声明和定义都写在一个头文件中，然后在需要使用函数模板的地方加上该头文件）。
c++中的类模板
Lyajpunov的博客
10-01 2161
/关键字 T2 value;//值 Pair(T1 k , T2 v) : key(k) , value(v) {};};template < class T1 , class T2 > bool Pair < T1 , T2 > :: operator & p) const //Pair的成员函数 operator < {//"小"的意思就是关键字小 return key < p . key;
c++的类模板
echo_bright_的博客
08-20 601
泛型思想可运用于函数即函数模板外，还可以运用于类即模板类，使得类的实现不关注数据元素的具体类型，而只关注类所需要实现的功能。模板类在实际中主要用于存储和组织数据元素，如数组类、链表类、栈类(后进先出)、队列类(先进先出)等，这些类的共同之处为：类中的数据组织方式和数据元素的具体类型无关。  模板类的语法如下：template<typename T> class TestCls { public:
C++模板类
weixin_30606669的博客
02-26 159
上篇文章介绍了模版函数，本篇文章介绍下模版类。 C++类模版为生成通用的类声明提供了一种更好的方法。模版提供参数化类型，即能通过类型名作为参数传递给接收方来简历类或函数，例如将类型名int传递给Queue模版，可以让那个模版构造一个对int进行排队的Queue类。 1.定义类模版 #ifndef STACKTP_H_ #define STACKTP_H_ template &lt...
C++类模板与模板类深入详解
09-04
C++类模板与模板类是C++编程中重要的特性，它们提供了泛型编程的能力，允许程序员编写出能够处理多种数据类型的一般性代码。本文将深入探讨这两个概念及其相关知识点。 1. 关键字`typename`与`class`： 在C++的模板...
c++ 类模板
01-28
很不错的类模板，
C++类模板案例.zip
08-11
C++标准库提供了`std::array`模板类，它是固定大小数组的封装，可以与类模板结合使用。`std::array`模板接收两个参数：元素类型和数组的大小。例如，创建一个存储5个整数的数组： ```cpp #include template ...
类模板中成员函数创建时机
嵌入式
07-02 703
类模板中成员函数和普通类中成员函数创建时机 普通类中的成员函数一开始就可以创建 类模板中的成员函数在调用时才创建 测试代码 #include <iostream> #include <string> using namespace std; #include <string> class Person1 { public: void showPerso...
【C++】类模板
debug...
07-24 2070
C++类模板
C++ 类模板
deeplan_1994的博客
01-09 666
类模板的定义 即类采用模板的形式出现，和函数模板一样，对参数没有具体的实例化 template &lt;class T&gt; //声明一个模板，虚拟类型名为T。注意：这里没有分号。 class Compare //类模板名为Compare { public : Compare(T a,T b) { x=a;y=b; } T max( ) { ...
c++——类模板
afootball的博客
11-06 1071
类模板类格式：template <class Type> 1.关键字template告诉编译器，将要定义一个模板。 2.<>尖括号中的内容相当于函数的参数列表。 3.可以把关键字class看作是变量类型名，该变量接受类型作为其值。 这里使用class并不意味着Type必须是一个类；而只是表明Type是一个通用的类型说明符。 4.把Type看作是该变量的名称。 一、类模板demon #include<iostream> #include<string> #
C++模板之类模板
weixin_42750185的博客
03-03 500
语法：template < typename T> 一、使用方法 //类模板 template <class T1,class T2> class Person { public: Person(T1 _name, T2 _age) { this->age = _age; this->name = _name; } T1 name; T2 age; }; 使用：Person<st
C++之类模板的概念和意义
weixin_43985500的博客
10-07 1860
类模板 一些类主要用于存储和组织数据元素 类中数据组织的方式和数据元素的具体类型无关 如：数组类、链表类、Stack、Queue类、等 1、C++中将模板的思想应用于类，使得类的实现不关注数据元素的具体类型，而只关注类所需要实现的功能。 C++中的类模板 1、以相同的方式处理不同的类型 2、在类声明前使用template进行标识； 3、用于说明类中使用的泛指类型T， 类模板的应用 1、只能显示指定具体类型，无法自动推导， 2、使用具体类型定义对象， 声明的泛型类型T可以出现在类模板的任意地方 编译器对类模
c++类模板
qq_45528961的博客
02-08 351
●建立一个通用类,类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。typename – 表面其后面的符号是-种数据类型, 可以用class代替。T — 通用的数据类型,名称可以替换，通常为大写字母。3.整个类模板化—— 将这个对象类型模板化进行传递。2.参数模板化——将对象中的参数变为模板进行传递。1.指定传入的类型——直接显示对象的数据类型。2.类模板在模板参数列表中可以有默认参数。1.类模板没有自动类型推导的使用方式。template — 声明创建模板。
C++类模板深度解析：从基础到进阶
"C++类模板学习指南，深入理解C++中...在后续的学习中，你可能还会接触到模板特化、模板元编程等更高级的概念，这些都是C++模板技术的延伸。不断实践和探索，你将能熟练运用类模板来解决实际问题，提升自己的编程能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值