浅学 ----- C++ 继承和多态，文件 *** 作

C++ 允许一个类继承多个类

语法：class 子类 ：继承方式 父类1,继承方式 父类2 ...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

概念：两个派生类继承同一个基类，又有某个类同时继承这两个派生类，这种继承被称为菱形继承，或者钻石继承

当菱形继承，两个父类拥有相同数据，需要加以作用域区分

利用虚继承 解决菱形继承的问题

继承之前 加上关键字 virtual 变成虚继承 解决了数据有两份的问题

vbptr：v - virtual b - base ptr - pointer 虚基类指针，指向虚基类表（vbtable）

#include
using namespace std;
class Animal
{
public:
    int m_Age;
};

//继承前加vritual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : vritual public Animal {};
class Tuo : vritual public Animal {};
Class SheepTuo : public Sheep,public Tuo {};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 100;
    st.Tuo::m_Age = 200;
    
    cout<<"st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    cout<<"st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
    cout<<"st.m_Age = " << endl;
}

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

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

利用虚继承可以解决菱形继承问题

多态分为两类

​ 静态多态：函数重载 和 运算符重载属于静态多态，复用函数名

​ 动态多态：派生类和虚函数实现运行时多态

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

​ 静态多态的函数地址早绑定 - 编译阶段确定函数地址

​ 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

#include
using namespace std;

//多态
//动物类
class Animal
{
public:
    
    //虚函数
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

//猫类
class Cat : public Animal
{
public:
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址迟绑定
void doSpeak(Animal &animal)
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat)	
}

动态多态满足条件

1、有继承关系

2、子类重写父类的虚函数

（重写时，virtual 关键字可加可不加）

动态多态使用

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

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

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

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

纯虚函数语法：vritual返回值类型 函数名 (参数列表) = 0

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

抽象类特点：

​ 无法实例化对象

​ 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include
using namespace std;

class Base
{
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类的特点：
	//无法实例化对象 
	virtual void func() = 0;	
	 
};

class Son : public Base
{
public:
	virtual void func()
	{
		cout<<"func函数调用"<func();
} 

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

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

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

虚析构和纯虚析构共性：

​ 可以解决父类指针释放子类对象

​ 都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

​ virtual ~类名(){}

纯虚析构语法：

​ virtual ~类名() = 0;

​ 类名::~类名(){}

#include
#include
using namespace std;

class Animal
{
public:
	Animal()
	{
		cout<<"Animal构造函数调用"<speak();
	//父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄露 
	delete animal;
}

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

总结：

​ 1、虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

​ 2、如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

​ 3、拥有纯虚析构函数的类也属于抽象类

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

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

C++ 中对文件 *** 作需要包含头文件

文件类型分为两种：

​ 1、文本文件 - 文件以文本的ASCII码形式存储在计算机中

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

*** 作文件的三大类：

​ 1、ofstream：写 *** 作

​ 2、ifstream：读 *** 作

​ 3、fstream：读写 *** 作

写文件步骤如下：

​ 1、包含头文件

​ #include

​ 2、创建流对象

​ ofstream ofs;

​ 3、打开文件

​ ofs.open(“文件路径”，打开方式)；

​ 4、写数据

​ ofs << “写入的数据”；

​ 5、关闭文件

​ ofs.close();

文件打开方式：

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

例如：用二进制方式写文件ios::binary | ios::out

生成的文件和源程序文件在同一目录下。

#include
#include	//头文件包含 
using namespace std;

//文本文件 写文件 
void test01()
{
	//1、包含头文件 fstream
	

	//2、创建流对象
	ofstream ofs; 
	
	//3、指定打开方式
	ofs.open("test.txt",ios::out);
	
	//4、写内容
	ofs << "hello world"<

#include
#include
#include
using namespace std;

//文本文件	读文件
void test01()
{
	//1、包含头文件
	

	//2、创建流对象
	ifstream ifs;
	//3、打开文件 并且判断是否打开成功
	ifs.open("test.txt",ios::in);
	
	if(!ifs.is_open())
	{
		cout << "文件打开失败"<> buf)
	{
		cout << buf <

#include
#include 
using namespace std;

//二进制文件  写文件
class Person
{
public:
	char m_Name[64];	//姓名
	int m_Age;			//年龄 
}; 

void test01()
{
	//1、包含头文件
	//2、创建流对象
	ofstream ofs;
	//3、打开文件
	ofs.open("person.txt",ios::out | ios::binary);
	//4、写文件
	Person p = {"法外狂徒",18};
	ofs.write((const char *)&p,sizeof(Person));
	//5、 关闭文件	
	ofs.close();
} 

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

#include
#include 
using namespace std;

//二进制文件  写文件
class Person
{
public:
	char m_Name[64];	//姓名
	int m_Age;			//年龄 
}; 

void test01()
{
	//1、包含头文件
	//2、创建流对象
	ifstream ifs;
	//3、打开文件  判断文件是否打开成功 
	ifs.open("person.txt",ios::in | ios::binary);
	if(!ifs.is_open())
	{
		cout << "文件打开失败"<