C++编程语言

1 C++初识

1.1 常量

C++定义常量两种方式

1.#define宏常量： #define 常量名 常量值

2.const修饰的变量 const 数据类型 常量名 = 常量值

2 数据类型

2.1 内存

sizeof( 数据类型 /变量 ) 输出所占内存

2.2 字符串

C++数据类型（整型、浮点型、字符型、字符串型、布尔型）_c++字符型-CSDN博客

#include<iostream>
#include<string.h>
using namespace std;int main(){//C风格字符串char str[]="Hello world";cout<<str<<endl;//C++风格字符串string str2="Hello world";cout<<str2<<endl;system("pause");return 0;
}

3 运算符

4 程序流程结构

4.1 三目运算符

//判断真假?表达式1:表达式2
a > b ? a : b

4.2 siwch语句

C switch 语句 | 菜鸟教程 (runoob.com)

#include<iostream>
using namespace std;
int main(){int a;cin>>a;switch (a){case 1:cout<<1<<endl;break;case 2:cout<<2<<endl;//break;case 3:cout<<3<<endl;break;default:cout<<0<<endl;}system("pause");return 0;
}

• 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
• case里尽量不用变量

4.3 do…while循环语句

与while的区别在于会先执行一次循环语句，再判断循环条件

4.4 goto语句

C goto 语句 | 菜鸟教程 (runoob.com)

5 数组

6 函数

6.1 参数

#include<iostream>
using namespace std;int d(int a,int b=20){return a+b;
}int main(){int a,b;cin>>a>>b;cout<<d(a)<<endl;cout<<d(0,b)<<endl;cout<<d(a,b)<<endl;
}

6.2 函数的分文件编写

[C++ 函数的分文件编写_c++函数的分文件编写-CSDN博客](https://blog.csdn.net/qq_37796444/article/details/107016831#:~:text=C%2B%2B 函数的分文件编写 1 创建.h 后缀名的头文件 2 创建.cpp后缀名的源文件,3 在头文件中写函数的声明 4 在源文件中写函数的定义 5、最后就是在main中进行测试，就OK了。 （同时注意这里也需要加入头文件---- %23incude “swap.h”）)

【c语言】无法找到头文件（fatal error: .h: No such file or directory）_10: fatal error: ot_common.h: no such file or dire_StudentWang_的博客-CSDN博客

7 指针

7.1 定义指针

#include<iostream>
using namespace std;int main(){//指针定义的语法： 数据类型 * 指针变量名:int a = 10;int * p;//让指针p记录a的地址p = &a;//使用指针*p = 1000;cout<<a<<endl;return 0;
}

7.2 指针内存

不论是什么数据类型

在32操作系统下：占用4个字节空间

在64操作系统下：占用8个字节空间

7.3 空指针

用途：初始化指针变量

注意：空指针指向的内存是不可访问的

int * p =NULL;

7.4 野指针

指针变量指向非法的内存空间

int * p = (int *)0x1100; //16进制的数

7.5 const修饰指针

1.常量指针：const int * p = &a;

特定：指针的指向可以改，但是指针指向的值不可以改

*p = 20; 错误

p = &b; 正确

2.指针常量：int * const p = &a;

特点：指针的指向不可以改，指针指向的值可以改

*p = 20; 正确

p = &b; 错误

3.常量既修饰指针和常量

const int * const p = &a;

特点：指针的指向不可以改，指针指向的值也不可以改

7.6 指针和数组

#include<iostream>
using namespace std;int main(){int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int *p =arr;	//arr就是数组首地址for(int i=1;i<=10;i++){cout<<*p<<endl;p++;}return 0;
}

7.7 指针和函数

#include<iostream>
using namespace std;void swap(int *p1,int *p2){int temp=*p1;*p1=*p2;*p2=temp;
}int main(){int a=10;int b=20;swap(&a,&b);cout<<a<<endl;cout<<b<<endl;return 0;
}

8 结构体

8.1 结构体指针

#include<iostream>
using namespace std;struct node{int a;int b;
};int main(){node s={10,20};node *p=&s;cout<<p->b;return 0;
}

9 通讯录管理系统

标准答案

#include<iostream>
#include<string>
using namespace std;
#define MAX 1000 //最大人数//联系人结构体
struct Person
{string m_Name;int m_Sex; //性别：1男 2女int m_Age;string m_Phone;string m_Addr;
};//通讯录结构体
struct Addressbooks
{struct Person personArray[MAX]; //通讯录中保存的联系人数组int m_Size; //通讯录中人员个数
};//添加联系人
void addPerson(Addressbooks * abs)
{//判断联系人是否满了if (abs->m_Size == MAX){cout << "通讯录已满，无法添加" << endl;return;}else{string name;cout << "请输入姓名：" << endl;cin >> name;abs->personArray[abs->m_Size].m_Name = name;cout << "请输入性别：" << endl;cout << "1 -- 男" << endl;cout << "2 -- 女" << endl;int sex = 0;while (true){cin >> sex;if (sex == 1 || sex == 2){abs->personArray[abs->m_Size].m_Sex = sex;break;}cout << "输入有误，请重新输入" << endl;}cout << "请输入年龄：" << endl;int age = 0;cin >> age;abs->personArray[abs->m_Size].m_Age = age;cout << "请输入联系电话：" << endl;string phone = "";cin >> phone;abs->personArray[abs->m_Size].m_Phone = phone;cout << "请输入家庭住址：" << endl;string address;cin >> address;abs->personArray[abs->m_Size].m_Addr = address;//更新通讯录人数abs->m_Size++;cout << "添加成功：" << endl;system("pause");system("cls");}
}//显示联系人
void showPerson(Addressbooks * abs)
{if (abs->m_Size == 0){cout << "暂时没有联系人" << endl;}else{for (int i = 0; i < abs->m_Size; i++){cout << "姓名：" << abs->personArray[i].m_Name << "\t";cout << "性别：" << (abs->personArray[i].m_Sex == 1 ? "男" : "女") << "\t";cout << "年龄：" << abs->personArray[i].m_Age << "\t";cout << "电话：" << abs->personArray[i].m_Phone << "\t";cout << "住址：" << abs->personArray[i].m_Addr << endl;}}system("pause");system("cls");
}//判断是否存在查询的人员，存在返回在数组中索引位置，不存在返回-1
int isExist(Addressbooks * abs ,string name)
{for (int i = 0; i < abs->m_Size; i++){if (abs->personArray[i].m_Name == name){return i;}}return -1;
}//删除联系人
void deletePerson(Addressbooks * abs)
{cout << "请输入您要删除的联系人" << endl;string name;cin >> name;int ret = isExist(abs, name);if (ret != -1){for (int i = ret; i < abs->m_Size; i++){abs->personArray[i] = abs->personArray[i++];}abs->m_Size--;cout << "删除成功" << endl;}else{cout << "查无此人" << endl;}system("pause");system("cls");
}//查找联系人
void findPerson(Addressbooks * abs)
{cout << "请输入您要查找的联系人" << endl;string name;cin >> name;int ret = isExist(abs, name);if (ret != -1){cout << "姓名：" << abs->personArray[ret].m_Name << "\t";cout << "性别：" << abs->personArray[ret].m_Sex << "\t";cout << "年龄：" << abs->personArray[ret].m_Age << "\t";cout << "电话：" << abs->personArray[ret].m_Phone << "\t";cout << "住址：" << abs->personArray[ret].m_Addr << endl;}else{cout << "查无此人" << endl;}system("pause");system("cls");}//修改联系人
void modifyPerson(Addressbooks* abs)
{cout << "请输入你要修改的联系人" << endl;string name;cin >> name;int ret = isExist(abs, name);if (ret != -1){cout << "请输入姓名：" << endl;string name;cin >> name;abs->personArray[ret].m_Name = name;cout << "请输入性别：" << endl;int sex;while (true){cin >> sex;if (sex == 1 || sex == 2){abs->personArray[ret].m_Sex = sex;break;}cout << "输入有误，请重新输入" << endl;}cout << "请输入年龄：" << endl;int age;cin >> age;abs->personArray[ret].m_Age = age;cout << "请输入联系电话：" << endl;string phone;cin >> phone;abs->personArray[ret].m_Phone = phone;cout << "请输入家庭住址：" << endl;string address;cin >> address;abs->personArray[ret].m_Addr = address;cout << "修改成功" << endl;}else{cout << "查无此人" << endl;}system("pause");system("cls");
}//清空联系人
void cleanPerson(Addressbooks * abs)
{abs->m_Size = 0;cout << "通讯录已清空" << endl;system("pause");system("cls");
}//菜单界面
void showMenu()
{cout << "***************************" << endl;cout << "*****  1、添加联系人  *****" << endl;cout << "*****  2、显示联系人  *****" << endl;cout << "*****  3、删除联系人  *****" << endl;cout << "*****  4、查找联系人  *****" << endl;cout << "*****  5、修改联系人  *****" << endl;cout << "*****  6、清空联系人  *****" << endl;cout << "*****  0、退出通讯录  *****" << endl;cout << "***************************" << endl;
}int main()
{int select = 0;//创建通讯录Addressbooks abs;//初始化通讯录中的人数abs.m_Size = 0;while (true){showMenu();cin >> select;switch (select){case 1: //添加联系人addPerson(&abs);break;case 2: //显示联系人showPerson(&abs);break;case 3: //删除联系人deletePerson(&abs);break;case 4: //查找联系人findPerson(&abs);break;case 5: //修改联系人modifyPerson(&abs);break;case 6: //清空联系人cleanPerson(&abs);break;case 0: //退出通讯录cout << "欢迎下次使用" << endl;system("pause");return 0;break;default:break;}}system("pause");return 0;
}

自习代码

#include<bits/stdc++.h>
using namespace std;
#define MAX 1000
struct node{string name;        //姓名int numb;           //电话
};
struct Address{struct node people[MAX];int size;
};void show(){cout<<"**************************\n";cout<<"*****  1、添加联系人  *****\n";cout<<"*****  2、显示联系人  *****\n";cout<<"*****  3、删除联系人  *****\n";cout<<"*****  4、查找联系人  *****\n";cout<<"*****  5、修改联系人  *****\n";cout<<"*****  6、清空联系人  *****\n";cout<<"*****  0、退出通讯录  *****\n";cout<<"**************************";
}
int isExist(Address *p,string x){for(int i=0;i<p->size;i++){if(p->people[i].name==x)return i;}return -1;
}
void add(Address *p){cout<<"请输入名字";string s;cin>>s;p->people[p->size].name=s;cout<<"请输入电话";int x;cin>>x;p->people[p->size].numb=x;p->size++;
}
void display(Address *p){for(int i=0;i<p->size;i++){cout<<"姓名:\n"<<p->people[i].name<<'\n';cout<<"电话:\n"<<p->people[i].numb<<'\n'<<'\n';}
}
void delect(Address *p){cout<<"请输入想要删除的人的名字\n";string s;cin>>s;int m=isExist(p,s);if(m==-1)cout<<"没有这个人\n";else{for(int i=m;i<p->size;i++){p->people[i].name=p->people[i+1].name;p->people[i].numb=p->people[i+1].numb;}p->size--;cout<<"删除成功\n";}
}
int main(){Address abs;abs.size=0;int x;while(true){show();cin>>x;switch(x){case(1):add(&abs);break;case(2):display(&abs);break;case(3):delect(&abs);break;case(0):cout<<"退出成功";return 0;default:break;}system("pause");system("cls");}
}

C++核心编程

1 内存分区模型

1.1 概述

C++程序在执行时，将内存大方向划分为4个区域：

代码区： 存放函数体的二进制代码，由操作系统进行管理；

全局区： 存放全局变量和静态变量以及常量；

栈区： 由编译器自动分配释放, 存放函数的参数值、局部变量等；

堆区： 由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存四区的意义： 不同区域存放的数据赋予不同的生命周期, 给我们更大的灵活编程。

1.2 new操作符

C++ 涨知识！new和delete知识总结(全面详细)_c++ delete用法-CSDN博客

C++中利用new操作符在堆区开辟数据。堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete。

new操作符的语法：new数据类型

利用new创建的数据，会返回该数据对应的类型的指针。

​ delete释放地址

实例如下所示。

#include<iostream>
using namespace std;int main(){int *p= new int[10];for(int i=0;i<10;i++)p[i]=i+100;for(int i=0;i<10;i++){cout<<p[i]<<endl;    cout<<*p<<endl<<endl;}delete[] p;return 0;
}

2 引用

2.1 基本语法

引用的本质在C++中内部实现是一个指针常量

语法：数据类型 &别名 = 原名

int &b = a;

注意：1.必须初始化；2.引用后就不能更改

#include<iostream>
using namespace std;void swap(int &a,int &b){int temp=a;a=b;b=temp;
}int main(){int a=10;int b=20;swap(a,b);cout<<a<<endl;cout<<b<<endl;return 0;
}

2.2 引用做函数返回值

#include<iostream>
using namespace std;int &test(){static int a=10;	//静态变量，存放在全局区return a;
}int main(){int &a=test();cout<<a<<endl;cout<<a<<endl;test()=20;		//如果函数的返回值是引用，可以作为左值cout<<a<<endl;cout<<a<<endl;return 0;
}

3 函数提高

3.1 函数默认参数

如果某个位置参数有默认值，那么从这个位置往后都必须要有默认值

如果函数声明有默认参数，函数实现就不能有默认参数

3.2 占位参数

void func(int a, int){}

3.3 函数重载

函数参数类型不同 或者 个数不同 或者 顺序不同

C++ const对函数重载的影响-CSDN博客

4 对象特性

4.1 构造函数和析构函数

构造函数： 主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
构造函数的语法：类名(){}

   1. 构造函数，没有返回值也不写void；2. 函数名称与类名相同；3. 构造函数可以有参数，因此可以发生重载；4. 程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次。

析构函数： 主要作用在于对象销毁前系统自动调用，执行一些清理工作。
析构函数的语法： ~类名(){}

   1. 析构函数，没有返回值也不写void；2. 函数名称与类名相同，在名称前加上符号~；3. 析构函数不可以有参数，因此不可以发生重载；4. 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次。

#include<iostream>
using namespace std;
class Person{public:Person(){cout<<"构造函数\n";}~Person(){cout<<"析构函数\n";}
};
int main(){Person();return 0;
}

4.2 构造函数的分类及调用

#include<iostream>
using namespace std;
class Person{public:Person(){cout<<"构造函数\n";}//拷贝构造函数Person(const Person &p){age=p.age;}~Person(){cout<<"析构函数\n";}private:int age;
};
int main(){Person();return 0;
}

4.3 构造函数的调用规则

默认情况下，C++编译器至少给一个类添加3个函数：

1. 默认构造函数(无参，函数体为空)；
2. 默认析构函数(无参，函数体为空)；
3. 默认拷贝构造函数，对属性进行值拷贝。

构造函数的调用规则如下：

• 如果用户定义有参构造函数，C++不再提供默认无参构造函数，但是会提供默认拷贝构造函数；
• 如果用户定义拷贝构造函数，C++不会再提供其他构造函数。

4.4 深拷贝和浅拷贝

浅拷贝： 简单的赋值拷贝操作。

深拷贝： 在堆区重新申请空间，进行拷贝操作。

总结：

1.如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题；

2.析构函数代码用于对在堆区开辟的内存做释放操作。

浅拷贝与深拷贝的区别（详解）_深拷贝和浅拷贝的区别-CSDN博客

4.5 初始化列表

Person(int a, int b, int c) :m_A(a), m_B(b), m_C© { }

4.6 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。

静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。

静态成员分为静态成员变量和静态成员函数：

• 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化
• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

静态成员函数与普通成员函数的区别：

• 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）；
• 普通成员函数有 this 指针，可以访问类中的任意成员。

#include<iostream>
using namespace std;class Person{public:static int a;
};
int Person::a=100;      //类内声明，类外初始化int main(){Person p1;cout<<p1.a<<endl;Person p2;p2.a=200;cout<<p1.a<<endl;return 0;
}

4.7 成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。

4.8 const修饰成员函数

• 常函数：

  • 成员函数后加const后我们称为这个函数为常函数；
  • 常函数内不可以修改成员属性；
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改。

• 常对象：

  • 声明对象前加const称该对象为常对象；
  • 常对象只能调用常函数。

5 友元

C++：友元（看这一篇就够了）_c++友元_孙 悟 空的博客-CSDN博客

6 运算符重载

#include<iostream>
using namespace std;class Person{public:friend ostream &operator<<(ostream &out,Person &p);Person(int a=50,int b=50):a(a),b(b){}//加号运算符重载Person operator+(Person &p){Person temp;temp.a=this->a+p.a;temp.b=this->b+p.b;return temp;}private:int a;int b;
};
//左移运算符重载
ostream &operator<<(ostream &out,Person &p){        //简化为cout<<pcout<<p.a<<'\n'<<p.b;return out;
}int main(){Person p1(10,10);Person p2(20,30);Person p3=p1+p2;cout<<p3<<endl;return 0;
}

7 继承

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

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

答案： 静态成员和非静态成员出现同名，处理方式一致。如果访问子类同名成员，直接访问即可；如果访问父类同名成员，需要加作用域。

s.func();  //直接调用的是子类的同名静态成员函数
s.Base::func();  //加父类作用域调用的是父类的同名静态成员函数

7.2 多继承语法

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++允许一个类继承多个类，但多继承可能会引发父类中有同名成员出现，需要加作用域区分。在C++实际开发中，不建议用多继承。

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

#include<iostream>
using namespace std;class Base1{public:int a=8;
};
class Base2{public:int a=16;
};
class Son:public Base1,public Base2{};int main(){Son s;cout<<sizeof(s)<<endl;//当父类出现同名成员，需要加作用域cout<<s.Base1::a;
}

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

7.3 虚继承

#include<iostream>
using namespace std;class Animal{       //虚基类public:int a;
};
class Sheep:virtual public Animal{};class Tuo:virtual public Animal{};class YangTuo:public Sheep,public Tuo{};int main(){YangTuo yt;yt.Sheep::a=10;yt.Tuo::a=20;cout<<yt.Sheep::a<<endl;cout<<yt.Tuo::a<<endl;cout<<yt.a<<endl;return 0;
}

Sheep中的a= 28
Tuo中的a= 28
YangTuo中的a= 28

8 多态

8.1 基本概念

多态是C++面向对象三大特性之一。多态分为两类：

1. 静态多态：函数重载和运算符重载属于静态多态，复用函数名；
2. 动态多态：派生类和虚函数实现运行时多态。

多态是C++面向对象三大特性之一。多态分为两类：

1. 静态多态：函数重载和运算符重载属于静态多态，复用函数名；
2. 动态多态：派生类和虚函数实现运行时多态。

#include<iostream>
using namespace std;class Animal{public://虚函数（函数前面加virtual关键字）virtual void speak(){cout<<"动物在说话"<<endl;}
};
class Cat:public Animal{public:void speak(){cout<<"小猫在说话"<<endl;}
};int main(){Cat cat;Animal &animal=cat;animal.speak();return 0;
}

总结：

1. 多态满足条件：1）有继承关系；2）子类重写父类中的虚函数（重写指函数返回值类型、函数名、参数列表完全一致）。

2. 多态使用条件：父类指针或引用指向子类对象。

8.2 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。

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

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

抽象类的特点：1. 无法实例化对象；

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

#include<iostream>
using namespace std;class Animal{public:virtual void speak()=0;
};
class Cat:public Animal{public:void speak(){cout<<"小猫在说话"<<endl;}
};
int main(){Cat cat;Animal &animal=cat;//Animal b;报错animal.speak();return 0;
}

8.3 多态案例

案例描述： 制作饮品的大致流程为：煮水→冲泡→倒入杯中→加入辅料。利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶。

#include<iostream>
using namespace std;//制作饮品
class AbstractDrinking
{
public:virtual void Boil() = 0;  //煮水virtual void Brew() = 0;  //冲泡virtual void PourInCup() = 0;  //倒入杯中virtual void PutSomething() = 0;  //加入辅料void makeDrink()  //制作饮品{Boil();Brew();PourInCup();PutSomething();}
};//冲咖啡
class Coffee :public AbstractDrinking
{
public:virtual void Boil()  //煮水{cout << "煮纯净水" << endl;}virtual void Brew()  //冲泡{cout << "冲泡咖啡" << endl;}virtual void PourInCup()  //倒入杯中{cout << "倒入杯中" << endl;}virtual void PutSomething()  //加入辅料{cout << "加入糖和牛奶" << endl;}
};//冲茶叶
class Tea :public AbstractDrinking
{
public:virtual void Boil()  //煮水{cout << "煮纯净水" << endl;}virtual void Brew()  //冲泡{cout << "冲泡茶叶" << endl;}virtual void PourInCup()  //倒入杯中{cout << "倒入杯中" << endl;}virtual void PutSomething()  //加入辅料{cout << "加入枸杞" << endl;}
};void doWork(AbstractDrinking *abs)  //AbstractDrinking *abs = new Coffee;
{abs->makeDrink();delete abs;  //释放堆区内存
}void test01()
{//冲咖啡cout << "开始冲咖啡..." << endl;doWork(new Coffee);cout << "----------------------" << endl;//冲茶叶cout << "开始冲茶叶..." << endl;doWork(new Tea);}int main()
{test01();system("pause");return 0;
}

8.4 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
  解决方式：将父类中的析构函数改为虚析构或者纯虚析构。

虚析构和纯虚析构的共性：1. 可以解决父类指针无法释放子类对象的问题；

                2. 都需要有具体的函数实现。

虚析构和纯虚析构的区别：如果是纯虚析构，该类属于抽象类，无法实例化对象。

虚析构的语法：virtual ~类名(){}

纯虚析构的语法：类内→virtual ~类名() = 0;
          类外→ 类名::~类名(){}

#include<iostream>
using namespace std;class Animal{public:virtual void speak()=0;virtual ~Animal(){cout<<"ANIMAL"<<endl;}
};
class Cat:public Animal{public:Cat(string a){cout<<"构造函数"<<endl;name=new string(a);}void speak(){cout<<*name<<"小猫在说话"<<endl;}~Cat(){if(name!=NULL){cout<<"析构函数调用"<<endl;delete name;name=NULL;}}string *name;
};int main(){Animal *animal=new Cat("Tom");animal->speak();delete animal;return 0;
}

总结： 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象的问题；

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

   拥有纯虚析构函数的类也属于抽象类，无法实例化对象。

9 文件操作

9.1 文本文件

数据类型	描述
ofstream	该数据类型表示输出文件流，用于创建文件并向文件写入信息。
ifstream	该数据类型表示输入文件流，用于从文件读取信息。
fstream	该数据类型通常表示文件流，且同时具有 ofstream 和 ifstream 两种功能，这意味着它可以创建文件，向文件写入信息，从文件读取信息。

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化。

C++中对文件操作需要包含头文件 ;。

文件类型分为两种：1. 文本文件 ：文件以文本的ASCII码形式存储在计算机中；

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

操作文件的三大类： 1. ofstream：写操作

              2. ifstream： 读操作am ： 读写操作

1.包含头文件

​ #include

2.创建流对象

​ ofstream.ofs;

3.打开文件

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

4.写数据

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

5.关闭文件

​ ofs.close();