（2）类和对象——多态、C++文件操作

小小白-小落

已于 2023-10-11 17:00:28 修改

阅读量45

点赞数

分类专栏： C++学习文章标签： c++

于 2023-08-03 00:26:45 首次发布

本文链接：https://blog.csdn.net/weixin_52542873/article/details/132073665

版权

C++学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

多态

基本语法

多态——C++面向对象三大特性之一

多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区别：

静态多态的函数地址早绑定——编译阶段确定函数地址
动态多态的函数地址晚绑定——运行阶段确定函数地址

class Animal {
public:
	virtual void speak() {//变为虚函数
		cout << "动物在说话" << endl;
	}
};
class Cat :public Animal {
public:
	virtual void speak() {
		cout << "小猫在说话" << endl;
	}
};
//地址早绑定 编译阶段确定函数地址
//如果想执行让猫说话，则函数地址就不能提前绑定，要在运行阶段绑定
void doSpeak(Animal& animal) {//Animal& animal = cat;
	animal.speak();
}
void test01() {
	Cat cat;
	doSpeak(cat);
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

多态满足条件

有继承关系
子类重写父类中的虚函数

多态使用条件

父类指针或引用指向子类对象

重写：

函数返回值类型、函数名、参数列表完全一致称为重写

深入理解多态

原理剖析

当子类重写父类虚函数，子类的虚函数表内部会替换成子类的虚函数地址

当父类的指针或者引用指向子类对象时，发生多态

案例一：计算器类

案例描述：

分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

总结：

C++开发提倡利用多态设计程序架构，因为多态优点很多

//普通写法
class Calculator {
public:
	int getResult(string oper) {
		if (oper == "+") {
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		else if (oper == "*") {
			return m_Num1 * m_Num2;
		}
		//如果想要扩展新的功能，比如加上除法功能，需要修改源码
		//在真实开发中，提倡开闭原则：对扩展进行开放，对修改进行关闭
	}
	int m_Num1;
	int m_Num2;
};
void test01() {
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;
	cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;
	cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}
//多态技术实现
class AbstractCalculator {//先实现计算器抽象类
public:
	virtual int getResult() {
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
class AddCalculator :public AbstractCalculator {//加法计算器类
public:
	int getResult() {
		return m_Num1 + m_Num2;
	}
};
class SubCalculator :public AbstractCalculator {//减法计算器类
public:
	int getResult() {
		return m_Num1 - m_Num2;
	}
};
class MulCalculator :public AbstractCalculator {//乘法计算器类
public:
	int getResult() {
		return m_Num1 * m_Num2;
	}
};
void test02() {
	AbstractCalculator * abc = new AddCalculator;//加法运算
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;//用完后记得销毁
	abc = new SubCalculator;//减法运算
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
	abc = new MulCalculator;//乘法运算
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

纯虚函数和抽象类

在多态，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：

virtual 返回值类型函数名（参数列表）= 0；

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base {
public:
	virtual void func() = 0;//纯虚函数，只要有一个纯虚函数，这个类就称为抽象类
};
class Son :public Base {//子类不重写纯虚函数，就不能实例化对象
public:
	virtual void func() {
		cout << "func 函数调用 " << endl;
	}
};
void test01() {
	//Base b;//抽象类无法实例化对象，报错
	//new Base;//抽象类无法实例化对象，报错
	Base* base = new Son;//new 哪个对象就调用哪个对象的func函数
	base->func();
}
int main() {
	test01();
	system("pause");
	return 0;
}

案例二：制作饮品

制作饮品的大致流程：煮水-冲泡-倒入杯中-加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

class AbstractDrinking {
public:
	virtual void Boil() = 0;//煮水
	virtual void Brew() = 0;//冲泡
	virtual void PourInCup() = 0;//倒入杯中
	virtual void PutSomething() = 0;//加入辅料
	void makeDrink() {//制作饮品，调用此函数，就会执行上述四个步骤
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
};
class Coffee :public AbstractDrinking {
public:
	virtual void Boil() {
		cout << " 煮农夫山泉 " << endl;
	}
	virtual void Brew() {
		cout << " 冲泡咖啡 " << endl;
	}
	virtual void PourInCup() {
		cout << " 倒入杯中 " << endl;
	}
	virtual void PutSomething() {
		cout << " 加入糖和牛奶 " << endl;
	}
};
class Tea :public AbstractDrinking {
public:
	virtual void Boil() {
		cout << " 煮白开水 " << endl;
	}
	virtual void Brew() {
		cout << " 冲泡茶叶 " << endl;
	}
	virtual void PourInCup() {
		cout << " 倒入杯中 " << endl;
	}
	virtual void PutSomething() {
		cout << " 加入枸杞和冰糖 " << endl;
	}
};
void doWork(AbstractDrinking* abs) {//AbstractDrinking* abs = new Coffee
	abs->makeDrink();
	delete abs;//堆区数据手动开辟手动释放，防止内存泄漏
}
void test01(){
	doWork(new Coffee);
	cout << "-----------------------" << endl;
	doWork(new Tea);
}
int main() {
	test01();
	system("pause");
	return 0;
}

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要有具体的函数体现

虚析构和纯虚析构区别：

如果写了纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名（）{ }；

纯虚析构语法：

virtual ~类名（）= 0；—— 声明

类名::~类名（）{ }； —— 实现

class Animal {
public:
	Animal() {
		cout << "Animal 构造函数调用 " << endl;
	}
	//virtual ~Animal() {//利用虚析构解决 父类指针释放子类对象不干净问题
	//	cout << "Animal 析构函数调用 " << endl;
	//}
	virtual ~Animal() = 0;//纯虚析构
	virtual void speak() = 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() {
		if (m_Name != NULL) {
			cout << "Cat 析构函数调用 " << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string* m_Name;
};
void test01() {
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针析构时，不会调用子类析构函数，导致子类如果有堆区属性，出现内存泄露
	delete animal;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

1.虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2.如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3.拥有纯虚析构函数的类也属于抽象类

案例三：电脑组装

案例描述：

电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

//电脑组装
class CPU {//抽象CPU类
public:
	virtual void calculate() = 0;//抽象的计算函数
};
class VideoCard {//抽象显卡类
public:
	virtual void display() = 0;//抽象的显示函数
};
class Memory {//抽象存储条类
public:
	virtual void storage() = 0;//抽象的存储函数
};
class Computer {//电脑类
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* mem) {
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}
	void work() {//提供工作函数，让零件工作起来，调用接口
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	}
	~Computer() {//提供析构函数，释放3个电脑零件
		if (m_cpu != NULL) {//释放CPU零件
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_vc != NULL) {//释放显卡零件
			delete m_vc;
			m_vc = NULL;
		}
		if (m_mem != NULL) {//释放内存条零件
			delete m_mem;
			m_mem = NULL;
		}
	}
private:
	CPU* m_cpu;//CPU零件指针
	VideoCard* m_vc;//显卡零件指针
	Memory* m_mem;//内存条零件指针
};
//具体厂商
class IntelCPU :public CPU {
public:
	virtual void calculate() {
		cout << "Intel CPU开始计算了！" << endl;
	}
};
class IntelVideoCard :public VideoCard {
public:
	virtual void display() {
		cout << "Intel 显卡开始显示了！" << endl;
	}
};
class IntelMemory :public Memory {
public:
	virtual void storage() {
		cout << "Intel 内存条开始存储了！" << endl;
	}
};
class LenovoCPU :public CPU {
public:
	virtual void calculate() {
		cout << "Lenovo CPU开始计算了！" << endl;
	}
};
class LenovoVideoCard :public VideoCard {
public:
	virtual void display() {
		cout << "Lenovo 显卡开始显示了！" << endl;
	}
};
class LenovoMemory :public Memory {
public:
	virtual void storage() {
		cout << "Lenovo 内存条开始存储了！" << endl;
	}
};
void test01() {
	//创建第一台电脑零件
	CPU* intelCpu = new IntelCPU;
	VideoCard* intelCard = new IntelVideoCard;
	Memory* intelMem = new IntelMemory;
	cout << "第一台电脑开始工作：" << endl;
	Computer* computer1 = new Computer(intelCpu, intelCard, intelMem);
	computer1->work();
	delete computer1;
	cout << "----------------------------------" << endl;
	cout << "第二台电脑开始工作：" << endl;
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	computer2->work();
	delete computer2;
	cout << "----------------------------------" << endl;
	cout << "第三台电脑开始工作：" << endl;
	Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
	computer3->work();
	delete computer3;
}
int main() {
	test01();
	system("pause");
	return 0;
}

文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放

通过文件可以将数据持久化

C++中对文件操作需要包含头文件<fstream>

文件类型分为两种：

1.文件文件 - 文件以文本的ASCII码形式存储在计算机中
2.二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

操作文件的三大类：

ofstream：写操作

ifstream：读操作

fstream：读写操作

文本文件

写文件

步骤：

1.包含头文件：#include<fstream>

2.创建流对象：ofstream ofs;

3.打开文件：ofs.open("文件路径",打开方式)；

4.写数据：ofs<<"写入的数据";

5.关闭文件：ofs.close();

文件打开方式：

注意：文件打开方式可以配合使用，利用“ | ”操作符

例如：用二进制方式写文件：

ios::binary | ios::out

#include<fstream>//包含头文件
void test01() {
	ofstream ofs;//创建流对象
	ofs.open("test.txt", ios::out);//指定打开方式，默认文件位置：项目存储位置
	ofs << "姓名：张三" << endl;//写内容
	ofs << "性别：男" << endl;
	ofs << "年龄：20" << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

文件操作必须包含头文件fstream
读文件可以利用ofstream，或者fstream类
打开文件时候需要指定操作文件的路径，以及打开方式
利用<<可以向文件中写数据
操作完毕，要关闭文件

读文件

读文件与写文件步骤相似，但是读文件方式相对比较多

步骤：

1.包含头文件：#include<fstream>

2.创建流对象：ifstream ifs;

3.打开文件：ifs.open("文件路径",打开方式)；

4.读数据：四种方式读取;

5.关闭文件：ifs.close();

//读文件
#include<fstream>//包含头文件
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) {// EOF end of file（文件尾部标志）
		cout << c;
	}
	ifs.close();//关闭文件
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

读文件可以利用ifstream，或者fstream类
利用is_open函数可以判断文件是否打开成功
close关闭文件

二进制文件

以二进制的方式对文件进行操作

打开方式要指定为：ios::binary

写文件

利用流对象调用成员函数write

函数原型：ostream& write(const char * buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数。

//二进制写文件
#include<fstream>//1.头文件
class Person {
public:
	char m_Name[64];
	int m_Age;
};
void test01() {
	ofstream ofs("person.txt", ios::out | ios::binary);//2.创建流对象（2.3.可以合为一步）
	//ofs.open("person.txt", ios::out | ios::binary);//3.打开文件
	Person p = { "小灰灰",10 };//4.写文件
	ofs.write((const char*)&p, sizeof(Person));
	ofs.close();//5.关闭文件
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

文件输出流对象可以通过write函数，以二进制方式写数据。

读文件

二进制方式读文件主要利用流对象调用成员函数read

函数原型：istream& read(char * buffer,int len);

//二进制读文件
#include<fstream>//1.头文件
class Person {
public:
	char m_Name[64];
	int m_Age;
};
void test01() {
	ifstream ifs;//2.创建流对象
	ifs.open("person.txt", ios::in | ios::binary);//3.打开文件,判断是否打开成功
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	Person p;//4.读文件
	ifs.read((char *)&p, sizeof(Person));
	cout << "姓名：" << p.m_Name << "  年龄：" << p.m_Age << endl;
	ifs.close();//5.关闭文件
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

文件输入流对象可以通过read函数，以二进制方式读数据