馆陶网站,苏州诗华洛网站建设,株洲网站建设技术托管,后台查看网站容量c基础学习第天#xff08;多态#xff0c;文件操作#xff0c;模板#xff09; 文章目录 1、多态1.1、多态的基本概念1.2、纯虚函数和抽象类1.3、虚析构和纯虚析构 2、文件操作2.1、文本文件2.1.1、写文件2.1.2、读文件 2.2、二进制文件2.2.1、写文件2.2.2、读文件 C提高编… c基础学习第天多态文件操作模板 文章目录 1、多态1.1、多态的基本概念1.2、纯虚函数和抽象类1.3、虚析构和纯虚析构 2、文件操作2.1、文本文件2.1.1、写文件2.1.2、读文件 2.2、二进制文件2.2.1、写文件2.2.2、读文件 C提高编程3、模板3.1、模板的概念3.2、函数模板3.2.1、函数模板语法3.2.2、函数模板注意事项3.2.3、函数模板案例3.2.4、普通函数与函数模板的区别3.2.5、普通函数与函数模板的调用规则3.2.6、模板的局限性 3.3、类模板3.3.1、类模板语法3.3.2 类模板与函数模板区别3.3.3、类模板中成员函数创建时机3.3.4、类模板对象做函数参数3.3.5、类模板与继承3.3.6、类模板成员函数类外实现3.3.7、类模板分文件编写3.3.8、类模板与友元3.3.9、类模板案例 提示以下是本篇文章正文内容下面案例可供参考
1、多态
1.1、多态的基本概念
多态是C面向对象三大特性之一
多态分为两类
静态多态: 函数重载 和 运算符重载属于静态多态复用函数名(函数重载或运算符重载 )动态多态: 派生类和虚函数实现运行时多态
静态多态和动态多态区别
静态多态的函数地址早绑定 - 编译阶段确定函数地址动态多态的函数地址晚绑定 - 运行阶段确定函数地址
//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话那么这个函数地址就不能提前绑定需要在运行阶段进行绑定地址晚绑
void doSpeak (Animal animal)//Animal animal cat;//c允许父类和子类之间的类型自动转换
{animal.speak()
}
void test01(){Cat cat;doSpeak(cat):
}
//重写 函数返回值类型 函数名 参数列表 完全相同//动态多态满足条件 //1、有继承关系 //2、子类重写父类的虚函数
//动态多态使用 //父类的指针或者引用 指向子类对象
class Animal
{
public://Speak函数就是虚函数//函数前面加上virtual关键字变成虚函数那么编译器在编译的时候就不能确定函数调用了。virtual void speak(){cout 动物在说话 endl;}
};class Cat :public Animal
{
public:void speak(){cout 小猫在说话 endl;}
};class Dog :public Animal
{
public:void speak(){cout 小狗在说话 endl;}};
//我们希望传入什么对象那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定那么静态联编
//如果函数地址在运行阶段才能确定就是动态联编void DoSpeak(Animal animal)
{animal.speak();
}
//
//多态满足条件
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用
//父类指针或引用指向子类对象void test01()
{Cat cat;DoSpeak(cat);Dog dog;DoSpeak(dog);
}int main() {test01();system(pause);return 0;
}总结
多态满足条件
有继承关系子类重写父类中的虚函数
多态使用条件
父类指针或引用指向子类对象
重写函数返回值类型 函数名 参数列表 完全一致称为重写
案例//如果想扩展新的功能需求修改源码//在真是开发中提倡开闭原则//开闭原则对扩展进行开发对修改进行关闭//利用多态实现计算器
//多态好处
//1、组织结构清晰
//2、可读性强
//3、对于前期和后期扩展以及维护性高1.2、纯虚函数和抽象类
在多态中通常父类中虚函数的实现是毫无意义的主要都是调用子类重写的内容 因此可以将虚函数改为纯虚函数 纯虚函数语法virtual 返回值类型 函数名 参数列表 0 ; 当类中有了纯虚函数这个类也称为抽象类
抽象类特点
无法实例化对象子类必须重写抽象类中的纯虚函数否则也属于抽象类
//纯虚函数 //只要有一个纯虚函数这个类称为抽象类 //抽象类特点 //1、无法实例化对象 //2、抽象类的子类必须要重写父类中的纯虚函数否则也属于抽象类
class Base
{
public://纯虚函数//类中只要有一个纯虚函数就称为抽象类//抽象类无法实例化对象//子类必须重写父类中的纯虚函数否则也属于抽象类virtual void func() 0;
};class Son :public Base
{
public:virtual void func() {cout func调用 endl;};
};void test01()
{Base * base NULL;//base new Base; // 错误抽象类无法实例化对象base new Son;base-func();delete base;//记得销毁
}int main() {test01();system(pause);return 0;
}1.3、虚析构和纯虚析构
多态使用时如果子类中有属性开辟到堆区那么父类指针在释放时无法调用到子类的析构代码
解决方式将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性
可以解决父类指针释放子类对象都需要有具体的函数实现
虚析构和纯虚析构区别
如果是纯虚析构该类属于抽象类无法实例化对象
虚析构语法 virtual ~类名(){}
纯虚析构语法 virtual ~类名() 0; 类名::~类名(){}
//父类指针在析构时候不会调用子类中析构函数导致子类如果有堆区属性出现内存泄漏
//利用虚析构可以解决父类指针释放子类对象时不干净的问题
virtual ~Animal(){}//纯虚析构需要声明也需要实现
//有了纯虚析构之后这个类也属于抽象类无法实例化对象因为要释放可能生成的堆区
virtual ~Animal()0;
//纯虚函数(不需要实例化)
virtual void speak()0;class Animal {
public:Animal(){cout Animal 构造函数调用 endl;}virtual void Speak() 0;//析构函数加上virtual关键字变成虚析构函数//virtual ~Animal()//{// cout Animal虚析构函数调用 endl;//}virtual ~Animal() 0;
};Animal::~Animal()
{cout Animal 纯虚析构函数调用 endl;
}//和包含普通纯虚函数的类一样包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。class Cat : public Animal {
public:Cat(string name){cout Cat构造函数调用 endl;m_Name new string(name);}virtual void Speak(){cout *m_Name 小猫在说话! endl;}~Cat(){cout Cat析构函数调用! endl;if (this-m_Name ! NULL) {delete m_Name;m_Name NULL;}}public:string *m_Name;
};void test01()
{Animal *animal new Cat(Tom);animal-Speak();//通过父类指针去释放会导致子类对象可能清理不干净造成内存泄漏//怎么解决给基类增加一个虚析构函数//虚析构函数就是用来解决通过父类指针释放子类对象delete animal;
}int main() {test01();system(pause);return 0;
}总结 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象 2. 如果子类中没有堆区数据可以不写为虚析构或纯虚析构 3. 拥有纯虚析构函数的类也属于抽象类
2、文件操作
程序运行时产生的数据都属于临时数据程序一旦运行结束都会被释放 通过文件可以将数据持久化 C中对文件操作需要包含头文件fstream
文件类型分为两种
文本文件 - 文件以文本的ASCII码形式存储在计算机中(可看懂)二进制文件 - 文件以文本的二进制形式存储在计算机中用户一般不能直接读懂它们
操作文件的三大类:
ofstream写操作ifstream 读操作fstream 读写操作
2.1、文本文件
2.1.1、写文件
写文件步骤如下 包含头文件 #include 创建流对象 ofstream ofs; 打开文件 ofs.open(“文件路径”,打开方式); 写数据 ofs “写入的数据”; 关闭文件 ofs.close();
文件打开方式
打开方式解释ios::in为读文件而打开文件ios::out为写文件而打开文件ios::ate初始位置文件尾ios::app追加方式写文件ios::trunc如果文件存在先删除再创建ios::binary二进制方式
注意 文件打开方式可以配合使用利用|操作符
**例如**用二进制方式写文件 ios::binary | ios:: out总结
* 文件操作必须包含头文件 fstream
* 读文件可以利用 ofstream 或者fstream类
* 打开文件时候需要指定操作文件的路径以及打开方式
* 利用可以向文件中写数据
* 操作完毕要关闭文件#include fstreamvoid test01()
{ofstream ofs;ofs.open(test.txt, ios::out);ofs 姓名张三 endl;ofs 性别男 endl;ofs 年龄18 endl;ofs.close();
}int main() {test01();system(pause);return 0;
}2.1.2、读文件
读文件与写文件步骤相似但是读取方式相对于比较多
读文件步骤如下 包含头文件 #include fstream 创建流对象 ifstream ifs; 打开文件并判断文件是否打开成功 ifs.open(“文件路径”,打开方式); 读数据 四种方式读取 关闭文件 ifs.close();
总结
读文件可以利用 ifstream 或者fstream类利用is_open函数可以判断文件是否打开成功close 关闭文件
#include fstream
#include string
void test01()
{ifstream ifs;ifs.open(test.txt, ios::in);if (!ifs.is_open()){cout 文件打开失败 endl;return;}//第一种方式//char buf[1024] { 0 };//while (ifs buf)//{// cout buf endl;//}//第二种//char buf[1024] { 0 };//while (ifs.getline(buf,sizeof(buf)))//{// cout buf endl;//}//第三种//string buf;//while (getline(ifs, buf))//{// cout buf endl;//}char c;while ((c ifs.get()) ! EOF){cout c;}ifs.close();}int main() {test01();system(pause);return 0;
}2.2、二进制文件
以二进制的方式对文件进行读写操作 打开方式要指定为 ios::binary
2.2.1、写文件
二进制方式写文件主要利用流对象调用成员函数write 函数原型 ostream write(const char * buffer,int len); 参数解释字符指针buffer指向内存中一段存储空间。len是读写的字节数
#include fstream
#include stringclass Person
{
public:char m_Name[64];int m_Age;
};//二进制文件 写文件
void test01()
{//1、包含头文件//2、创建输出流对象ofstream ofs(person.txt, ios::out | ios::binary);//3、打开文件//ofs.open(person.txt, ios::out | ios::binary);Person p {张三 , 18};//4、写文件ofs.write((const char *)p, sizeof(p));//5、关闭文件ofs.close();
}int main() {test01();system(pause);return 0;
}总结
文件输出流对象 可以通过write函数以二进制方式写数据
2.2.2、读文件
二进制方式读文件主要利用流对象调用成员函数read 函数原型istream read(char *buffer,int len); 参数解释字符指针buffer指向内存中一段存储空间。len是读写的字节数
#include fstream
#include stringclass Person
{
public:char m_Name[64];int m_Age;
};void test01()
{ifstream ifs(person.txt, ios::in | ios::binary);if (!ifs.is_open()){cout 文件打开失败 endl;}Person p;ifs.read((char *)p, sizeof(p));cout 姓名 p.m_Name 年龄 p.m_Age endl;
}int main() {test01();system(pause);return 0;
}C提高编程
本阶段主要针对C泛型编程和STL技术做详细讲解探讨C更深层的使用
3、模板
3.1、模板的概念
模板就是建立通用的模具大大提高复用性
模板的特点
模板不可以直接使用它只是一个框架模板的通用并不是万能的
3.2、函数模板
C另一种编程思想称为 泛型编程 主要利用的技术就是模板C提供两种模板机制:函数模板和类模板
3.2.1、函数模板语法
函数模板作用 建立一个通用函数其函数返回值类型和形参类型可以不具体制定用一个虚拟的类型来代表。
语法
templatetypename T
函数声明或定义解释 template — 声明创建模板 typename — 表面其后面的符号是一种数据类型可以用class代替 T — 通用的数据类型名称可以替换通常为大写字母
int a 10;
int b 20;
//swapInt (a,b);
//利用函数模板交换
//两种方式使用函数模板
//1、自动类型推导
//mySwap (a,b);
//2、显示指定类型
mySwapint(a, b);//类型参数化
cout a a endl;
cout b b endl;//交换整型函数
void swapInt(int a, int b) {int temp a;a b;b temp;
}//交换浮点型函数
void swapDouble(double a, double b) {double temp a;a b;b temp;
}//利用模板提供通用的交换函数
templatetypename T
void mySwap(T a, T b)
{T temp a;a b;b temp;
}void test01()
{int a 10;int b 20;//swapInt(a, b);//利用模板实现交换//1、自动类型推导mySwap(a, b);//2、显示指定类型mySwapint(a, b);cout a a endl;cout b b endl;}int main() {test01();system(pause);return 0;
}总结
函数模板利用关键字 template使用函数模板有两种方式自动类型推导、显示指定类型模板的目的是为了提高复用性将类型参数化
3.2.2、函数模板注意事项
注意事项
自动类型推导必须推导出一致的数据类型T,才可以使用模板必须要确定出T的数据类型才可以使用
//利用模板提供通用的交换函数
templateclass T
void mySwap(T a, T b)
{T temp a;a b;b temp;
}// 1、自动类型推导必须推导出一致的数据类型T,才可以使用
void test01()
{int a 10;int b 20;char c c;mySwap(a, b); // 正确可以推导出一致的T//mySwap(a, c); // 错误推导不出一致的T类型
}// 2、模板必须要确定出T的数据类型才可以使用
templateclass T
void func()
{cout func 调用 endl;
}void test02()
{//func(); //错误模板不能独立使用必须确定出T的类型funcint(); //利用显示指定类型的方式给T一个类型才可以使用该模板
}int main() {test01();test02();system(pause);return 0;
}总结
使用模板时必须确定出通用数据类型T并且能够推导出一致的类型
3.2.3、函数模板案例
案例描述
利用函数模板封装一个排序的函数可以对不同数据类型数组进行排序排序规则从大到小排序算法为选择排序分别利用char数组和int数组进行测试
//交换的函数模板
templatetypename T
void mySwap(T a, Tb)
{T temp a;a b;b temp;
}templateclass T // 也可以替换成typename
//利用选择排序进行对数组从大到小的排序
void mySort(T arr[], int len)
{for (int i 0; i len; i){int max i; //最大数的下标for (int j i 1; j len; j){if (arr[max] arr[j]){max j;}}if (max ! i) //如果最大数的下标不是i交换两者{mySwap(arr[max], arr[i]);}}
}
templatetypename T
void printArray(T arr[], int len) {for (int i 0; i len; i) {cout arr[i] ;}cout endl;
}
void test01()
{//测试char数组char charArr[] bdcfeagh;int num sizeof(charArr) / sizeof(char);mySort(charArr, num);printArray(charArr, num);
}void test02()
{//测试int数组int intArr[] { 7, 5, 8, 1, 3, 9, 2, 4, 6 };int num sizeof(intArr) / sizeof(int);mySort(intArr, num);printArray(intArr, num);
}int main() {test01();test02();system(pause);return 0;
}总结模板可以提高代码复用需要熟练掌握
3.2.4、普通函数与函数模板的区别
普通函数与函数模板区别
普通函数调用时可以发生自动类型转换隐式类型转换函数模板调用时如果利用自动类型推导不会发生隐式类型转换如果利用显示指定类型的方式可以发生隐式类型转换
//普通函数
int myAdd01(int a, int b)
{return a b;
}//函数模板
templateclass T
T myAdd02(T a, T b)
{return a b;
}//使用函数模板时如果用自动类型推导不会发生自动类型转换,即隐式类型转换
void test01()
{int a 10;int b 20;char c c;cout myAdd01(a, b) endl; //正确cout myAdd01(a, c) endl; //正确将char类型的c隐式转换为int类型 c 对应 ASCII码 99//myAdd02(a, c); // 报错使用自动类型推导时不会发生隐式类型转换myAdd02int(a, c); //正确如果用显示指定类型可以发生隐式类型转换}int main() {test01();system(pause);return 0;
}
总结建议使用显示指定类型的方式调用函数模板因为可以自己确定通用类型T
3.2.5、普通函数与函数模板的调用规则
调用规则如下
如果函数模板和普通函数都可以实现优先调用普通函数可以通过空模板参数列表来强制调用函数模板函数模板也可以发生重载如果函数模板可以产生更好的匹配,优先调用函数模板
//普通函数与函数模板调用规则
void myPrint(int a, int b)
{cout 调用的普通函数 endl;
}templatetypename T
void myPrint(T a, T b)
{cout 调用的模板 endl;
}templatetypename T
void myPrint(T a, T b, T c)
{cout 调用重载的模板 endl;
}void test01()
{//1、如果函数模板和普通函数都可以实现优先调用普通函数// 注意 如果告诉编译器 普通函数是有的但只是声明没有实现或者不在当前文件内实现就会报错找不到int a 10;int b 20;myPrint(a, b); //调用普通函数//2、可以通过空模板参数列表来强制调用函数模板myPrint(a, b); //调用函数模板//3、函数模板也可以发生重载int c 30;myPrint(a, b, c); //调用重载的函数模板//4、 如果函数模板可以产生更好的匹配,优先调用函数模板char c1 a;char c2 b;myPrint(c1, c2); //调用函数模板
}int main() {test01();system(pause);return 0;
}总结既然提供了函数模板最好就不要提供普通函数否则容易出现二义性
3.2.6、模板的局限性
局限性
模板的通用性并不是万能的
例如 templateclass Tvoid f(T a, T b){a b;}数组不可以赋值为数组 在上述代码中提供的赋值操作如果传入的a和b是一个数组就无法实现了
再例如 templateclass Tvoid f(T a, T b){if(a b) { ... }}在上述代码中如果T的数据类型传入的是像Person这样的自定义数据类型也无法正常运行
因此C为了解决这种问题提供模板的重载可以为这些特定的类型提供具体化的模板
//模板局限性 //模板并不是万能的有些特定数据类型需要用具体化方式做特殊实现 //类之间的运算比较等-》不好使可以运算符重载或具体化函数
#includeiostream
using namespace std;#include stringclass Person
{
public:Person(string name, int age){this-m_Name name;this-m_Age age;}string m_Name;int m_Age;
};//普通函数模板
templateclass T
bool myCompare(T a, T b)
{if (a b){return true;}else{return false;}
}//具体化显示具体化的原型和定意思以template开头并通过名称来指出类型
//具体化优先于常规模板
template bool myCompare(Person p1, Person p2)
{if ( p1.m_Name p2.m_Name p1.m_Age p2.m_Age){return true;}else{return false;}
}void test01()
{int a 10;int b 20;//内置数据类型可以直接使用通用的函数模板bool ret myCompare(a, b);if (ret){cout a b endl;}else{cout a ! b endl;}
}void test02()
{Person p1(Tom, 10);Person p2(Tom, 10);//自定义数据类型不会调用普通的函数模板//可以创建具体化的Person数据类型的模板用于特殊处理这个类型bool ret myCompare(p1, p2);if (ret){cout p1 p2 endl;}else{cout p1 ! p2 endl;}
}int main() {test01();test02();system(pause);return 0;
}总结
利用具体化的模板可以解决自定义类型的通用化学习模板并不是为了写模板而是在STL能够运用系统提供的模板
3.3、类模板
3.3.1、类模板语法
类模板作用
建立一个通用类类中的成员 数据类型可以不具体制定用一个虚拟的类型来代表。
语法
templatetypename T
类解释 template — 声明创建模板 typename — 表面其后面的符号是一种数据类型可以用class代替 T — 通用的数据类型名称可以替换通常为大写字母
#include string
//类模板
templateclass 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类型Personstring, intP1(孙悟空, 999);P1.showPerson();
}int main() {test01();system(pause);return 0;
}总结类模板和函数模板语法相似在声明模板template后面加类此类称为类模板
3.3.2 类模板与函数模板区别
类模板与函数模板区别主要有两点
1. 类模板没有自动类型推导的使用方式:
//Personstring, intP1(孙悟空, 999);
/Person p(孙悟空,1000);//错误无法用自动类型推导
Personstring,intp(孙悟空1000)//正确只能用显示指定类型
2. 类模板在模板参数列表中可以有默认参数(函数模板没有)
templateclass NameType, class AgeType int
Person string p(猪八戒, 999); //类模板中的模板参数列表 可以指定默认#include string
//类模板
templateclass NameType, class AgeType int
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;
};//1、类模板没有自动类型推导的使用方式
void test01()
{// Person p(孙悟空, 1000); // 错误 类模板使用时候不可以用自动类型推导Person string ,intp(孙悟空, 1000); //必须使用显示指定类型的方式使用类模板p.showPerson();
}//2、类模板在模板参数列表中可以有默认参数
void test02()
{Person string p(猪八戒, 999); //类模板中的模板参数列表 可以指定默认参数p.showPerson();
}int main() {test01();test02();system(pause);return 0;
}总结
类模板使用只能用显示指定类型方式类模板中的模板参数列表可以有默认参数
3.3.3、类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的
普通类中的成员函数一开始就可以创建类模板中的成员函数在调用时才创建
class Person1
{
public:void showPerson1(){cout Person1 show endl;}
};class Person2
{
public:void showPerson2(){cout Person2 show endl;}
};templateclass T
class MyClass
{
public:T obj;//类模板中的成员函数并不是一开始就创建的而是在模板调用时再生成void fun1() { obj.showPerson1(); }void fun2() { obj.showPerson2(); }};void test01()
{MyClassPerson1 m;m.fun1();//m.fun2();//编译会出错说明函数调用才会去创建成员函数
}int main() {test01();system(pause);return 0;
}总结类模板中的成员函数并不是一开始就创建的在调用时才去创建
3.3.4、类模板对象做函数参数
学习目标
类模板实例化出的对象向函数传参的方式
一共有三种传入方式
指定传入的类型**** — 直接显示对象的数据类型参数模板化 — 将对象中的参数变为模板进行传递整个类模板化 — 将这个对象类型 模板化进行传递 示例
#include string
//类模板
templateclass NameType, class AgeType int
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;
};//1、指定传入的类型
void printPerson1(Personstring, int p)
{p.showPerson();
}
void test01()
{Person string, int p(孙悟空, 100);printPerson1(p);
}//2、参数模板化
template class T1, class T2
void printPerson2(PersonT1, T2p)
{p.showPerson();cout T1的类型为 typeid(T1).name() endl;cout T2的类型为 typeid(T2).name() endl;
}
void test02()
{Person string, int p(猪八戒, 90);printPerson2(p);
}//3、整个类模板化
templateclass T
void printPerson3(T p)
{cout T的类型为 typeid(T).name() endl;p.showPerson();}
void test03()
{Person string, int p(唐僧, 30);printPerson3(p);
}int main() {test01();test02();test03();system(pause);return 0;
}总结
通过类模板创建的对象可以有三种方式向函数中进行传参使用比较广泛是第一种指定传入的类型
3.3.5、类模板与继承
当类模板碰到继承时需要注意一下几点
当子类继承的父类是一个类模板时子类在声明的时候要指定出父类中T的类型如果不指定编译器无法给子类分配内存如果想灵活指定出父类中T的类型子类也需变为类模板 示例
templateclass T
class Base
{T m;
};//class Son:public Base //错误c编译需要给子类分配内存必须知道父类中T的类型才可以向下继承
class Son :public Baseint //必须指定一个类型
{
};
void test01()
{Son c;
}//类模板继承类模板 ,可以用T2指定父类中的T类型
templateclass T1, class T2
class Son2 :public BaseT2
{
public:Son2(){cout typeid(T1).name() endl;cout typeid(T2).name() endl;}
};void test02()
{Son2int, char child1;
}int main() {test01();test02();system(pause);return 0;
}总结如果父类是类模板子类需要指定出父类中T的数据类型
3.3.6、类模板成员函数类外实现
学习目标能够掌握类模板中的成员函数类外实现
示例
#include string//类模板中成员函数类外实现
templateclass T1, class T2
class Person {
public://成员函数类内声明Person(T1 name, T2 age);void showPerson();public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
templateclass T1, class T2
PersonT1, T2::Person(T1 name, T2 age) {this-m_Name name;this-m_Age age;
}//成员函数 类外实现
templateclass T1, class T2
void PersonT1, T2::showPerson() {cout 姓名: this-m_Name 年龄: this-m_Age endl;
}void test01()
{Personstring, int p(Tom, 20);p.showPerson();
}int main() {test01();system(pause);return 0;
}总结类模板中成员函数类外实现时需要加上模板参数列表
3.3.7、类模板分文件编写
学习目标
掌握类模板成员函数分文件编写产生的问题以及解决方式
问题
类模板中成员函数创建时机是在调用阶段导致分文件编写时链接不到
解决
解决方式1直接包含.cpp源文件解决方式2将声明和实现写到同一个文件中并更改后缀名为.hpphpp是约定的名称并不是强制
示例 person.hpp中代码
#pragma once
#include iostream
using namespace std;
#include stringtemplateclass T1, class T2
class Person {
public:Person(T1 name, T2 age);void showPerson();
public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
templateclass T1, class T2
PersonT1, T2::Person(T1 name, T2 age) {this-m_Name name;this-m_Age age;
}//成员函数 类外实现
templateclass T1, class T2
void PersonT1, T2::showPerson() {cout 姓名: this-m_Name 年龄: this-m_Age endl;
}类模板分文件编写.cpp中代码
#includeiostream
using namespace std;//#include person.h
#include person.cpp //解决方式1包含cpp源文件//解决方式2将声明和实现写到一起文件后缀名改为.hpp(放类模板)
#include person.hpp
void test01()
{Personstring, int p(Tom, 10);p.showPerson();
}int main() {test01();system(pause);return 0;
}总结主流的解决方式是第二种将类模板成员函数写到一起并将后缀名改为.hpp
3.3.8、类模板与友元
学习目标
掌握类模板配合友元函数的类内和类外实现
全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在
示例
#include string//2、全局函数配合友元 类外实现 - 先做函数模板声明下方在做函数模板定义在做友元
templateclass T1, class T2 class Person;//如果声明了函数模板可以将实现写到后面否则需要将实现体写到类的前面让编译器提前看到
//templateclass T1, class T2 void printPerson2(PersonT1, T2 p);templateclass T1, class T2
void printPerson2(PersonT1, T2 p)
{cout 类外实现 ---- 姓名 p.m_Name 年龄 p.m_Age endl;
}templateclass T1, class T2
class Person
{//1、全局函数配合友元 类内实现friend void printPerson(PersonT1, T2 p){cout 姓名 p.m_Name 年龄 p.m_Age endl;}//全局函数配合友元 类外实现//全局函数类外实现//加空模板参数列表//如果全局函数是类外实现需要让编译器提前知道这个函数的存在friend void printPerson2(PersonT1, 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, 30);printPerson2(p);
}int main() {//test01();test02();system(pause);return 0;
}总结建议全局函数做类内实现用法简单而且编译器可以直接识别
3.3.9、类模板案例
案例描述: 实现一个通用的数组类要求如下
可以对内置数据类型以及自定义数据类型的数据进行存储将数组中的数据存储到堆区构造函数中可以传入数组的容量提供对应的拷贝构造函数以及operator防止浅拷贝问题提供尾插法和尾删法对数组中的数据进行增加和删除可以通过下标的方式访问数组中的元素可以获取数组中当前元素个数和数组的容量
示例
myArray.hpp中代码
#pragma once
#include iostream
using namespace std;templateclass 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; // 大小
};类模板案例—数组类封装.cpp中
#include myArray.hpp
#include stringvoid printIntArray(MyArrayint arr) {for (int i 0; i arr.getSize(); i) {cout arr[i] ;}cout endl;
}//测试内置数据类型
void test01()
{MyArrayint 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;MyArrayint 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(MyArrayPerson personArr)
{for (int i 0; i personArr.getSize(); i) {cout 姓名 personArr[i].m_Name 年龄 personArr[i].m_Age endl;}}void test02()
{//创建数组MyArrayPerson 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;
}总结
能够利用所学知识点实现通用的数组
