从0到1入门C++编程——06 类和对象之多态、文件操作

文章目录

• 多态
• • 1.多态基本概念
  • 2.多态案例——计算器
  • 3.纯虚函数和抽象类
  • 4.多态案例——制作饮品
  • 5.虚析构和纯虚析构
  • 6.多态案例——电脑组装
• 文件操作
• • 1.文本文件–写文件
  • 2.文本文件–读文件
  • 3.二进制文件–写文件
  • 4.二进制文件–读文件

多态

1.多态基本概念

多态是C++面向对象的三大特性之一。
多态分为静态多态和动态多态，静态多态包括函数重载和运算符重载等，动态多态是指派生类和虚函数实现运行时多态。
静态多态和动态多态的区别：静态多态的函数地址是早绑定的，其在编译阶段就已经确定了函数的地址；动态多态的函数地址是晚绑定的，其在运行阶段才确定函数地址。
函数重写：父类和子类中函数返回值类型、函数名、参数列表完全相同。
动态多态需要满足的条件：有继承关系；子类重写父类的虚函数。
动态多态使用时，父类的指针或引用指向子类的对象。
子类重写父类虚函数，虚函数表指针会将父类的函数表指针替换成本类的；如果不重写父类虚函数，子类将继承父类函数表指针，其指向的函数地址仍是父类的。
多态的简单代码示例如下。

#include using namespace std;class Animal{public:virtual void speak() //通过虚函数实现地址晚绑定，vfptr是一个虚函数表指针{cout<<"Animal speak()"<<endl;}};class Cat : public Animal{public:void speak()//子类重写父类虚函数，虚函数表指针会将父类的替换成本类的{cout<<"Cat speak()"<<endl;}};class Dog : public Animal{public:void speak(){cout<<"Dog speak()"<<endl;}};void dospeak(Animal &animal)//父类的引用可以指向子类对象{animal.speak();}void fun(){Cat cat;cat.speak();dospeak(cat);//传哪个对象就执行这个对象所在类的函数Dog dog;dospeak(dog);}int main(){fun();system("pause");return 0;}

上面代码的执行结果如下图所示。

2.多态案例——计算器

多态的优点：代码组织结构清晰；可读性强；利于前期和后期的扩展及维护。
利用普通方法实现计算器的代码如下。

#include #include using namespace std;class Calculator{public:int getResult(string str){if(str == "+")return num1+num2;else if(str == "-")return num1-num2;else if(str == "*")return num1*num2;else if(str == "/"){if(num2 != 0)return num1/num2;elsecout<<"除数不能为0！"<<endl;}}int num1;int num2;};void fun(){Calculator c;c.num1 = 10;c.num2 = 20;cout<<c.num1<<"+"<<c.num2<<"="<<c.getResult("+")<<endl;cout<<c.num1<<"-"<<c.num2<<"="<<c.getResult("-")<<endl;cout<<c.num1<<"*"<<c.num2<<"="<<c.getResult("*")<<endl;cout<<c.num1<<"/"<<c.num2<<"="<<c.getResult("/")<<endl;}int main(){fun();system("pause");return 0;}

利用多态方法实现计算器的代码如下。

#include #include using namespace std;//计算器的抽象类class AbstractCalculator{public:virtual int getResult(){return 0;}int num1;int num2;};//加法计算器类class AddCalculator : public AbstractCalculator{public:int getResult(){return num1+num2;}};//减法计算器类class SubCalculator : public AbstractCalculator{public:int getResult(){return num1-num2;}};//乘法计算器类class MultiCalculator : public AbstractCalculator{public:int getResult(){return num1*num2;}};//除法计算器类class DivCalculator : public AbstractCalculator{public:int getResult(){return num1/num2;}};void fun(){//指针方式AbstractCalculator *c = new AddCalculator;c->num1 = 10;c->num2 = 20;cout<<c->num1<<"+"<<c->num2<<"="<<c->getResult()<<endl;delete c;c = new SubCalculator;c->num1 = 10;c->num2 = 20;cout<<c->num1<<"-"<<c->num2<<"="<<c->getResult()<<endl;delete c;c = new MultiCalculator;c->num1 = 10;c->num2 = 20;cout<<c->num1<<"*"<<c->num2<<"="<<c->getResult()<<endl;delete c;c = new DivCalculator;c->num1 = 10;c->num2 = 20;cout<<c->num1<<"/"<<c->num2<<"="<<c->getResult()<<endl;delete c;//引用方式AddCalculator add;AbstractCalculator &a = add;add.num1 = 10;add.num2 = 20;cout<<add.num1<<"*"<<add.num2<<"="<<add.getResult()<<endl;}int main(){fun();system("pause");return 0;}

上面代码的运行结果如下图所示。

利用多态方法的代码量相比于普通代码增多了，但是代码组织结构更加清晰，可读性也更强，利于扩展和维护。

3.纯虚函数和抽象类

在多态中，通常父类的虚函数实现是无意义的，调用的一般是子类重写后的函数。因此可以将父类的虚函数替换为纯虚函数。
纯虚函数的语法：virtual 返回值类型 函数名 (参数列表) = 0；
当类中有了纯虚函数，类就被称为抽象类。
抽象类的特点是：无法实例化对象，栈区和堆区都是不可以的；子类必须重写父类中的纯虚函数，否则其也属于抽象类。
纯虚函数和抽象类的例子如下。

#include #include using namespace std;class Parent {public:virtual void fun() = 0;//纯虚函数//Parent类就是抽象类，无法实例化对象};class Son1 : public Parent{public:void fun()//重写父类的纯虚函数{cout<<"Son1类的fun()调用！"<<endl;}};class Son2 : public Parent{public:void fun()//重写父类的纯虚函数{cout<<"Son2类的fun()调用！"<<endl;}};int main(){Parent *p1 = new Son1; //创建对象p1->fun(); //创建的对象不同，访问的函数也不同delete p1;Parent *p2 = new Son2;p2->fun();delete p2;system("pause");return 0;}

程序的运行结果如下图所示。

多态的目的就是让函数的接口更加通用化。

4.多态案例——制作饮品

制作饮品的流程：煮水、冲泡、倒入杯中、加入辅料。
利用多态技术实现制作饮品，提供抽象类制作饮品基类，提供子类制作咖啡和茶。
该案例的代码实现如下。

#include #include using namespace std;class AbstractDrinking //抽象类{public:virtual void Boil() = 0;//1煮水virtual void Brew() = 0;//2冲泡virtual void PourInCup() = 0;//3倒入杯中virtual void PutOthers() = 0;//4加入辅料void makeDrink(){Boil();Brew();PourInCup();PutOthers();}};class Tea : public AbstractDrinking{public:Tea(){cout<<"制作茶的步骤:"<<endl;}//依次重写父类中的纯虚函数void Boil(){cout<<"1.煮水"<<endl;}void Brew(){cout<<"2.冲泡茶叶"<<endl;}void PourInCup(){cout<<"3.倒入茶杯"<<endl;}void PutOthers(){cout<<"4.加入枸杞和桂圆"<<endl;}};class Coffee : public AbstractDrinking{public:Coffee(){cout<<"制作咖啡的步骤:"<<endl;}//依次重写父类中的纯虚函数void Boil(){cout<<"1.煮水"<<endl;}void Brew(){cout<<"2.冲泡咖啡"<<endl;}void PourInCup(){cout<<"3.倒入咖啡杯中"<<endl;}void PutOthers(){cout<<"4.加入糖和牛奶"<<endl;}};void fun(AbstractDrinking *p){p->makeDrink();deletep;}int main(){fun(new Tea);cout<<"----------------------"<<endl;fun(new Coffee);system("pause");return 0;}

程序的运行结果如下图所示。

5.虚析构和纯虚析构

多态在使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类中的析构代码。因此，要将父类中的析构函数改为虚析构或者纯虚析构。
虚析构和纯虚析构的共性：可以解决父类中指针释放子类对象问题；都需要具体的函数实现。
如果子类中没有堆区数据，可以不写虚析构或者纯虚析构。
如果类中是纯虚析构，该类是抽象类，无法实例化对象。
虚析构的语法：virtual ~类名(){}
纯虚析构的语法：virtual ~类名()=0；类名:: ~类名(){}
虚析构代码的代码实现例子如下。

#include #include using namespace std;class Animal{public:Animal(){cout<<"Animal类构造函数"<<endl;}virtual ~Animal()//在父类中使用虚析构，解决子类中堆区内存释放问题{cout<<"Animal类析构函数"<<endl;}virtual void speak() = 0;//纯虚函数};class Cat : public Animal{public:Cat(string catName){cout<<"Cat类构造函数"<<endl;name = new string(catName);}void speak(){cout<<*name<<" is speaking."<<endl;}~Cat() //析构函数中释放堆区内存{cout<<"Cat类析构函数"<<endl;if(name != NULL){delete name;name = NULL;}}string *name;};void fun(){Animal *p = new Cat("Tom");p->speak();delete p;}int main(){fun();system("pause");return 0;}

上面程序中如果在父类中不使用虚析构，其运行结果如下图所示，可以看到，父类指针在析构的时候无法执行子类的析构函数，后果就是如果子类中有堆区数据属性，就会产生内存泄漏。

父类中使用虚析构，其运行结果如下图所示，子类中的析构函数也被执行了。

纯虚函数在父类中只做声明，不做实现。不同与纯虚函数，纯虚析构在父类中不仅需要有声明，还需要有具体的实现，因为父类中也可能有一些属性开辟在堆区。
在上面代码的基础上，需要修改为纯虚析构代码的部分如下。

class Animal{public:Animal(){cout<<"Animal类构造函数"<<endl;}virtual ~Animal() = 0; //纯虚析构的声明virtual void speak() = 0;//纯虚函数};Animal :: ~Animal() //纯虚析构的实现{cout<<"Animal类纯虚析构函数"<<endl;}

使用纯虚析构后的程序运行结果如下图所示。

6.多态案例——电脑组装

电脑的主要组成部件有CPU、显卡、内存。将每个部件封装出抽象的基类，并提供不同的厂商生产不同的零件，创建电脑类提供让电脑工作的函数，并调用每个部件工作的接口。
该案例的代码实现如下。

#include #include using namespace std;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 *m){this->cpu = cpu;//构造函数中接收各指针this->vc = vc;this->m = m;}void work(){cpu->calculate(); //调用各零件接口vc->display();m->storage();}~Computer()//析构函数释放指针{if(cpu != NULL){delete cpu;cpu = NULL;}if(vc != NULL){delete vc;vc = NULL;}if(m != NULL){delete m;m = NULL;}}private:CPU *cpu;//CPU零件指针VideoCard *vc;Memory *m;};//Intel厂商class IntelCPU : public CPU{public:void calculate(){cout<<"Intel_CPU_calculate()"<<endl;}};class IntelVideoCard : public VideoCard{public:void display(){cout<<"Intel_VideoCard_display()"<<endl;}};class IntelMemory : public Memory{public:void storage(){cout<<"Intel_Memory_storage()"<<endl;}};//Lenovo厂商class LenovoCPU : public CPU{public:void calculate(){cout<<"Lenovo_CPU_calculate()"<<endl;}};class LenovoVideoCard : public VideoCard{public:void display(){cout<<"Lenovo_VideoCard_display()"<<endl;}};class LenovoMemory : public Memory{public:void storage(){cout<<"Lenovo_Memory_storage()"<<endl;}};void test(){cout<<"第一台电脑组装:"<<endl;CPU *icpu = new IntelCPU;VideoCard *ivc = new IntelVideoCard;Memory *m = new IntelMemory;Computer *c1 = new Computer(icpu,ivc,m);c1->work();delete c1;cout<<"----------------------"<<endl;cout<<"第二台电脑组装:"<<endl;Computer *c2 = new Computer(new LenovoCPU,new LenovoVideoCard,new LenovoMemory);c2->work();delete c2;cout<<"----------------------"<<endl;cout<<"第三台电脑组装:"<<endl;Computer *c3 = new Computer(new LenovoCPU,new IntelVideoCard,new LenovoMemory);c3->work();delete c3;}int main(){test();system("pause");return 0;}

程序运行结果如下图所示。

文件操作

程序运行时产生的数据都属于临时数据，程序运行结束后都会被释放，通过文件可以将数据持久化。
C++中对文件的操作需要包含头文件。
文件类型分为两种，文本文件和二进制文件。文本文件以文本的ASCII码形式存储。二进制文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们。
操作文件的三大类：ofstream（写操作）、ifstream（读操作）、fstream（读写操作）。

文件的打开方式可以配合使用，如果有多个中间使用 | 符连接。例如用二进制方式写文件 ios::binary | ios::out。

1.文本文件–写文件

写文件的步骤：1.包含头文件 #include ；2.创建流对象 ofstream ofs；3.打开文件 ofs.open(“文件路径”,打开方式)；4.写数据 ofs << “写入的数据”(cout是往屏幕上输出，ofs是往文件中输出)；5.关闭文件 ofs.close()。
往文本文件中写内容的简单代码如下。

#include #include //1.包含头文件#include using namespace std;void test(){ofstream ofs;//2.创建流对象ofs.open("test.txt",ios::out); //3.打开文件ofs << "This is the first line." <<endl; //4.往文件写内容ofs << "This is the second line." <<endl;ofs << "This is the third line." <<endl;ofs.close();//5.关闭文件}int main(){test();system("pause");return 0;}

程序运行结束后，右键Visual Studio中的cpp文件，选择打开所在的文件夹，在该文件夹下就生成了指定的文件，打开后其内容如下图所示。

可以看到，文件名就是我们在程序中指定的，当然程序中也可以将文件名指定为绝对路径，如果只是给出文件名，生成的文件默认就在项目所在目录下。文件中的内容也是通过代码写入的。

2.文本文件–读文件

读文件的步骤：1.包含头文件 #include ；2.创建流对象 ifstream ifs；3.打开文件并判断文件是否打开成功 ifs.open(“文件路径”,打开方式)，is_open()函数判断文件是否打开成功；4.读数据，共有四种方式；5.关闭文件 ifs.close()。
从文本文件中读取内容的简单代码如下。

#include #include //1.包含头文件#include using namespace std;void test(){ifstream ifs;//2.创建流对象ifs.open("test.txt",ios::in); //3.打开文件并判断文件是否打开成功if(!ifs.is_open()){cout<<"文件打开失败！"<<endl;return;}//4.读文件内容//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();//5.关闭文件}int main(){test();system("pause");return 0;}

读取到的文件内容就是上面写入的内容，读取的结果如下图所示。

3.二进制文件–写文件

以二进制方式往文件中写内容的简单代码如下。

#include #include //1.包含头文件#include using namespace std;class Person{public:char name[64];int age;};void test(){ofstream ofs;//2.创建流对象ofs.open("person.txt",ios::out|ios::binary); //3.以二进制方式打开文件//ofstream ofs("person.txt",ios::out|ios::binary); //2和3步骤也可以用本行代替Person p = {"张三",22};ofs.write((const char*)&p,sizeof(Person));ofs.close();//5.关闭文件}int main(){test();system("pause");return 0;}

以二进制方式写的时候可以写入类这种类型的数据到文件，程序运行之后同样在项目文件夹下可以看到新出现的文件，打开后其内容如下图所示。

可以看到，以二进制写入文件后会出现乱码，有时候甚至都看不懂，不过没关系，只要确保写入的内容是对的，后面通过读取文件就可以验证。

4.二进制文件–读文件

以二进制方式读取文件内容的简单代码如下。

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

程序运行后的结果如下图所示。

可以看到，虽然以二进制方式写入文件后会出现乱码，但是以二进制方式读取到的内容与写入的内容是一致的。

本文参考视频：
黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难