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

多态

1.多态基本概念

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

#include <iostream>
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 <iostream>
#include <string>
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 <iostream>
#include <string>
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 <iostream>
#include <string>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 <iostream>
#include <string>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();delete  p;
}int main()
{fun(new Tea);cout<<"----------------------"<<endl;fun(new Coffee);system("pause");return 0;
}

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

5.虚析构和纯虚析构

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

#include <iostream>
#include <string>
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 <iostream>
#include <string>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::in	读文件
ios::out	写文件
ios::ate	初始位置是文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式

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

1.文本文件–写文件

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

#include <iostream>
#include <fstream>  //1.包含头文件
#include <string>
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 <iostream>
#include <fstream>  //1.包含头文件
#include <string>
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 <iostream>
#include <fstream>  //1.包含头文件
#include <string>
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 <iostream>
#include <fstream>  //1.包含头文件
#include <string>
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入门编程,学习编程不再难