第一百一十三天学习记录：C++提高：类模板（黑马教学视频）

于 2023-07-21 23:16:55 发布
阅读量880 收藏
点赞数
分类专栏： 编程语言学习 文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45694614/article/details/131819671
版权

类模板

类模板语法

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

template<typename T>
类

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

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

template<class NameType,class AgeType>
struct 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();
	return 0;
}

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

类模板与函数模板区别

类模板与函数模板区别主要有两点：
1、类模板没有自动类型推导的使用方式
2、类模板在模板参数列表中可以有默认参数

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

template<class NameType, class AgeType = int>
struct 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 p1("孙悟空", 999);//报错，无法用自动类型推导
	Person<string, int>p1("孙悟空", 999);
	p1.showPerson();
}
//2、类模板在模板参数列表中可以有默认参数
void test02()
{
	Person<string>p2("猪八戒",999);
	p2.showPerson();
}

int main()
{
	test01();
	test02();
	return 0;
}

总结：
1、类模板使用只能用显示指定类型方式
2、类模板中的模板参数列表可以有默认参数

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：
1、普通类中的成员函数一开始就可以创建
2、类模板中的成员函数在调用时才创建

#include <iostream>
using namespace std;

class Person1
{
public:
	void showPersong1()
	{
		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPersong2()
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>
class Myclass
{
public:
	T obj;
	//类模板中的成员函数
	void func1()
	{
		obj.showPerson1();
	}

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

int main()
{

	return 0;
}

上述代码可以运行，因为没有调用成员函数。

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

void test01()
{
	Person<string, int>p("张三", 33);
	printPerson1(p);
}

//2、参数模板化 —— 将对象中的参数变为模板进行传递
template<class T1, class T2>
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("李四", 32);
	printPerson2(p);
}

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

void test03()
{
	Person<string, int>p("王五", 35);
	printPerson3(p);
}

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

在这里插入图片描述
总结：
1、通过类模板创建的对象，可以有三种方式向函数中进行传参
2、使用比较广泛的是第一种：指定传入的类型

类模板与继承

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

#include <iostream>
using namespace std;

template<class T>
class Base
{
	T m;
};

//class Son :public Base//错误，必须要知道父类中T的类型，才能继承给子类
class Son :public Base<int>
{

};

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 test01()
{
	Son s1;
}

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

int main()
{
	//test01();
	test02();
	return 0;
}

在这里插入图片描述
总结：如果父类是类模板，子类需要指出父类父类中T的数据类型

类模板成员函数类外实现

学习目标：能够掌握类模板中的成员函数类外实现

#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)
{
	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();
	return 0;
}

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

类模板分文件编写

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

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

解决：
1、解决方式1：直接包含.cpp源文件
2、解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
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)
{
	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;
}

main

//第一种解决方式，直接包含源文件
//#include "person.cpp"//少用
//第二种解决方式，将h和cpp中的内容写到仪器，将后缀改为.hpp文件
#include "person.hpp"


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

int main()
{
	test01();
	return 0;
}

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

类模板与友元

学习目标：掌握类模板配合友元函数的类内和类外实现

全局函数类内实现-直接在类内声明友元即可
全局函数类外实现-需要提前让编译器知道全局函数的存在

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

//通过全局函数 打印Person信息
//提前让编译器知道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
{
	//全局函数 类内实现
	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;
	}
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);
	printPerson2(p);
}

int main()
{
	test01();
	return 0;
}

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

肝果
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值