C++ 基本语法

1 C++初识

1.1 基本语法

1.1.1 注释

作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码

两种格式

1. 单行注释：// 描述信息

   • 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明

2. 多行注释： /* 描述信息 */

   • 通常放在一段代码的上方，对该段代码做整体说明

提示：编译器在编译代码时，会忽略注释的内容

1.1.2 变量

作用：给一段指定的内存空间起名，方便操作这段内存

语法：数据类型 变量名 = 初始值;

注意：C++在创建变量时，必须给变量一个初始值，否则会报错

1.1.3 常量

作用：用于记录程序中不可更改的数据

C++定义常量两种方式：

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

   • ==通常在文件上方定义==，表示一个常量

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

   • ==通常在变量定义前加关键字const==，修饰该变量为常量，不可修改

1.1.4 关键字

作用：C++中预先保留的单词（标识符）

• 在定义变量或者常量时候，不要用关键字

提示：在给变量或者常量起名称时候，不要用C++得关键字，否则会产生歧义。

1.1.5 标识符命名规则

作用：C++规定给标识符（变量、常量）命名时，有一套自己的规则

• 标识符不能是关键字

• 标识符只能由字母、数字、下划线组成

• 第一个字符必须为字母或下划线

• 标识符中字母区分大小写

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读

1.2 数据类型

C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存.

1.2.1 整型

作用：表示整数类型的数据

C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同：

****数据类型	****占用空间	取值范围
short(短整型)	2字节	(-2^15 ~ 2^15-1)
int(整型)	4字节	(-2^31 ~ 2^31-1)
long(长整形)	Windows为4字节，Linux为4字节(32位)，8字节(64位)	(-2^31 ~ 2^31-1)
long long(长长整形)	8字节	(-2^63 ~ 2^63-1)

1.2.2 sizeof关键字

作用：统计数据类型所占内存大小

语法： sizeof( 数据类型 / 变量)

整型结论：short < int ≤ long ≤ long long

1.2.3 实型（浮点型）

浮点型变量分为两种，区别在于表示的有效数字范围不同。

****数据类型	****占用空间	****有效数字范围
float	4字节	7位有效数字
double	8字节	15～16位有效数字

1.2.4 字符型

作用： 字符型变量用于显示单个字符

语法：char ch = 'a';

注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号

注意2：单引号内只能有一个字符，不可以是字符串

• C和C++中字符型变量只占用1个字节。

• 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

ASCII 码大致由以下两部分组成：

• ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。

• ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

1.2.5 转义字符

作用： 用于表示一些不能显示出来的ASCII字符

常用的转义字符有：\n换行\\反斜线\t水平制表

1.2.6 字符串型

C风格字符串： char 变量名[] = "字符串值"（要用双引号括起来）

C++风格字符串： string 变量名 = "字符串值"（需加入头文件#include<string>）

1.2.7 布尔类型 bool

作用： 布尔数据类型代表真或假的值，占1个字节

bool类型只有两个值：true — 真（本质是1）| false — 假（本质是0）

1.2.8 数据的输入

作用：用于从键盘获取数据

语法： cin >> 变量

1.3 运算符

1.3.1 算术运算符

****运算符	****术语	****运算符	****术语
+	加	%	取模(取余，针对整数变量)
-	减	++	递增
*	乘	–	递减
/	除（除数不能为0）

前置：先对变量进行++/–，再计算表达式；后置：先计算表达式，后对变量进行++/–

1.3.2 赋值运算符

****运算符	****术语	****运算符	****术语
=	赋值	*=	乘等于
+=	加等于	/=	除等于
-=	减等于	%=	模等于

1.3.3 比较运算符

****运算符	****术语	****示例	****结果
==	相等于	>	大于
!=	不等于	<=	小于等于
<	小于	>=	大于等于

注意：C和C++ 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。

1.3.4 逻辑运算符

与&& | 或|| | 非！

2 程序流程结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

• 顺序结构：程序按顺序执行，不发生跳转

• 选择结构：依据条件是否满足，有选择的执行相应功能

• 循环结构：依据条件是否满足，循环多次执行某段代码

2.1 选择结构

2.1.1 if语句

1. 单行格式if语句：if(条件){ 条件满足执行的语句 }

2. 多行格式if语句：if(条件){ 条件满足执行的语句 }else{ 条件不满足执行的语句 };

3. 多条件的if语句：if(条件1){ 条件1满足执行的语句 }else if(条件2){条件2满足执行的语句}... else{ 都不满足执行的语句}

4. 嵌套if语句

2.1.2 三目运算符

语法：表达式1 ? 表达式2 ：表达式3

如果表达式1的值为真，执行表达式2，并返回式2结果；反之，执行表达式3，并返回式3的结果。

如：(a > b ? a : b) = 100;如果a>b，比较后将a赋值为100。

三目运算符短小整洁，但如果用嵌套，结构不清晰。

2.1.3 switch语句

switch(表达式)
{
  case 结果1：执行语句;break;
  case 结果2：执行语句;break;
  ...
  default:执行语句;break;
}

优点：结构清晰，执行率高；缺点：表达式类型只能是整型或字符型，不可以判断区间。

case里如果没有break，那么程序会一直向下执行。

2.2 循环结构

2.2.1 while循环语句

语法： while(循环条件){ 循环语句 }

**解释：**只要循环条件的结果为真，就执行循环语句。程序必须提供跳出循环的出口，否则出现死循环。

2.2.2 do…while循环语句

语法： do{ 循环语句 } while(循环条件);

注意： do…while先执行一次循环语句，再判断循环条件。

2.2.3 for循环语句

语法： for(起始表达式;条件表达式;末尾循环体) { 循环语句; }

起始表达式 → 条件表达式 → 循环语句 → 末尾循环体

2.3 跳转语句

2.3.1 break语句

出现在switch条件语句 / 循环语句 / 嵌套循环中，跳出选择结构或者循环结构

2.3.2 continue语句

在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

2.3.3 goto语句

语法： goto 标记; 标记: 语句;

解释： 如果标记的名称存在，执行到goto语句时，无条件跳转到标记的位置

注意：在程序中不建议使用goto语句，以免造成程序流程混乱

3 数组

3.1 概述

1. 数组中的每个数据元素都是相同的数据类型

2. 数组是由连续内存位置组成的

3.2 一维数组

1. 数据类型 数组名[ 数组长度 ];

2. 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...}; // 如果初始时未完全赋值，将自动将其赋0值。

3. 数据类型 数组名[ ] = { 值1，值2 ...};

4. 通过下标访问数组元素：数组名[下标] // 从0开始索引。

5. 通过sizeof(arr)获取整个数组占内存空间的大小，数组元素个数为int len = sizeof(arr) / sizeof(arr[0]);。

6. 直接打印数组(int)arr获取数组在内存中的首地址，首个元素地址为(int)&arr[0]。

3.3 冒泡排序

作用： 最常用的排序算法，对数组内元素进行排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。

3. 重复以上的步骤，每次比较次数-1，直到不需要比较

3.4 二维数组

1. 数据类型 数组名[ 行数 ][ 列数 ];

2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1, 数据2}, {数据3, 数据4} };

3. 数据类型 数组名[ 行数 ][ 列数 ] = {数据1, 数据2, 数据3, 数据4};

4. 数据类型 数组名[ ][ 列数 ] = {数据1, 数据2, 数据3, 数据4};

   在定义二维数组时，如果初始化了数据，可以省略行数。

5. 查看整个二维数组所占内存空间大小：sizeof(数组名)；第一行占用空间：sizeof(数组名[0])；第一个元素占用的空间：sizeof(数组名[0][0])。

6. 查看首地址：(int)arr；首行地址：(int)arr[0]；首元素地址：(int)&arr[0][0]。

4 函数

4.1 定义

返回值类型 函数名 (参数列表)
{
    函数体语句
    return 表达式
}

4.2 调用

语法： 函数名（参数）

4.3 值传递

• 值传递：函数调用时实参将数值传入给形参

• 值传递时，如果形参发生改变，并不会影响实参。

4.4 声明

作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

• 函数的声明可以多次，但是定义只能有一次。

• 在main函数前写int max(int a, int b);，这样就可以把函数定义写在main后。

4.5 函数的分文件编写

1. 创建后缀名为.h的头文件

2. 创建后缀名为.cpp的源文件

3. 在.h头文件中写函数的声明

4. 在.cpp源文件中写函数的定义

5. 在main源文件中写#include "xxx.h"

5 指针

5.1 基本概念

指针的作用： 间接访问内存

语法： 数据类型* 变量名; 如：int* p = &a;

• 普通变量存放的是数据，指针变量存放的是地址。

• 指针变量通过&a获取变量的地址，通过*p操作指针变量指向的内存中的数据（解引用）。

所占内存空间：4个字节（32位操作系统）| 8个字节（64位操作系统）

5.2 空指针和野指针

空指针：int* p = NULL;用于初始化指针变量，指向内存中编号为0的空间，内存编号0~255为系统占用内存，不允许用户访问。

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

5.3 const修饰指针

1. const修饰指针 — 常量指针（指针的指向（地址）可以修改，但指针指向的值（内容只读）不可修改）

   const int* p = &a;
   // *p = 20; // 错误
   p = &b;  // 正确
   

2. const修饰常量 — 指针常量（指针指向（地址）不可修改，但指针指向的值可以修改）

   int* const p = &a;
   *p = 20; // 正确
   // p = &b;  // 错误
   

3. const即修饰指针，又修饰常量（指针指向和指针指向的值都不可更改）

   const int* const p = &a;
   // *p = 20; // 错误
   // p = &b;  // 错误
   

5.4 指针和数组

作用： 利用指针访问数组中元素

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
for (int i = 1; i <= 10; i++) {
  cout << "指针访问第" << i << "个元素: " << *p << endl;
  p++;}

5.5 指针和函数

作用： 利用指针（地址传递）作函数参数，可以修改实参的值。

void BubbleSort(int* arr, int len) {
  for (int i = 0; i < len - 1; i++) {
    for (int j = 0; j < len - i -1; j++) {
      if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;}}}}

6 结构体

6.1 结构体定义和使用

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。

语法：struct 结构体名 { 结构体成员列表 };

通过结构体创建变量的方式有三种：

• struct 结构体名 变量名

• struct 结构体名 变量名 = { 成员1值 ， 成员2值...}

• 定义结构体时顺便创建变量struct 结构体名 { 结构体成员列表 }s3;

6.2 结构体数组

作用： 将自定义的结构体放入到数组中方便维护

语法：struct 结构体名 数组名[元素个数] = { {} , {} , ..., {} }

6.3 结构体指针

作用： 利用操作符 -> 可以通过结构体指针访问结构体中成员属性。

  Student* p = &s;
  cout << p->name << " " << p->age << " " << p->score << endl;

6.4 结构体中const使用场景

值传递把数据拷贝一份进行操作，占用内存，可以用地址传递，但担心对原数据进行修改，可以用const来防止误操作

void printInfo(const student* p) {
  //p->age = 10;
  cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;}

7 内存分区模型

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

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

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

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

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

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

7.1 程序运行前

​在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域：

1. ​**代码区：**存放 CPU 执行的机器指令

   • 共享 — 对于频繁被执行的程序，只需要在内存中有一份代码即可；

   • ​只读 — 防止程序意外地修改了它的指令；

2. ​**全局区：**存放全局变量、静态变量和常量（const修饰的全局常量和字符串常量）

   • 该区域的数据在程序结束后由操作系统释放；

7.2 程序运行后

1. ​栈区：由编译器自动分配释放, 存放函数的参数值，局部变量等。

   • 不要返回局部变量地址，栈区开辟的数据由编译器自动释放（函数执行完成后）

2. **堆区：**由程序员分配（利用new开辟）/ 释放，若程序员不释放，程序结束时由操作系统回收。

   int* func() {
     // 利用new关键字将数据开辟在堆区
     // 指针本质也是局部变量，放在栈上，指针保存的数据放在堆区
     int* a = new int(10);
     return a;}
   

   1. 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete a;（释放数组应使用delete[] arr）；

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

8 引用

8.1 引用的基本使用

作用： 给变量起别名

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

8.2 引用注意事项

1. 引用必须初始化；

2. 引用在初始化后，不可以改变；

     int a = 100;
     int& b = a;
   
     int c = 20;
     b = c; // 赋值操作，b仍是a的别名
   
     cout << "a=" << a << endl;  // 20
     cout << "b=" << b << endl;  // 20
   

8.3 引用做函数参数

作用： 函数传参时，可以利用引用让形参修饰实参，效果同按地址传递。

// 引用传递
void swap3(int& a, int& b) {
  int temp = a;
  a = b;
  b = temp;
}

8.4 引用做函数返回值

作用：引用是可以作为函数的返回值存在的，但不要返回局部变量的引用（函数使用完毕后内存会被释放）

用法：函数调用作为左值；

int& test01() {
  static int a = 10;
  return a;}
int main() {
  int& ref = test01();  // ref为a的别名
  cout << ref << endl;
  cout << ref << endl;
  test01() = 1000;  // a赋值为1000
  cout << ref << endl;
  cout << ref << endl;}

8.5 引用的本质

本质：在c++内部实现是一个指针常量。

//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
    ref = 100; // ref是引用，转换为*ref = 100}
int main(){
    int a = 10;
    int& ref = a; //自动转换为 int* const ref = &a; 指针常量
    ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20; 
    cout << "a:" << a << endl;
    cout << "ref:" << ref << endl;    
    func(a);
    return 0;}

8.6 常量引用

作用： 常量引用主要用来修饰形参，防止误操作

1. const int& ref = 10; // 编译器： int temp = 10; const int & ref = temp; // 引用必须引一块合法的内存空间

2. void showData(const int& a) {cout << a << endl;}

9 函数

9.1 默认参数与占位参数

默认参数： 返回值类型 函数名 （参数= 默认值）{}

1. 如果某个位置有默认参数，那么该位置之后都必须有默认参数。

2. 如果函数声明有默认参数，函数实现就不能有默认参数，只能出现在一处。

占位参数： 返回值类型 函数名 (数据类型){}

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置。

9.2 函数重载

9.2.1 函数重载概述

作用： 函数名可以相同，提高复用性

函数重载满足条件：

• 函数名称相同、位于同一个作用域

• 函数参数类型/个数/顺序不同

注意: 函数的返回值不可以作为函数重载的条件

9.2.2 函数重载注意事项

• 引用作为重载条件；

void func(int &a) {
  cout << "this is func(int &a)!" << endl;}
void func(const int& a) {
  cout << "this is func(const int& a)!" << endl;}
int main() {
  int a = 10;
  func(a);  // this is func(int &a)!
  func(10);  // this is func(const int& a)!
}

• 函数重载碰到函数默认参数（此时尽量不使用默认参数避免造成混淆）；

10 类和对象

C++面向对象的三大特性为：封装、继承、多态；C++认为万事万物都皆为对象，对象上有其属性和行为

10.1 封装

语法： class 类名{ 访问权限： 属性 / 行为 };

访问权限：public（公共权限 - 类内类外都可访问）/ protected（保护权限 - 类外不可访问）/ private（私有权限 - 类外不可访问）

10.1.1 struct和class区别

C++中 struct和class唯一区别为默认访问权限不同：struct 默认权限为public，class默认权限为private。

10.1.2 成员属性设置为私有

1. 将所有成员属性设置为私有，使用公有方法控制读写权限；

2. 对于写权限，可以检测数据的有效性；

10.2 对象的初始化和清理

10.2.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题：

• ​一个对象或者变量没有初始状态，对其使用后果是未知；

• ​同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题；

C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。如果我们不提供构造和析构，编译器提供空实现的构造函数和析构函数。

• 构造函数：创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

• 析构函数：对象销毁前系统自动调用，执行一些清理工作。

构造函数：类名(){}

1. 构造函数没有返回值也不写void；

2. 函数名称与类名相同；

3. 构造函数可以有参数，因此可以发生重载；

4. 程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次；

析构函数： ~类名(){}

1. 析构函数没有返回值也不写void；

2. 函数名称与类名相同，在名称前加上符号~；

3. 析构函数不可以有参数，因此不可以发生重载；

4. 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次。

10.2.2 构造函数的分类及调用

两种分类方式：

1. ​按参数分为： 有参构造和无参构造（默认构造）

2. ​按类型分为： 普通构造和拷贝构造Person(const Person &p) {}

使用默认构造函数时不要加()，Person p1(); 会被认为是函数声明；

三种调用方式：括号法 / 显示法Person p2 = Person(p1); / 隐式转换法Person p2 = 10;

1. 单独的Person(10);为匿名对象，当前行执行结束后，系统会立即回收。

2. 不要利用拷贝构造函数来初始化匿名对象，编译器认为Person (p3) 等价于 Person p3;

10.2.3 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况：

1. 使用一个已经创建完毕的对象来初始化一个新对象

2. 值传递的方式给函数参数传值

3. 以值方式返回局部对象

10.2.4 构造函数调用规则

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

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造；

• 如果用户定义拷贝构造函数，c++不会再提供其他构造函数；

10.2.5 深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作（如拷贝构造）；

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

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

class Person {
public:
  Person(int age, int height) {
    m_Age = age;
    m_Height = new int(height);
    cout << "有参构造" << endl;}
  Person(const Person &p) {
    cout << "拷贝构造" << endl;
    m_Age = p.m_Age;
    m_Height = new int(*p.m_Height);}
  int m_Age;
  int* m_Height;};

10.2.6 初始化列表

语法：构造函数():属性1(值1),属性2（值2）... {}

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

10.2.7 类对象作为类成员

B类中有对象A作为成员，先构造对象成员A，后构造B。析构时先析构B，后析构A。

10.2.8 静态成员

在成员变量和成员函数前加上关键字static，称为静态成员，可分为静态成员变量和静态成员函数。

静态成员变量：

• 所有对象共享同一份数据；

• 在编译阶段分配内存（运行exe前就已存在）；

• 类内声明，类外初始化；

  class Person {public: static int m_A;};

  int Person::m_A = 100;

• 访问（public作用域下）：通过对象p.m_A / 类名Person::m_A进行访问；

静态成员函数：

• 所有对象共享同一个函数；

• 静态成员函数只能访问静态成员变量，不可以访问非静态成员变量（无法区分到底是哪个对象的）；

• 访问（public作用域下）：通过对象p.func / 类名Person::func进行访问；

10.3 C++对象模型和this指针

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

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

• 非静态成员函数和静态成员函数/变量不属于类对象上。

10.3.2 this指针概念

每一个非静态成员函数只会诞生一份函数实例，如何区分哪个对象调用自己？

c++通过提供特殊的对象指针 — this指针解决上述问题。

this指针是隐含每一个非静态成员函数内的一种指针，指向被调用的成员函数所属的对象，不需要定义，直接使用即可。

this指针的用途：

• 当形参和成员变量同名时，可用this指针来区分；

• 在类的非静态成员函数中返回对象本身，可使用return *this；

  Person &  PersonAddAge(Person& p) {
    this->age += p.age;
    return *this;}

10.3.3 空指针访问成员函数

C++中空指针可以调用成员函数，但要注意是否用到this指针；如有，需要加以判断保证代码的健壮性。

10.3.4 const修饰成员函数

class Person {
public:
  // this指针本质为Person* const this，指向不可修改 
  // 此时this为指针常量const Person* const this，指针指向的值不可修改 
  void showPerson() const{
    // this->m_A = 110;
    this->m_B = 110;}
  int m_A;
  mutable int m_B;};

常函数（成员函数后加const）：

• 常函数内不可以修改成员属性；

• 成员属性声明时加关键字mutable后，在常函数中依然可以修改；

常对象（声明对象前加const）：

• 常对象只能调用常函数，不能调用普通成员函数；

• 成员属性声明时加关键字mutable后在常对象下可以修改；

10.4 友元

友元（friend）：让一个函数或者类访问另一个类中私有成员

三种实现（在要访问的类中添加…）：

• 全局函数做友元：friend void goodGay(Building* building);

• 类做友元：friend class GoodGay;

• 成员函数做友元

10.5 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

10.5.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

• 对于内置的数据类型的表达式的的运算符是不可能改变的

• 不要滥用运算符重载

10.5.2 左移运算符重载

作用：可以输出自定义数据类型

ostream& operator<<(ostream &cout, Person &p) {
  // cout只能有一个 -- 引用传递
  cout << "m_A = " << p.m_A << " m_B = " << p.m_B << endl;
  return cout;}

重载左移运算符配合友元可以实现输出自定义数据类型：friend ostream& operator<<(ostream& cout, Person& p);

10.5.3 递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据

总结： 前置递增返回引用，后置递增返回值

10.5.4 赋值运算符重载

c++编译器至少给一个类添加4个函数

1. 默认构造函数(无参，函数体为空)

2. 默认析构函数(无参，函数体为空)

3. 默认拷贝构造函数，对属性进行值拷贝

4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题。

10.5.5 关系运算符重载

作用： 重载关系运算符，可以让两个自定义类型对象进行对比操作

10.5.6 函数调用运算符重载

• 函数调用运算符 () 也可以重载

• 由于重载后使用的方式非常像函数的调用，因此称为仿函数

• 仿函数没有固定写法，非常灵活

10.6 继承

定义某些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。此时，可以考虑利用继承的技术，减少重复代码。

10.6.1 继承的基本语法

class 子类（派生类） : public 父类（基类）;

派生类中的成员，包含两大部分：一类是从基类继承过来的，一类是自己增加的成员。从基类继承过过来的表现其共性，而新增的成员体现了其个性。

10.6.2 继承方式

• 公共继承class SonClass : public FatherClass
• 保护继承class SonClass : protected FatherClass
• 私有继承class SonClass : private FatherClass

10.6.3 继承中的对象模型

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

10.6.4 继承中构造和析构顺序

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

10.6.5 继承同名成员处理方式

子类与父类出现同名的成员时：

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

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

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

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

• 访问子类同名成员 — 直接访问即可
• 访问父类同名成员 — 加作用域Son::Father::m_A|Father::m_A

子类出现和父类同名静态成员函数时，隐藏父类中所有同名成员函数（包括重载），需加作用域进行访问。

10.6.7 多继承语法

C++允许类继承多个类：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

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

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

10.6.8 菱形继承

两个派生类继承同一个基类，又有某个类同时继承者两个派生类，这种继承被称为菱形继承或钻石继承。

• 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费；
• 利用虚继承可以解决菱形继承问题，vbptr虚基类指针指向vbtable指向虚基类表，表中指明偏移量，指针加偏移量就可以找到m_Age。

10.7 多态

10.7.1 多态的基本概念

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

• 静态多态: 函数重载和运算符重载属于静态多态，复用函数名（地址早绑定 - 编译阶段）
• 动态多态: 派生类和虚函数实现运行时多态（地址晚绑定 - 运行阶段）

多态满足条件：

1. 有继承关系
2. 子类重写父类中的虚函数（函数返回值类型、函数名和参数列表完全一致）

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

#include<iostream>
using namespace std;

class Animal {
public:
  virtual void speak() {
    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 test01() {
  Cat cat;
  doSpeak(cat); // output: Animal Speak | 改为虚函数后，Cat Speak
  Dog dog;
  doSpeak(dog);
}

int main() {
  test01();
  return 0;
}

class Animal    size(4):
        +---
 0      | {vfptr}
        +---

Animal::$vftable@:
        | &Animal_meta
        |  0
 0      | &Animal::speak

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

10.7.2 纯虚函数和抽象类

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

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

类中存在纯虚函数时，可称为抽象类：

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

实例化对象：Base* base = new Son;或Son base;

10.7.3 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针（Animal* animal = new Cat("Tom");）在释放时无法调用子类的析构代码。

虚析构和纯虚析构共性：

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

虚析构：

virtual ~类名(){}

纯虚析构（此时该类属于抽象类，无法实例化对象）：

virtual ~类名() = 0;

类名::~类名(){}

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

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

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

11 文件操作

通过文件可以将程序运行产生的数据持久化，C++中对文件操作需要包含头文件fstream（读写）/ ofstream（写）/ ifstream（读）。

文件类型分为两种：

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

11.1 文本文件

11.1.1 写文件

void test01() {
  // 1. 包含头文件 #include<fstream>
  // 2. 创建流对象
  ofstream ofs;
  // 3. 指定打开方式：ofs.open("文件路径", 打开方式);
  ofs.open("test.txt", ios::out);
  // 4. 写内容
  ofs << "hello world!" << endl;
  ofs << "2024-06-29" << endl;
  // 5. **关闭文件**
  ofs.**close**();}

文件打开方式：

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

注意： 多个文件打开方式可使用|操作符，如用二进制方式写文件ios::binary|ios:: out。

11.1.2 读文件

void test02() {
  // 1. 包含头文件
  // 2. 创建流对象
  ifstream ifs;
  // 3. 打开文件，并判断是否打开成功
  ifs.open("test.txt", ios::in);
  if (!ifs.is_open()) {
    cout << "文件打开失败！" << endl;
    return;
  }
  // 4. 读数据
  // (1). 会把空格读为换行
  //char buffer[1024] = { 0 };
  //while (ifs >> buffer) {
  //  cout << buffer << endl;}
  // (2)
  //char buf[1024] = { 0 };
  //while (ifs.getline(buf, sizeof(buf))) {
  //  cout << buf << endl;}
  // (3)
  //string buf;
  //while (getline(ifs, buf)) {
  //  cout << buf << endl;}
  // (4). 不推荐使用
  char c;
  while ((c = ifs.get()) != EOF) {  // EOF - end of file
    cout << c;}
  // 5. 关闭文件
  ifs.close();}

11.2 二进制文件

以二进制的方式对文件进行读写操作时，打开方式要指定为ios::binary。

11.2.1 写文件

二进制方式写文件主要利用流对象调用成员函数ostream& write(const char * buffer,int len);，字符指针buffer指向内存中一段存储空间，len是读写的字节数。

void test01() {
  // 1. 包含头文件
  // 2. 创建流对象
  // 3. 打开文件
  ofstream ofs("person.txt", ios::out | ios::binary);
  // 4. 写文件
  Person p = { "张三", 18 };  // 类的列表初始化
  ofs.write((const char*)&p, sizeof(Person));
  // 5. 关闭文件
  ofs.close();}

11.2.2 读文件

二进制方式读文件主要利用流对象调用成员函数istream& read(char *buffer,int len);，字符指针buffer指向内存中一段存储空间，len是读写的字节数。

void test02() {
  // 1. 包含头文件
  // 2. 创建流对象
  ifstream ifs;
  // 3. 打开文件
  ifs.open("person.txt", ios::out | ios::binary);
  if (!ifs.is_open()) {
    cout << "文件打开失败" << endl;
    return;}
  // 4. 写文件
  Person p;
  ifs.read((char*)&p, sizeof(Person));
  cout << "Name = " << p.m_Name << " Age = " << p.m_Age << endl;
  // 5. 关闭文件
  ifs.close();}