c++核心编程继承和多态、文件简单读写

4.6 继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ePVg2IyK-1610002143050)(assets/1544861202252.png)]

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

4.6.1 继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同

接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

普通实现：

//Java页面
class Java
{public:void header(){cout << "首页、公开课、登录、注册...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;}void left(){cout << "Java,Python,C++...(公共分类列表)" << endl;}void content(){cout << "JAVA学科视频" << endl;}
};
//Python页面
class Python
{public:void header(){cout << "首页、公开课、登录、注册...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;}void left(){cout << "Java,Python,C++...(公共分类列表)" << endl;}void content(){cout << "Python学科视频" << endl;}
};
//C++页面
class CPP
{public:void header(){cout << "首页、公开课、登录、注册...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;}void left(){cout << "Java,Python,C++...(公共分类列表)" << endl;}void content(){cout << "C++学科视频" << endl;}
};void test01()
{//Java页面cout << "Java下载视频页面如下： " << endl;Java ja;ja.header();ja.footer();ja.left();ja.content();cout << "--------------------" << endl;//Python页面cout << "Python下载视频页面如下： " << endl;Python py;py.header();py.footer();py.left();py.content();cout << "--------------------" << endl;//C++页面cout << "C++下载视频页面如下： " << endl;CPP cp;cp.header();cp.footer();cp.left();cp.content();}int main() {test01();system("pause");return 0;
}

继承实现：

//公共页面
class BasePage
{public:void header(){cout << "首页、公开课、登录、注册...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;}void left(){cout << "Java,Python,C++...(公共分类列表)" << endl;}};//Java页面
class Java : public BasePage
{public:void content(){cout << "JAVA学科视频" << endl;}
};
//Python页面
class Python : public BasePage
{public:void content(){cout << "Python学科视频" << endl;}
};
//C++页面
class CPP : public BasePage
{public:void content(){cout << "C++学科视频" << endl;}
};void test01()
{//Java页面cout << "Java下载视频页面如下： " << endl;Java ja;ja.header();ja.footer();ja.left();ja.content();cout << "--------------------" << endl;//Python页面cout << "Python下载视频页面如下： " << endl;Python py;py.header();py.footer();py.left();py.content();cout << "--------------------" << endl;//C++页面cout << "C++下载视频页面如下： " << endl;CPP cp;cp.header();cp.footer();cp.left();cp.content();}int main() {test01();system("pause");return 0;
}

总结：

继承的好处：可以减少重复的代码

class A : public B;

A 类称为子类或派生类

B 类称为父类或基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

4.6.2 继承方式

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

继承方式一共有三种：

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y8QqK2tK-1610002198463)(assets/clip_image002.png)]

示例：

class Base1
{public: int m_A;
protected:int m_B;
private:int m_C;
};//公共继承
class Son1 :public Base1
{public:void func(){m_A; //可访问 public权限m_B; //可访问 protected权限//m_C; //不可访问}
};void myClass()
{Son1 s1;s1.m_A; //其他类只能访问到公共权限
}//保护继承
class Base2
{public:int m_A;
protected:int m_B;
private:int m_C;
};
class Son2:protected Base2
{public:void func(){m_A; //可访问 protected权限m_B; //可访问 protected权限//m_C; //不可访问}
};
void myClass2()
{Son2 s;//s.m_A; //不可访问
}//私有继承
class Base3
{public:int m_A;
protected:int m_B;
private:int m_C;
};
class Son3:private Base3
{public:void func(){m_A; //可访问 private权限m_B; //可访问 private权限//m_C; //不可访问}
};
class GrandSon3 :public Son3
{public:void func(){//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到//m_A;//m_B;//m_C;}
};

4.6.3 继承中的对象模型

**问题：**从父类继承过来的成员，哪些属于子类对象中？

示例：

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;
}

利用工具查看：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-94tSSrIV-1610002198466)(assets/1545881904150.png)]

打开工具窗口后，定位到当前CPP文件的盘符

然后输入： cl /d1 reportSingleClassLayout查看的类名所属文件名

效果如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-isVgCjB2-1610002198480)(assets/1545882158050.png)]

结论：父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

4.6.4 继承中构造和析构顺序

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

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

示例：

class Base
{public:Base(){cout << "Base构造函数!" << endl;}~Base(){cout << "Base析构函数!" << endl;}
};class Son : public Base
{public:Son(){cout << "Son构造函数!" << endl;}~Son(){cout << "Son析构函数!" << endl;}};void test01()
{//继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反Son s;
}int main() {test01();system("pause");return 0;
}

总结：继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

4.6.5 继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

示例：

class Base {public:Base(){m_A = 100;}void func(){cout << "Base - func()调用" << endl;}void func(int a){cout << "Base - func(int a)调用" << endl;}public:int m_A;
};class Son : public Base {public:Son(){m_A = 200;}//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域void func(){cout << "Son - func()调用" << endl;}
public:int m_A;
};void test01()
{Son s;cout << "Son下的m_A = " << s.m_A << endl;cout << "Base下的m_A = " << s.Base::m_A << endl;s.func();s.Base::func();s.Base::func(10);}
int main() {test01();system("pause");return EXIT_SUCCESS;
}

总结：

子类对象可以直接访问到子类中同名成员
子类对象加作用域可以访问到父类同名成员
当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

4.6.6 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

示例：

class Base {public:static void func(){cout << "Base - static void func()" << endl;}static void func(int a){cout << "Base - static void func(int a)" << endl;}static int m_A;
};int Base::m_A = 100;class Son : public Base {public:static void func(){cout << "Son - static void func()" << endl;}static int m_A;
};int Son::m_A = 200;//同名成员属性
void test01()
{//通过对象访问cout << "通过对象访问： " << endl;Son s;cout << "Son  下 m_A = " << s.m_A << endl;cout << "Base 下 m_A = " << s.Base::m_A << endl;//通过类名访问cout << "通过类名访问： " << endl;cout << "Son  下 m_A = " << Son::m_A << endl;cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}//同名成员函数
void test02()
{//通过对象访问cout << "通过对象访问： " << endl;Son s;s.func();s.Base::func();cout << "通过类名访问： " << endl;Son::func();Son::Base::func();//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问Son::Base::func(100);
}
int main() {//test01();test02();system("pause");return 0;
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通过类名）

4.6.7 多继承语法

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

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

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

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

示例：

class Base1 {public:Base1(){m_A = 100;}
public:int m_A;
};class Base2 {public:Base2(){m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确}
public:int m_A;
};//语法：class 子类：继承方式 父类1 ，继承方式 父类2
class Son : public Base2, public Base1
{public:Son(){m_C = 300;m_D = 400;}
public:int m_C;int m_D;
};//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{Son s;cout << "sizeof Son = " << sizeof(s) << endl;cout << s.Base1::m_A << endl;cout << s.Base2::m_A << endl;
}int main() {test01();system("pause");return 0;
}

总结：多继承中如果父类中出现了同名情况，子类使用时候要加作用域

4.6.8 菱形继承

菱形继承概念：

两个派生类继承同一个基类

又有某个类同时继承者两个派生类

这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

菱形继承问题：

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

#include<iostream>
#include<string>
using namespace std;//#### 4.6.8 菱形继承//** 菱形继承概念：**
//
// 两个派生类继承同一个基类
// 又有某个类同时继承者两个派生类
// 这种继承被称为菱形继承，或者钻石继承
//
//** 菱形继承问题：**
//
//1.羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
//
//2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。//动物类
class Animal
{public:int age;
};//羊类
class sheep :virtual public Animal
{public://int age;
};//驼类
class tuo :virtual public Animal
{public://int age;
};class sheeptuo : public sheep,  public tuo
{};
void test50()
{sheeptuo p;p.sheep::age = 18;p.tuo::age = 28;//当出现菱形继承时候，有两个父类拥有相同数据，需要加以作用域区分cout << "p.sheep::age=" << p.sheep::age << endl;cout << "p.sheep::age=" << p.tuo::age << endl;//这份数据数据我们知道只要有一份就可以，菱形继承导致数据有两份，导致资源浪费//利用虚继承可以解决菱形继承问题//继承之前，加上关键字virtual 变为虚继承//Animal 类称为 虚基类cout << "p.age=" << p.age << endl;//虚继承后就只有一份数据}int main()
{test50();system("pause");return 0;
}

总结：

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

4.7 多态

4.7.1 多态的基本概念

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

多态分为两类

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

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

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

下面通过案例进行讲解多态

#include<iostream>
#include<string>
using namespace std;//### 4.7  多态
//
//#### 4.7.1 多态的基本概念
//** 多态是C++面向对象三大特性之一**
//多态分为两类
//
//* 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
//* 动态多态 : 派生类和虚函数实现运行时多态
//
//静态多态和动态多态区别：
//
//* 静态多态的函数地址早绑定 - 编译阶段确定函数地址
//* 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
//下面通过案例进行讲解多态//多态
//动物
class Animal1
{public://函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。virtual void speak()//虚函数{cout << "动物在说话" << endl;}
};//猫类
class cat :public Animal1
{public:void speak(){cout << "小猫在说话" << endl;}
};
//狗类
class dog :public Animal1
{public:void speak(){cout << "小狗在说话" << endl;}
};//执行说话的函数//地址早绑定   在编译阶段确定了函数地址//如果想要猫说话  那么这个地址就不能提前绑定   ，需要在运行阶段绑定，地址晚绑定
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编//动态多态 满足条件
//1.得有继承关系
//2.子类要重写父类虚函数     重写（函数返回值、函数名称、 参数列表完全相同）//动态多态使用
//父类的指针或引用指向子类对象
void dospeak(Animal1 &animal)  //Animal1 的引用 = cat；
{animal.speak();
}void test51()
{cat cat1;dospeak(cat1);dog dog1;dospeak(dog1);
}int main()
{test51();system("pause");return 0;
}

总结：

多态满足条件

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

多态使用条件

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

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

多态原理

4.7.2 多态案例一-计算器类

案例描述：

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

多态的优点：

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

#include<iostream>
#include<string>
using namespace std;//案例描述：
//
//分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
//
//多态的优点：
//
//* 代码组织结构清晰
//* 可读性强
//* 利于前期和后期的扩展以及维护
class calculator
{public:int getanwser1(string oper){if (oper == "+"){return m_a + m_b;}else if(oper == "-"){return m_a - m_b;}else if(oper == "*"){return m_a * m_b;}else if (oper == "/"){return m_a / m_b;}}//如果想扩展新的计算器功能，就需要修改源码int getanwser(string oper)//真正开发中，提倡一种原则---开闭原则//对扩展进行开放，对修改进行关闭int m_a; //操作数1int m_b; //操作数2
};void test53()
{//创建计算器对象calculator p;p.m_a = 10;p.m_b = 10;cout << p.getanwser1("+") << endl;cout << p.getanwser1("-") << endl;cout << p.getanwser1("*") << endl;cout << p.getanwser1("/") << endl;}//利用多态实现计算器
//好处 ：
//1.组织结构清晰
//2.可读性强
//3.对于后期和前期扩展及维护性能强
//总结：C++开发提倡利用多态设计程序架构，因为多态优点很多
//实现计算器抽象类
class Acalculator
{public:virtual int getanwser(){return 0;}int a;int b;};
//加法计算器
class add : public Acalculator
{public:int getanwser(){return a + b;}
};
//减法计算器
class jian :public Acalculator
{int getanwser(){return a - b;}
};void test54()
{//多态使用条件//父类指针或者引用指向子类对象Acalculator* p = new add;p->a = 10; p->b = 10;cout << p->getanwser() << endl;//用完后记得销毁delete p;//减法运算p = new jian;cout << p->getanwser() << endl;//用完后记得销毁delete p;}
int main()
{test53();test54();system("pause");return 0;
}

4.7.3 纯虚函数和抽象类

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

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

纯虚函数语法：virtual 返回值类型函数名（参数列表）= 0 ;

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

抽象类特点：

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

示例：

#include<iostream>
#include<string>
using namespace std;//纯虚函数和抽象类
class base
{//纯虚函数//类中只要有一个纯虚函数就称为抽象类//1.抽象类无法实例化对象//2.子类必须重写父类中的纯虚函数，否则也属于抽象类
public:virtual void func() = 0;
};class son:public base
{public:void func(){cout << "子类调用" << endl;}
};
void test55()
{//base b;//抽象类无法实例化对象   ----栈区//new base;//抽象类无法实例化对象   ---堆区//子类必须重写父类中的纯虚函数，否则也属于抽象类,否则无法实例化对象base* a = new son;a->func();}int main4601()
{test55();system("pause");return 0;
}

4.7.4 多态案例二-制作饮品

案例描述：

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

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

#include<iostream>
#include<string>
using namespace std;//#### 4.7.4 多态案例二-制作饮品
//制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料
//利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶//制作饮品抽象类
class AbstractMaking
{public:virtual void zhushui() = 0;//煮水virtual void chongpao() = 0;//冲泡virtual void daorubeizhong() = 0;//倒入杯中virtual void jiarufuliao() = 0;//加辅料//制作流程规定void dowork(){zhushui();chongpao();daorubeizhong();jiarufuliao();}};
//制作咖啡
class kafei :public AbstractMaking
{public:virtual void zhushui(){cout << "煮农夫山泉" << endl;}virtual void chongpao(){cout << "冲泡咖啡" << endl;}virtual void daorubeizhong(){cout << "倒入杯中" << endl;}virtual void jiarufuliao(){cout << "加糖加牛奶" << endl;}
};
//制作茶水
class chaye :public AbstractMaking
{public:virtual void zhushui(){cout << "煮自来水" << endl;}virtual void chongpao(){cout << "冲泡茶叶" << endl;}virtual void daorubeizhong(){cout << "倒入杯中" << endl;}virtual void jiarufuliao(){cout << "加柠檬" << endl;}
};
//具体实现函数
void test56(AbstractMaking* dringk)
{dringk->dowork();delete dringk;
}//测试函数
void test57()
{test56(new kafei);//制作咖啡cout << "--------------" << endl;test56(new chaye);//制作茶叶
}
int main()
{test57();system("pause");return 0;
}

4.7.5 虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

示例：

#include<iostream>
#include<string>
using namespace std;//多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
//解决方式：将父类中的析构函数改为** 虚析构** 或者** 纯虚析构**//虚析构和纯虚析构共性：
//
//* 可以解决父类指针释放子类对象
//* 都需要有具体的函数实现
//
//虚析构和纯虚析构区别：
//
//* 如果是纯虚析构，该类属于抽象类，无法实例化对象
//虚析构语法：
//
//`virtual ~类名() {}`
//
//纯虚析构语法：
//
//` virtual ~类名() = 0; `
//
//`类名::~类名() {}`
class Animal3
{public:Animal3(){cout << "Animal3构造函数调用" << endl;}//1.虚析构函数，可以解决父类指针释放子类对象不干净的问题/*virtual~Animal3(){cout << "Animal3虚析构函数调用" << endl;}*///2.纯虚析构函数，可以解决父类指针释放子类对象不干净的问题virtual~Animal3() = 0;//纯虚析构需要有声明 和 实现  //如果是纯虚析构，该类属于抽象类，无法实例化对象//纯虚函数virtual void speak() = 0;
};Animal3::~Animal3()
{cout << "Animal3纯虚析构函数调用" << endl;
}class cat11 : public Animal3
{public:virtual void speak(){cout << *name <<"小猫在说话" << endl;}cat11(string name){this->name = new string(name);cout << "cat构造函数调用" << endl;}~cat11(){if (name != NULL){cout << "cat析构函数调用" << endl;delete name;name = NULL;}}string* name;
};void test56()
{Animal3 * p = new cat11("tom");p->speak();//父类指针在析构时候不会调用子类中析构函数 导致子类中如果有堆区属性，会出现内存泄漏情况delete p;
}
int main()
{test56();system("pause");return 0;
}

总结：

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

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

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

4.7.6 多态案例三-电脑组装

案例描述：

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

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

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

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

#include<iostream>
#include<string>
using namespace std;
//#### 4.7.6 多态案例三-电脑组装
//**案例描述：**
//
//电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
//
//将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
//
//创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
//
//测试时组装三台不同的电脑进行工作//抽象cpu类
class CPU
{public://抽象计算函数virtual void caculate() = 0;
};//抽线显卡类
class xianka
{public://抽象现实函数virtual void display() = 0;};//抽象内存条类
class neicuntiao
{public://抽象存储函数virtual void storage() = 0;
};//电脑类
class cumpter
{public://构造函数中传入三个零件的指针cumpter(CPU* cpu, xianka* xianka, neicuntiao* neicuntiao){m_cpu = cpu;m_xianka = xianka;m_neicuntiao = neicuntiao;}//提供一个工作的函数，调用每个零件工作的借口void work(){m_cpu->caculate();m_xianka->display();m_neicuntiao->storage();}~cumpter(){if (m_cpu != NULL){delete m_cpu; m_cpu = NULL;}if (m_xianka != NULL){delete m_xianka;m_xianka = NULL;}if (m_neicuntiao != NULL){delete m_neicuntiao;m_neicuntiao = NULL;}}
private:CPU* m_cpu;xianka* m_xianka;neicuntiao* m_neicuntiao;
};//Intercpu   零件厂商
class InterCpu : public CPU
{public://重写计算函数virtual void caculate(){cout << "Inter cpu 开始计算了" << endl;}
};
//Inter显卡    零件厂商
class Interxianka : public xianka
{public://重写显示函数virtual void display(){cout << "Inter 显卡 开始显示了" << endl;}
};
//Inter 内存条   零件厂商
class Interneicuntiao : public neicuntiao
{public://重写存储函数virtual void storage(){cout << "Inter 显卡 开始显示了" << endl;}
};//Lenovocpu   零件厂商
class LenovoCpu : public CPU
{public://重写计算函数virtual void caculate(){cout << "Lenovo cpu 开始计算了" << endl;}
};
//Lenovo显卡    零件厂商
class Lenovoxianka : public xianka
{public://重写显示函数virtual void display(){cout << "Lenovo 显卡 开始显示了" << endl;}
};
//Lenovo 内存条   零件厂商
class Lenovoneicuntiao : public neicuntiao
{public://重写存储函数virtual void storage(){cout << "Lenovo 显卡 开始显示了" << endl;}
};void test58()
{//第一台电脑零件CPU* cpu = new InterCpu;xianka* xianka = new Interxianka;neicuntiao* neicuntiao = new Interneicuntiao;//第一台电脑工作cout << "第一台电脑开始工作：" << endl;cumpter* p1 = new cumpter(cpu, xianka, neicuntiao);p1->work();delete p1;cout << "-----------------------" << endl;//第二台电脑工作cout << "第二台电脑开始工作：" << endl;cumpter* p2 = new cumpter(new LenovoCpu,new  Lenovoxianka, new  Lenovoneicuntiao);p2->work();delete p2;cout << "-----------------------" << endl;//第三台电脑工作cout << "第三台电脑开始工作：" << endl;cumpter* p3 = new cumpter(new InterCpu, new  Lenovoxianka, new  Lenovoneicuntiao);p3->work();delete p3;}int main()
{test58();system("pause");return 0;
}

5 文件操作

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

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

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

文件类型分为两种：

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

操作文件的三大类:

ofstream：写操作
ifstream：读操作
fstream ：读写操作

5.1文本文件

5.1.1写文件

写文件步骤如下：

包含头文件

#include <fstream>
创建流对象

ofstream ofs;
打开文件

ofs.open(“文件路径”,打开方式);
写数据

ofs << “写入的数据”;
关闭文件

ofs.close();
文件打开方式：

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式

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

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

#include<iostream>
#include<string>
#include<fstream>
using namespace std;//C++中对文件操作需要包含头文件 <fstream>
//文件类型分为两种：
//1. * *文本文件 * *-文件以文本的 * *ASCII码 * *形式存储在计算机中
//2. * *二进制文件 * *-文件以文本的 * *二进制 * *形式存储在计算机中，用户一般不能直接读懂它们
//
//操作文件的三大类:
//1. ofstream：写操作
//2. ifstream： 读操作
//3. fstream ： 读写操作//### 5.1文本文件
//
//#### 5.1.1写文件
//
//写文件步骤如下：
//
//1. 包含头文件
//#include <fstream>
//
//2. 创建流对象
//ofstream ofs;
//
//3. 打开文件
//ofs.open("文件路径", 打开方式);
//
//4. 写数据
//ofs << "写入的数据";
//
//5. 关闭文件
//ofs.close()文件打开方式：//| 打开方式 | 解释                       |
//| ---------- - | -------------------------- |
//| ios::in | 为读文件而打开文件         |
//| ios::out | 为写文件而打开文件         |
//| ios::ate | 初始位置：文件尾           |
//| ios::app | 追加方式写文件             |
//| ios::trunc | 如果文件存在先删除，再创建 |
//| ios::binary | 二进制方式 |//** 注意：** 文件打开方式可以配合使用，利用 | 操作符
//* *例如： * *用二进制方式写文件 ios::binary | ios::outvoid test599()
{//1.包含头文件 fstream//2.创建流对象ofstream ofs;//3.指定打开方式//ofs.open("test.txt", ios::out);  //不指定目录，直接写文件名称"test.txt"，就会创建在与脚本文件同级别路径下//4.写内容ofs << "张三Å李四" << "男人" << endl;ofs << "张三Å李四" << "男人" << endl;ofs << "张三Å李四" << "男人" << endl;//5.关闭文件ofs.close();
}
int main()
{test599();system("pause");return 0;
}

总结：

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

5.1.2读文件

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

读文件步骤如下：

包含头文件

#include <fstream>
创建流对象

ifstream ifs;
打开文件并判断文件是否打开成功

ifs.open(“文件路径”,打开方式);
读数据

四种方式读取
关闭文件

ifs.close();

示例：

#include<iostream>
#include<string>
#include<fstream>
using namespace std;//读文件void test68()
{//1.包含头文件//2.创建流对象ifstream ifs;//3.打开文件，并判断是否打开成功ifs.open("test.txt",ios::in);if (!ifs.is_open())//ifs.is_open()返回bool类型，成功打开返回真，失败返回0{cout << "文件打开失败" << endl;return;}//4.读数据//第一种//char buf[1024] = { 0 };//while (ifs >> buf)//从文件读入，直到读不到数据返回0//   {//     cout << buf << endl;//  }//第二种//char buf[1024] = { 0 };//while (ifs.getline(buf,sizeof(buf)))//getline（）获取//{//  cout << buf << endl;//}//第三种//string  buf;//while (getline(ifs, buf))//getline（）获取//{//   cout << buf << endl;//}//第四种  --不建议用（把文件中所有数据一个一个字符读出来）char c;while ((c = ifs.get()) != EOF )  //EOF  代表 end of file  文件尾 {cout << c;}//5.关闭文件ifs.close();
}int main()
{test68();system("pause");return 0;
}

总结：

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

5.2 二进制文件

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

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

5.2.1 写文件

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

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

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

示例：

#include<iostream>
#include<string>
#include<fstream>
using namespace std;class Person99
{public:char name[64];  //姓名 int age;//年龄
};
void test699()
{//1.包含头文件 fstream//2.创建流对象//ofstream ofs1;//3.指定打开方式//ofs.open("Person99txt", ios::out | ios::binary );  //不指定目录，直接写文件名称"test.txt"，就会创建在与脚本文件同级别路径下//也可以直接合并23ofstream ofs("Person99.txt", ios::out | ios::binary);//4.写内容Person99 p = { "张三", 18 };ofs.write((const char*)&p,sizeof(Person99));//5.关闭文件ofs.close();
}int main()
{test699();system("pause");return 0;
}

总结：

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

#include<iostream>
#include<string>
#include<fstream>
using namespace std;//读文件
class Person99
{public:char name[64];  //姓名 int age;//年龄
};void test689()
{//1.包含头文件//2.创建流对象ifstream ifs;//3.打开文件，并判断是否打开成功ifs.open("Person99.txt", ios::in | ios::binary);if (!ifs.is_open())//ifs.is_open()返回bool类型，成功打开返回真，失败返回0{cout << "文件打开失败" << endl;return;}//4.读数据Person99 p;ifs.read((char* )&p, sizeof(Person99));cout << "xingming" << p.name << "nianling" << p.age << endl;//5.关闭文件ifs.close();
}int main()
{test689();system("pause");return 0;
}
//总结：//*文件输出流对象 可以通过write函数，以二进制方式写数据