C++类模板

已于 2022-06-20 21:14:36 修改
阅读量92 收藏
点赞数
文章标签： c++ 蓝桥杯 开发语言
于 2022-06-11 18:16:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_60406853/article/details/125235120
版权

01 类模板语法

#include<iostream>
using namespace std;
//类模板

template<class NameType,class AgeType>
class Person
{
public:
	NameType m_Name;
	AgeType m_Age;

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

void _01Test01()
{
	 Person<string, int> p("Tom", 18);//<  >中就相当于模板形参列表
	 p.ShowPerson();
}

void main()
{
	_01Test01();
}

02 类模板与函数模板的区别

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

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

//类模板与函数模板的区别
//1、类模板没有自动类型推导的使用方式
//2、类模板在模板参数列表中可以有默认类型参数 函数模板不可以使用默认类型参数
template<class NameType, class AgeType=int>
class _02Person
{
public:
	NameType m_Name;
	AgeType m_Age;

public:
	_02Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void ShowPerson()
	{
		cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
	}
};

//1、类模板没有自动类型推导的使用方式
void _02Test01()
{
	//_02Person p("Tom", 19);//报错 类模板中没有自动类型推导

	_02Person<string, int> p("Tom", 19);
	p.ShowPerson();
}

//2、类模板在模板参数列表中可以有默认类型参数 
void _02Test02()
{
	//使类模板参数列表中的AgeType默认等于int
	_02Person<string> p1("Tony", 20);
	p1.ShowPerson();

	_02Person<string, string>p2("Jack", "22");
	p2.ShowPerson();
}

void main()
{
	//_02Test01();
	_02Test02();
}

03 类模板中成员函数的创建时机

//类模板中的成员函数并不是一开始就创建的 而是在模板调用时才创建

#include <iostream>
using namespace std;

//类模板中成员函数的创建时机
//类模板中的成员函数并不是一开始就创建的 而是在模板调用时才创建
class Person1
{
public:
	void showPerson1()
	{
		cout << "调用showPerson1" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "调用showPerson2" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj;
public:
	void func1()
	{
		obj.showPerson1();
	}

	void func2()
	{
		obj.showPerson2();
	}
};

void _03Test01()
{
	MyClass<Person1> myClass;
	myClass.func1();
	//myClass.func2();//编译报错 说明函数调用时才会去创建成员函数

}

void main()
{
	_03Test01();
}

04 类模板对象做函数参数

//1、指定传入类型

//2、参数模板化

//3、整个类模板化 使用比较广泛

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

//类模板对象做函数参数
template<class T1,class T2>
class _04Person
{
public:
	T1 m_Name;
	T2 m_Age;

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

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

};

//1、指定传入类型
void PrintPerson1(_04Person<string, int>& p)
{
	p.showPerson();
}
void _04Test01()
{
	_04Person<string, int> p("Tom", 19);
	PrintPerson1(p);
}

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

void _04Test02()
{
	_04Person<string, int> p("Tony", 29);
	PrintPerson2(p);
}

//3、整个类模板化 使用比较广泛'
template<class T>
void PrintPerson3(T& p)
{
	cout << "T的类型为：" << typeid(T).name() << endl;
	p.showPerson();
}
void _04Test03()
{
	_04Person<string, int> p("Jack", 39);
	PrintPerson3(p);
}

void main()
{
	_04Test01();
	_04Test02();
	_04Test03();
}

05 类模板与继承

//当类模板碰到继承时，需要注意以下几点：
//1、当子类继承的父类为类模板时，子类在声明时，必须指定父类中T的类型
//2、如果不指定，编译器无法给子类分配内存
//3、如果想灵活指定出父类中T的类型，子类也需要变为类模板

#include <iostream>
using namespace std;
//当类模板碰到继承时，需要注意以下几点：
//1、当子类继承的父类为类模板时，子类在声明时，必须指定父类中T的类型
//2、如果不指定，编译器无法给子类分配内存
//3、如果想灵活指定出父类中T的类型，子类也需要变为类模板

//类模板与继承
template<class T >
class Base
{
public:
	T m_Member;

};


//如果不指定，编译器无法给子类分配内存
//class Son1:Base//报错 没有指明父类中T的数据类型
class Son1 :Base<int>
{

};


//如果想灵活指定出父类中T的类型，子类也需要变为类模板
template<class T1,class T2>
class Son2 :Base<T1>
{
public:
	T2 m_Member2;

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

};

void _05Test01()
{
	Son2<char, int> s;
}

void main()
{
	_05Test01();
}

06 类模板成员函数类外实现

#include<iostream>
using namespace std;
//类模板成员函数类外实现
template<class T1,class T2>
class Student
{
public:
	T1 m_Name;
	T2 m_Age;

	Student(T1 name, T2 age);

	void showStudent();
};

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

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


void _06Test01()
{
	Student<string, int >s1("Tom", 19);
	s1.showStudent();
}

void main()
{
	_06Test01();
}

07 类模板分文件编写

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

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

hpp文件：

#pragma once
#include<iostream>
using namespace std;
template<class T1, class T2>
class _07Person
{
public:
	T1 m_Name;
	T2 m_Age;

	_07Person(T1 name, T2 age);

	void showPerson();
};

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


template<class T1, class T2>
void _07Person<T1, T2>::showPerson()
{
	cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
#include<iostream>

using namespace std;

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

//解决方法：
//方式1：直接包含.cpp源文件
//#include"person.cpp"


//方式2：将声名和实现写到同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制
#include"person.hpp"

void _07Test01()
{
	_07Person<string, int> p("Tom", 18);
	p.showPerson();
}

void main()
{
	_07Test01();

}

08 类模板与友元

#include<iostream>
using namespace std;

//在编写友元函数实现之前还要提前声明类模板
template<class T1, class T2>
class _08Person;

//友元函数类外实现需要在类之前编写实现
template<class T1, class T2>
void showPerson2(_08Person<T1, T2> p)
{
	cout << "name: " << p.m_Name << " age:" << p.m_Age << endl;
}


template<class T1, class T2>
class _08Person
{
	//友元函数类内实现
	friend void showPerson1(_08Person<T1, T2> p)
	{
		cout << "name: " << p.m_Name << " age:" << p.m_Age << endl;
	}

	//友元函数类外实现 还需要加空模板参数列表
	//如果全局函数是类外实现，还需要让编译器提前知道这个函数的存在
	friend void showPerson2<>(_08Person<T1, T2> p);

public:
	T1 m_Name;
	T2 m_Age;

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

};

void _08Test01()
{
	_08Person<string, int>p("Jerry", 19);

	showPerson1(p);
}

void _08Test02()
{
	_08Person<string, int>p("Jack", 20);

	showPerson2(p);
}

void main()
{
	//_08Test01();
	_08Test02();

}

09 类模板案例-通用数组类封装

MyArray.hpp文件：

//自己的通用的数组类
#pragma once
#include <iostream>
#include "MyArray.hpp"
using namespace std;


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

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

	for (int i = 0; i < 5; i++)
	{
		arr1.Push_Back(i);
	}

	cout << "arr1的打印输出：" << endl;
	PrintArray(arr1);
}

void _09Test02()
{
	MyArray<string> arr(10);

	arr.Push_Back("小一");
	arr.Push_Back("小二");
	arr.Push_Back("小三");
	arr.Push_Back("小四");
	arr.Push_Back("小五");

	PrintArray(arr);
	cout << "容量" << arr.getCapacity() << endl;
	cout << "数量" << arr.getSize() << endl;
}

void main()
{
	_09Test01();

	_09Test02();
}

测试文件：

//自己的通用的数组类
#pragma once
#include <iostream>
#include "MyArray.hpp"
using namespace std;


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

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

	for (int i = 0; i < 5; i++)
	{
		arr1.Push_Back(i);
	}

	cout << "arr1的打印输出：" << endl;
	PrintArray(arr1);
}

void _09Test02()
{
	MyArray<string> arr(10);

	arr.Push_Back("小一");
	arr.Push_Back("小二");
	arr.Push_Back("小三");
	arr.Push_Back("小四");
	arr.Push_Back("小五");

	PrintArray(arr);
	cout << "容量" << arr.getCapacity() << endl;
	cout << "数量" << arr.getSize() << endl;
}

void main()
{
	_09Test01();

	_09Test02();
}

补充：

类模板中的静态成员变量

不同的具体类所共享的静态成员变量不同

示例：

#include<iostream>
using namespace std;

//类模板中的静态成员变量
template<class T>
class MyClass10
{
public:
	static int a;
};

//静态成员类外赋值
template<class T>
int MyClass10<T>::a = 0;

void main()
{
	MyClass10<int> m1, m2,m3;

	MyClass10<char> mm1, mm2, mm3;

	m1.a = 10;
	mm1.a = 100;
	cout << "MyClass10<int>: m1:" << m1.a << " m2:" << m2.a << " m3:" << m3.a << endl;
	cout << "MyClass10<char>: mm1:" << mm1.a << " mm2:" << mm2.a << " mm3:" << mm3.a << endl;
}

噗通~280
关注
C++ 类模板与模板类详解
weixin_30907935的博客
11-18 6355
　　在C++的Template中很多地方都用到了typename与class这两个关键字，有时候这两者可以替换，那么这两个关键字是否完全一样呢？ 　　事实上class用于定义类，在模板引入c++后，最初定义模板的方法为:template<class T>,这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键...
C++：模板类
07-09 255
22.模板类 22.1 模板类 模板是泛型编程的基础，那什么是泛型编程呢？泛型编程是一种独立于任何特定数据类型编写代码的方式。 C++标准模板库中的数据容器、迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。比如动态数组vector是可以存放任何类型数据的容器，我们可以定义许多不...
【C++】模板详解（函数模板 和 类模板）
最新发布
2302_76713442的博客
03-29 1431
1.模板的分类（函数模板 和 类模板） 2. 模板的原理（模板只是一个模具，它本身并不是函数 或 类。模板只有实例化之后才生成对应的函数 或 类） 3. 函数模板的实例化（隐式实例化 和 显示实例化）和 类模板的实例化（与函数模板实例化不同，类模板实例化需要在类模板名字后跟< >，然后将实例化的类型放在< >中） 4. 模板的特化（全特化 和 偏特化）
C++ 类模板、函数模板全特化、偏特化的使用
08-25
C++ 类模板、函数模板全特化、偏特化的使用 类模板全特化和偏特化是 C++ 编程语言中非常重要的概念，它们都是模板元编程的基础。类模板全特化和偏特化可以让开发者更好地控制模板的行为，提高代码的灵活性和可维护...
C++ 类模板详解：代码复用与灵活性的新突破
03-25
内容概要：该文档系统介绍了 C++ 类模板的基础概念、定义语法、使用方法以及高级技巧，旨在帮助读者深刻理解类模板的工作机制，并能在实际编程中灵活运用。文章从类模板的基本定义出发，讲解了其与普通类的区别，...
C++类模板与模板类深入详解
09-04
C++类模板与模板类是C++编程中重要的特性，它们提供了泛型编程的能力，允许程序员编写出能够处理多种数据类型的一般性代码。本文将深入探讨这两个概念及其相关知识点。 1. 关键字`typename`与`class`： 在C++的模板...
c++ 类模板
01-28
很不错的类模板，
C++模板笔记四：类模板；类模板与函数模板的区别；类模板中成员函数创建时机
xiaoyaolangwj的博客
01-27 664
类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体指定，用一个虚拟的类型来代表。 语法： template<typename T> 类 // 函数模板此处写函数，类模板，此处写类。 解释： template：声明创建模板 typename：表明其后面的符号是一种数据类型，可以用class代替。 T ：通用的数据类型，名称可以替换，通常为大写字母。 普通类:成员属性确定。 // 普通类 class Person1 { public: Person1(string
c++类模板
weixin_50866517的博客
04-11 526
类模板类模板与函数模板的区别类模板作为函数的参数类模板中成员函数创建时机类模板对象做函数参数二级标题三级标题四级标题五级标题六级标题 1.C++ 除了支持函数模板，还支持类模板（Class Template）。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。 3.语法： template<class T1, class T2> class 类名 {...} 4.类模板和函数模板都是以 template
C++模板知识小结
weixin_34204057的博客
08-14 101
  模板定义：模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数， 从而实现了真正的代码可重用性。模版可以分为两类，一个是函数模版，另外一个是类模版。  由于类模板包含类型参数，因此又称为参数化的类。如果说类是对象的抽象，对象是类的实例，则类模板是类的抽象，类是类模板的实例。 1.模板的概念 模板定义 函数模板：template &lt;typena...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值