一、基础部分
1、C++编写步骤
编写一个C++程序总共分为4个步骤：创建项目->创建文件->编写代码->运行程序
#include<iostream>
using namespace std;
int main()
{
cout<<"hello world"<<endl;
return 0;
}
2、注释
1）单行注释：通常放在一行代码的上方，或一条语句的末尾，对该行代码说明。
//描述信息
2）多行注释：通常放在一段代码的上方，对该段代码做整体说明。
/*描述信息*/
3、变量
作用：给一段指定的内存空间起名，方便操作这段内存。
语法：数据类型 变量名=初始值；
#include<iostream>
using namespace std;
int main()
{
int a=10;
cout<<"a= "<<a<<endl;
return 0;
}
4、常量
作用：用于记录程序中不可更改的数据。
1）#define 宏常量：通常在文件上方定义，表示一个常量。
#define 常量名 常量值
2）const修饰的变量：通常在变量定义前加关键字const，修饰该变量为常量，不可修改。
const 数据类型 常量名 = 常量值
5、关键字
关键字是C++中预先保留的单词（标识符）在定义变量或常量时，不要使用关键字。
sizeof关键字
作用：利用sizeof关键字可以统计数据类型所占内存大小
语法：sizeof（数据类型/变量）
#include <iostream>
using namespace std;
int main() {
cout << "short类型所占内存空间为: " << sizeof(short) << endl;
cout << "int类型所占内存空间为: " << sizeof(int) << endl;
cout << "long类型所占内存空间为: " << sizeof(long) << endl;
cout << "long long类型所占内存空间为: " << sizeof(long long) << endl;
return 0;
}
6、标识符命名规则
1）标识符不能是关键字；
2）标识符只能由字母，数字，下划线组成；
3）第一个字符必须为字母或下划线；
4）标识符中字母区分大小写。
7、数据类型
C++规定在创建一个变量或常量时，必须要指出对应的数据类型，否则无法给变量分配内存。
转义字符
作用：用于表示一些不显示出来的ASCII字符
常用转义字符： \n（换行） \（反斜线） \t（水平制表）
数据的输入
作用：用于从键盘获取数据
关键字：cin
语法：cin >> 变量
7.1、整型
作用：整型变量表示的是整数类型的数据。
数据类型 占用空间
short（短整型） 2字节
int(整型) 4字节
long（长整型） Windows：4字节，Linux：4字节（32位）8字节（64位）
long long（长长整型） 8字节
整型大小比较：short < int <= long <= long long
7.2、浮点型
作用：用于表示小数。
浮点类型数据变量分为两种：1）单精度 float 2）双精度 double
float f1 = 3.14f;
double d1 = 3.14;
两者的区别在于表示的有效数字范围不同：
数据类型 占用字节 有效数字范围
float 4字节 7位有效数字
double 8字节 15-16位有效数字
默认情况下，输出一个小数，会显示出6位有效数字。
7.3、字符型
作用：字符型变量用于显示单个字符。
语法：char ch = ‘a'；
注意： 1）在显示字符串变量时，用单引号将字符括起来，不要用双引号；
2）单引号内只能有一个字符，不可以是字符串。
C和C++中字符型变量只占用一个字节。
字符变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放到存储单元。
7.4、字符串类型
作用：用于表示一串字符。
C风格字符串：char 变量名[ ] = “字符串”；
C++风格字符串：string 变量名 = “字符串值”；（使用C++风格字符串时候，要包含**#include <string>** 这个头文件）
7.8、布尔类型
作用：布尔数据类型代表真或假的值。
bool类型只有两个值：true—真（本质是1） flase—假（本质是0）
bool类型占1个字节大小。
8、运算符
作用：用于执行代码的运算。
运算符类型 作用 运算符
算术运算符 用于处理四则运算 + - * / % ++ --
赋值运算符 用于将表达式的值赋给变量 = += -= *= /= %=
比较运算符 用于表达式的比较，并返回一个真值或假值 ==
逻辑运算符 用于根据表达式的值返回真值或假值 ！（与） &&（与） ||(或)
9、程序流程结构
C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。
- 顺序结构：程序按顺序执行，不发生跳转；
- 选择结构：依据条件是否满足，有选择的执行相应功能；
- 循环结构：依据条件是否满足，循环多久执行某段代码。
9.1、选择结构
1）if语句
作用：执行满足条件的语句
单行格式if语句：
if（条件）{
条件满足执行的语句
}；
多行格式if语句：
if(条件){
条件满足执行的语句
}
else{
条件不满足执行语句
}；
多条件的if语句：
if(条件1){
条件1满足执行的语句
}
else if(条件2){
条件2满足执行的语句
}
else{
都不满足执行的语句
}
2）嵌套if语句
在if语句中，可以嵌套使用if语句，达到更精准的条件判断。
3）三目运算符
作用：通过三目运算符实现简单的判断
语法：表达式1 ？表达式2:表达式3
如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
如果表达式1的值为假，执行表达式3，并返回表达式3的结果。
4）switch语句
作用：执行多条件分支语句。
switch(表达式)
{
case结果1：
执行语句；
break；
case结果2:
执行语句；
break；
...
default:
执行语句；
break；
}
9.2、循环结构-while
作用：满足循环条件，执行循环语句。
while（循环条件）{
循环语句
};
9.3、do-while循环语句
作用：满足循环条件，执行循环语句。
do{
循环语句
}
while(循环条件);
注意：与while的区别在于do-while会先执行一次循环语句，再判断循环条件。
//在屏幕输出0-9
#include <iostream>
using namespace std;
int main() {
int num = 0;
do
{
cout << num << endl;
num++;
} while (num<10);
return 0;
}
//水仙花数，每个位数上的数字的3次幂之和等于它本身
#include<iostream>
using namespace std;
int main() {
int num = 100;//要判断的三位数
int a = 0; //个位
int b = 0; //十位
int c = 0; //百位
do {
a = num % 10; //获取该三位数的个位
b = num / 10 % 10; //获取该三位数的十位
c = num / 100; //获取该三位数的百位
if (a * a * a + b * b * b + c * c * c == num) {
cout << num << "是水仙花数" << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}
9.4、for循环
作用：满足循环条件，执行循环语句。
for（起始表达式；条件表达式；末尾循环体）{
循环语句；
}
注意：for循环体中的表达式，需要用分号进行分隔。
9.5、嵌套循环
作用：在循环中再嵌套一层循环，解决一些实际问题。
//乘法口诀表
#include <iostream>
using namespace std;
int main() {
for (int i = 1; i < 9; i++)
{
for (int j = 0; j <= i; j++)
{
cout << j << "*" << i << "=" << j * i << " ";
}
cout << endl;
};
return 0;
}
9.6、跳转语句—break语句
作用：用于跳出选择结构或循环结构
break使用时机：
- 出现在switch语句中，用于终止case并跳出switch；
- 循环语句中，跳出当前的循环语句；
- 嵌套语句中，跳出最近的内层循环。
9.7、跳转语句—continue语句
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。
注意：continue并没有使整个循环终止，而break会跳出循环。
10、数组
所谓数组，就是一个集合，里面存放了相同类型的数据元素。
特点：1）数组中每个数据元素都是相同的数据类型；
2）数组是由连续的内存位置组成的。
10.1、一维数组
一维数组定义方式：
数据类型 数组名[数组长度]；
数据类型 数组名[数组长度] = {值1，值2，...}
数据类型 数组名[] = {值1，值2，...}
#include <iostream>
using namespace std;
int main() {
int arr[5];
int arr2[5] = { 10,20,30,40,50 };
//利用循环输出数组中的元素
for (int i = 0; i < 5; i++)
{
cout << arr2[i] << endl;
}
return 0;
}
数组名的命名规范与变量名命名规范一致，不要和变量名重名。
数组中下标是从0开始索引。
一维数组数组名用途：
- 可以统计整个数组在内存中的长度 => sizeof（arr）
- 可以获取数组在内存中的首地址
cout<<"数组首地址为："<< (int)arr << endl;cout<<"数组中第一个元素地址为："<< (int)&arr[0] << endl;
10.2、二维数组
二维数组就是在一维数组上，多加一个维度。
4种定义方式：
数据类型 数组名[行数][列数]；
数据类型 数组名[行数][列数] = {{数据1，数据2},{数据3，数据4}}；
数据类型 数组名[行数][列数] = {数据1，数据2，数据3，数据4}；
数据类型 数组名[][列数] = {数据1，数据2，数据3，数据4}；
二维数组名组名用途：1）查看二维数组所占内存空间；2）获取二维数组首地址
11、函数
作用：将一段经常使用的代码封装起来，减少重复代码。
11.1、函数的定义
函数定义的步骤：
返回值类型 -> 函数名 -> 参数列表 -> 函数体语句 -> return表达式
语法：
返回值类型 函数名（参数列表）
{
函数体语句；
return表达式；
}
int add(int num1,int num2){
int sum = num1 + num2;
return sum;
}
返回值类型：一个函数可以返回一个值，在函数定义中。
函数名：给函数起的名称。
参数列表：使用该函数时，传入的数据。
函数体语句：花括号内的代码，函数内需要执行的语句。
return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据。
11.2、函数的调用
功能：使用定义好的函数。
语法：函数名（参数）
11.3、值传递
所谓值传递，就是在函数调用时实参将数值传入给形参。
值传递时，如果形参发生改变，并不会影响实参。
void swap(int num1,int num2){
int temp = num1;
num1 = num2;
num2 = temp;
cout <<"交换后"<<endl;
cout<<"num1 = "<< num1 << endl;
cout<<"num2 = "<< num2 << endl;
}
11.4、函数的常见形式
无参无返 有参无返 无参无返 有参有返
11.5、函数的声明
作用：告诉编译器函数名称及如何调用函数，函数主体可以单独定义。
函数的声明可以多次，但函数的定义只能有一次。
11.6、函数的分文件编写
作用：让代码结构更加清晰。
函数分文件编写一般步骤：
1）创建后缀名为.h的头文件；
2）创建后缀名为.cpp的源文件；
3）在头文件中写函数的声明；
4）在源文件中写函数的定义。
12、指针
作用：可以通过指针间接访问内存
内存编号是从0开始记录的，一般用十六进制数字表示。
可以利用指针变量保存地址。
12.1、指针定义和使用
语法：数据类型 * 指针变量名
//定义指针
int a = 10;
int *p;
//让指针记录变量a的地址
p = &a;
使用指针：可以通过引用的方式来找到指针指向的内存。
*p; //指针前加*代表解引用，找到指针指向的内存中的数据
指针所占内存的空间：32位占用4个字节空间； 64位占用8个字节空间
12.2、空指针
空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的。
//指针变量p指向内存地址编号为0的空间
int *p = NULL;
//访问空指针报错，内存编号0-255为系统占用内存，不允许用户访问。
cout << *p << endl;
12.3、const修饰指针
const修饰指针的三种情况：
const修饰指针 ——常量指针
const修饰常量 ——指针常量
const即修饰指针，又修饰常量
常量指针特点：指针的指向可以修改，但指针指向的值不可以改。
int a = 10;
int b = 10;
const int *p = &a;
*p = 20;//错
p = &b;//对
指针常量特点：指针的指向不可以改，指针指向的值可以改。
int a = 10;
int b = 10;
int *const p = &a;
*p = 20;//对
p = &b;//错
const即修饰指针，又修饰常量：指针的指向和指针指向的值都不可以改。
技巧：看const右侧紧跟的是指针还是常量，是指针就是常量指针，是常量就是指针常量。
13、结构体
结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。
语法：
struct 结构体名{
结构体成员列表
}；
通过结构体创建变量的方式有3种：
- struct 结构体名 变量名
- struct 结构体名 变量名 = {成员1值，成员2值，...}
- 定义结构体时顺便创建变量
struct Student{
string name;
int age;
int score;
}
struct Student s1;
//给s1赋值，通过.访问结构体变量中的属性
s1.name = "张三";
s1.age = 18;
s1.score = 100;
struct Student s2 = {"李四",19,80};
struct Student{
string name;
int age;
int score;
}s3;
s3.name = "王五";
s3.age = 20;
s3.score = 60;
总结： 定义结构体时的关键字是struct，不可省略；
结构体变量利用操作符“.”访问成员。
struct和class的区别：在C++中struct和class唯一的区别在于默认的访问权限不同。struct默认权限为公有，class默认私有。
13.1、结构体数组
作用：将自定义的结构体放到数组中方便维护。
语法：struct 结构体名 数组名[元素个数] = {{},{},{},...}
struct Student{
string name;
int age;
int score;
}
//创建结构体数组
struct Student stuArr[3] = {{"刘"，22，100},{"陈"，22，100},{"池",22,100}};
13.2、结构体指针
作用：通过指针访问结构体中的成员。
利用操作符“ -> ”可以通过结构体指针访问结构体属性。
//1、创建学生结构体
struct Student s = {"liu",22,100};
//2、通过指针指向结构体
struct Student *p = &s;
//3、通过指针访问结构体变量中的数据
cout <<"姓名是："<< p->name <<endl;
13.3、结构体嵌套结构体
作用：结构体中的成员可以是另一个结构体。
//每个老师辅导一个成员，一个老师的结构体中，记录一个学生的结构体
struct Student{
string name;
int age;
int score;
};
struct Teacher{
int id;
string name;
int age;
struct Student stu;//子结构学生
}；
//创建老师
int main(){
Teacher t;
t.id = 1000;
t.name = "wu";
t.age = 40;
t.stu.name = "liu";
t.stu.age = 22;
t.stu.score = 80;
}
13.4、结构体做函数参数
作用：将结构体作为参数向函数中传递
传递方式： 值传递 地址传递
struct Student{
string name;
int age;
int score;
};
//值传递
void printStudent(student stu){
stu.age = 22;
cout<<"子函数中 年龄："<< stu.age << endl;
}
//地址传递
void printStudent2(struct Student *p){
cout<<"年龄："<< p->age <<endl;
}
void printStudent(s);//值传递
void printStudent2(&s);//地址传递
如果不想修改主函数中的数据，用值传递，反之用地址传递。
二、提高部分
1、内分区模型
C++程序在执行时，将内存大方向划分为4个区域。
代码区：存放函数体的二进制代码，由操作系统进行管理。
全局区：存放全局变量和静态变量以及常量。
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等。
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。
1.1、程序运行前
在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域：
1）代码区：存放CPU执行的机器指令。代码区是共享的，只读的。
2）全局区：存放全局变量、静态变量、常量。该区域的数据在程序结束后由操作系统释放。
1.2、程序运行后
1）栈区：由编译器自动分配释放，存放函数的参数值，局部变量等。
2）堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。
2、引用
作用：给变量起别名。
语法：数据类型 &别名 = 原名
int a = 10;
int &b = a;
b = 20;
cout << a << endl; //输出也为20
注意：1）引用必须初始化；2）引用在初始化后，不可以改变。
int a = 10;
int b = 20;
//int &c; //错误，必须初始化
int &c = a;//一旦初始化，就不可以更改
c = b；//这是赋值操作，不是更改引用
引用的本质：引用的本质在C++内部实现是一个指针常量。
2.1、引用做函数参数
作用：函数传参时，可以利用引用让形参修饰实参。
//1、值传递，形参不会修饰实参
void mySwap1(int a,int b){
int temp = a;
a = b;
b = temp;
}
//2、地址传递，形参修饰实参
void mySwap2(int *a,int *b){
int temp = *a;
*a = *b;
*b = temp;
}
//3、引用传递，形参会修饰实参
void mySwap3(int &a,int &b){
int temp = a;
a = b;
b = temp;
}
//总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更加清晰。
3、函数提高
3.1、函数默认参数
语法： 返回值类型 函数名（参数 = 默认值）{}
int func(int a, int b = 10, int c =10){
return a + b + c;
}
注意： 1）如果某个函数参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值；
2）如果函数声明有默认值，函数实现的时候就不能有默认参数。
3.2、函数重载
作用：函数名可以相同，提高复用性。
函数重载满足条件：1）同一个作用域下；2）函数名相同；3）函数参数类型不同或个数不同或顺序不同
4、封装
C++面向对象三大特性：封装、继承、多态。C++认为万事万物都皆为对象，对象上有其属性和行为。
封装的意义：1）将属性和行为作为一个整体，表现生活中的事物
2）将属性和行为加以权限控制
封装意义一：在设计类的时候，属性和行为写在一起，表现事物。
语法：class 类名{访问权限：属性/行为}；
//设计一个圆类，求圆的周长
const double PI = 3.14;
class Circle{
public: //公共权限
int m_r; //属性-半径
deouble calculatez(){
return 2 * PI * m_r; //行为-获取圆的周长
}
}；
int main(){
Circle c1; //通过圆类，创建具体的圆（对象）
c1.m_r = 10; //给圆对象的属性进行赋值
cout <<"圆的周长："<< c1.calculatez() << endl;
}
类中的属性和行为，统一称为成员。
属性：成员属性，成员变量。 行为：成员函数，成员方法。
封装意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制。
三种权限：
公共权限 public 类内可以访问 类外可以访问
保护权限 protected 类内可以访问 类外不可以访问
私有权限 private 类内可以访问 类外不可以访问
成员属性设置为私有优点：
- 将所有成员属性设置为私有，可以自己控制读写权限；
- 对于写权限，我们可以检测数据的有效性
5、构造函数和析构函数
5.1、构造函数
主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
语法：类名(){}
- 构造函数没有返回值也不写void；
- 函数名称与类名相同；
- 构造函数可以有参数，因此可以发生重载；
- 程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次。
5.2、析构函数
主要作用于对象销毁前系统自动调用，执行一些清理工作。
语法： ～类名(){}
- 析构函数没有返回值也不写void；
- 函数名称与类名相同，在名称前面加上符号～；
- 析构函数不可以有参数，因此不能发生重载；
- 程序在对象销毁前会自动调用析构函数，无须手动调用，而且只会调用一次。
class Person{
public:
Person(); //构造函数
{
cout <<"Person构造函数调用"<< endl;
}
~Person(); //析构函数
{
cout <<"Person析构函数调用" << endl;
}
}
5.3、构造函数的分类及调用
两种分类方式：
1）按参数分为：有参构造和无参构造
2）按类型分为：普通构造和拷贝构造
三种调用方式：1）括号法； 2）显示法； 3）隐式转换法
//拷贝构造函数
Person(const Person &p){
age = p.age; //将传入的人身上的所有属性拷贝到我身上
}
//调用
Person p1; //默认构造函数调用 注意：调用默认参数时，不要加（）
Person p2; //有参构造函数
Person p3; //拷贝构造函数
//显示法
Person p2 = Person(10); //有参构造
Person p3 = Person(p2); //拷贝构造 注意：不要利用拷贝构造函数，初始化匿名对象
//隐式转换法
Person p4 = 10; //相当于Person p4 = Person(10);
5.4、拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况：
- 使用一个已经创建完毕的对象来初始化一个新对象；
- 值传递的方式给函数参数传值；
- 以值方式返回局部对象。
5.5、深拷贝与浅拷贝
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作。
浅拷贝带来的问题：堆区的内存重复释放。
浅拷贝的问题要利用深拷贝进行解决:
m_Height = new int(*p.m_Height)；
总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。
5.6、初始化列表
作用：C++提供了初始化列表语法，用来初始化属性。
语法：构造函数():属性1(值1),属性2(值2)...{}
class Person{
public:
Person(int a,int b,int c){
m_a = a;
m_b = b;
m_c = c;
}
}
//初始化列表赋初值
Person():m_a(10), m_b(20), m_c(30){}
5.7、静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。
静态成员分为：
1）静态成员变量：所有对象共享同一份数据；在编译阶段分配内存；类内声明，类外初始化。
2）静态成员函数：所有对象共享同一个函数；静态成员函数只能访问静态成员变量。
5.8、const修饰成员函数
1）常函数：成员函数后加const后我们称这个函数为常函数
常函数内一般不可修改成员属性，成员函数声明时加关键字mutable后，在常函数中依然可以修改。
2）常对象：声明对象前加const称该对象为常对象。
常对象只能调用常函数。
6、友元
友元的目的是让一个函数或类访问另一个类中的私有成员。
友元的关键字：friend
友元的三种实现：1）全局函数做友元；2）类做友元；3）成员函数做友元
//1、全局函数做友元
class Building{
friend void goodGay(Buliding *buliding);
}
//2、类做友元
class Building{
friend class GoodGay; //GoodGay类是本类的好朋友，可以访问本类中私有成员
}
//3、成员函数做友元
class Building{
friend void GoodGay::visit();
...
}
7、继承
继承的好处：减少重复代码。
语法：class 子类：继承方式 父类
子类也称为派生类；父类也称为基类。
派生类的成员，包含两大部分：一类是从基类继承过来的；一类是自己增加的成员。
从基类继承过来的表现其共性，新增成员体现其个性。
7.1、继承方式
继承方式一共有3种：公共继承；保护继承；私有继承
父类所有非静态成员属性都会被子类继承下去。
7.2、继承中构造和析构顺序
子类继承父类后，当创建子类对象，也会调用父类的构造函数。
继承中构造和析构函数顺序：先构造父类，再构造子类，析构顺序与构造顺序相反。
7.3、继承同名成员处理方式
访问子类同名成员：直接访问即可。
s.m_a
访问父类同名成员：需要加作用域。
s.Base::m_a
小结：1）子类对象可以直接访问子类中同名成员；
2）子类对象加作用域可以访问到父类同名成员；
3）当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。
7.4、多继承
C++允许一个类继承多个类。
语法：class 子类：继承方式 父类1，继承方式 父类2,...
多继承可能会引发父类中有同名成员出现，需要加作用域区分。实际开发不建议使用多继承。
8、多态
多态定义: 同一种行为(调用)导致的不同的结果。
虚函数：虚函数是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。
#include <iostream>
using namespace std;
class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width = a;
height = b;
}
virtual int area()
{
cout << "Parent class area :" <<endl;
return 0;
}
};
class Rectangle: public Shape{
public:
Rectangle( int a=0, int b=0):Shape(a, b) { }
int area ()
{
cout << "Rectangle class area :" <<endl;
return (width * height);
}
};
class Triangle: public Shape{
public:
Triangle( int a=0, int b=0):Shape(a, b) { }
int area ()
{
cout << "Triangle class area :" <<endl;
return (width * height / 2);
}
};
// 程序的主函数
int main( )
{
Shape *shape;
Rectangle rec(10,7);
Triangle tri(10,5);
// 存储矩形的地址
shape = &rec;
// 调用矩形的求面积函数 area
shape->area();
// 存储三角形的地址
shape = &tri;
// 调用三角形的求面积函数 area
shape->area();
return 0;
}
多态分类：1）静态多态：函数重载和运算符重载都属于静态多态，复用函数名；
2）动态多态：派生类和虚函数实现运行多态。
静态多态和动态多态的区别：
- 静态多态的函数地址早绑定——编译阶段确定函数地址；
- 动态多态的函数地址晚绑定——运行阶段确定函数地址。
动态多态满足条件：1）有继承关系；2）子类需要重写父类虚函数
动态多态的使用：父类的指针或指引指向子类对象。
Base *base = new son;
重写：函数返回值类型 函数名 参数列表完全一致称为重写。
多态优点：1）代码组织结构清晰；
2）可读性强；
3）利于前期和后期的拓展和维护。
版权归原作者 白天数糖晚上数羊 所有， 如有侵权，请联系我们删除。