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

• 继承
• • 继承方式
  • 继承中的对象类型
  • 继承中构造函数和析构顺序
  • 继承同名成员处理方式
  • 继承同名静态成员处理方式
  • 多继承语法
  • 菱形继承
• 多态
• • 纯虚函数和抽象类
  • 虚析构和纯虚析构
• 文件操作
• • 文本文件
  • • 写文件
    • 读文件
  • 二进制文件
  • • 写文件
    • 读文件

继承语法：class 子类 : 继承方式 父类

继承方式一共有三种：

公共继承、保护继承、 私有继承

三种继承方式都不继承父类的私有成员

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EiOv0JFZ-1651912967832)(https://raw.githubusercontent.com/Ckingt-k/photos/main/image-20220506145846458.png)]

公共继承：不改变父类中的成员属性，在父类中成员属性是公共的还是公共的。

保户继承：将父类中的成员属性变为保护的

私有继承：将父类中的成员属性变为私有的

父类中的私有成员会继承到子类中，只是被隐藏了，不可访问。

（父类中所有非静态成员属性都会被子类继承下去）

#inlcude
using namespace std;
class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;	//私有成员只是被隐藏了，但是还是会继承下去
};

//公共继承
class Son : public Base
{
public:
	int m_D;    
};

void test01()
{
    cout<< "sizeof Son = " << sizeof(Son) << endl;
}

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

该程序的输出结果为16，说明子类也继承了父类的私有成员，只是被隐藏起来了，不可访问。

也可以使用工具查看

利用开发人员命令提示工具查看对象模型

跳转盘符

跳转文件路径 cd 具体路径下

查看命名

cl /dl reportSingleClassLayout类名 文件名

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造函数和析构顺序是谁先谁后？

#include
using namespace std;

//继承中的构造和析构顺序
class Base
{
public:
    Base()
    {
        cout << "Base构造函数!" << endl;
    }
    ~Base()
    {
        cout << "Base析构函数！" < 
继承中的构造和析构顺序如下：
 
先构造父类，再构造子类，析构的顺序与构造的顺序相反。
 
继承同名成员处理方式 
问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？
 
​ 访问子类同名成员 直接访问即可
 
​ 访问父类同名成员 需要加作用域
 
#include
using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
     	m_A=100; 
    }
    
    void func()
    {
        cout << "Base - func() 调用" << endl;
    }
    
    int m_A; 
};

class Son:public Base
{
public:
    Son()
    {
        m_A=200;
    }
    
    void func()
    {
        cout << "Son - func() 调用" << endl;
    }
    
    int m_A;
};

//同名成员属性（变量）处理
void test01()
{
    Son S;
    cout << "Son  下 m_A = " << s.m_A << ednl;
    //通过子类对象  访问到父类中同名成员，需要加作用域
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
}

//同名成员函数处理
void test02()
{
	Son s;
    s.func();
    s.Base::func();
}

int main()
{
    //test01();
    test02();
    system(pause);
    return 0;
}
 
子类对象可以直接访问到子类中同名成员
 
如果子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数
 
如果想访问到父类中被隐藏的同名成员函数，需要加作用域
 
继承同名静态成员处理方式 
问题：继承中同名的静态成员在子类对象上如何进行访问？
 
静态成员和非静态成员出现同名，处理方式一致
 
​ 访问子类同名成员 直接访问即可
 
​ 访问父类同名成员 需要加作用域
 
#include
using namespace std;
class Base
{
 public:
    static int m_A;
    
   	static void func()
    {
        cout<<"Base - static void func()"< 
多继承语法 
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"< 
读文件 
读文件与写文件步骤相似，但是读取方式相对于比较多
 
读文件步骤如下：
 
​ 1、包含头文件
 
​ #include
 
​ 2、创建流对象
 
​ ifstream ifs;
 
​ 3、打开文件并判断是否打开成功
 
​ ifs.open(“文件路径”，打开方式)
 
​ 4、读数据
 
​ 四种方式读取
 
​ 5、关闭文件
 
​ ifs.close();
 
#include
#include
#include
using namespace std;

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

	//2、创建流对象
	ifstream ifs;
	//3、打开文件 并且判断是否打开成功
	ifs.open("test.txt",ios::in);
	
	if(!ifs.is_open())
	{
		cout << "文件打开失败"< 
总结：
 
​ 读文件可以利用 ifstream，或者fstream类
 
​ 利用is_open函数可以判断文件是否打开成功
 
​ close 关闭文件
 
二进制文件 
以二进制的方式对文件进行读写操作
 
打开方式指定为 ios::binary
 
写文件 
二进制方式写文件主要利用流对象调用成员函数write
 
函数原型：ostream& write(const char * buffer,int len);
 
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
 
#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;
}
 
总结：
 
​ 文件输出流对象 可以通过write函数，以二进制方式写数据。
 
读文件 
二进制方式读文件主要利用流对象调用成员函数read
 
函数原型：istream& read(char *buffer,int len);
 
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
 
#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 << "文件打开失败"< 
文件输入流对象 可以通过read函数，以二进制方式读数据