C++期末复习超详细总结知识点（期末冲刺）

Posted 2021-06-22 生命是有光的

0.简介

1. 重点已经用黑体和高亮表示，属于记忆理解部分
2. 学校考试一般比较简单，更多在于概念和语法的考察，包括一些细节知识点在选择判断等。
3. 是根据老师的PPT与自己所学进行总结的，基本不涉及偏难怪知识点，重点是为了期末考试。
4. 全文长6400多字，基本可以囊括90%的考试知识点
5. 个人感觉知识掌握了就是多做做往年习题，毕竟考试偏应试，想提高分请一定多做题！！！！
6. 想打印的伙伴可以下方留言邮箱，看到会发pdf打印版。
7. 考试加油！！！！

1、数据类型

1.1、整型

作用：整型变量表示的是整数类型的数据

1.2、sizeof关键字

作用：利用sizeof关键字可以统计数据类型所占内存大小

1.3、浮点型

作用：用于表示小数

浮点型变量分为两种：

1. 单精度float
2. 双精度double

1.4、字符型

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

语法：char ch = 'a';

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

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

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

• 字符常量只能包括一个字符，如′AB′ 是不合法的

• 字符常量区分大小写字母，如′A′和′a′是两个不同的字符常量

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

1.5、字符串型

作用：用于表示一串字符

两种风格

1. C风格字符串： char 变量名[] = "字符串值"

char str1[] = "hello world";

注意：C风格的字符串要用双引号括起来

2. C++风格字符串： string 变量名 = "字符串值"

string str = "hello world";

注意：C++风格字符串，需要加入头文件==#include<string>==

---

常考：字符串 "abc" 在内存中占几个字节？

答：占4个字节，而不是3个字节，编译系统会在字符串最后自动加一个′＼0′作为字符串结束标志。但′＼0′并不是字符串的一部分，它只作为字符串的结束标志

---

常考: 字符串常量″abc＼n″包含几个字符?

答：不是5个而是4个字符，其中“＼n”是一个转义字符,但它在内存中占5个字节

1.6、布尔类型bool

作用：布尔数据类型代表真或假的值

bool类型只有两个值：

• true — 真（本质是1）
• false — 假（本质是0）

bool类型占1个字节大小

1.7、数据的输入

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

关键字：cin

语法： cin >> 变量

1.8、数据的输出

语法：cout<<" hello world "<<endl;

2、运算符

2.1、算数运算符

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10 + 5	15
-	减	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 5	2
%	取模(取余)	10 % 3	1
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
–	前置递减	a=2; b=–a;	a=1; b=1;
–	后置递减	a=2; b=a–;	a=1; b=2;

注意：

• 两个整数相除结果依然是整数（这里不进行四舍五入，直接舍去小数点后面数字）
• C++中两个小数可以相除
• 只有整型变量可以进行取模运算，两个小数不可以取模
• 在除法运算中，除数不能为0
• 取模运算时，除数也不能为0

常考：

• 前置后置运算符单独使用没有什么区别

• 前置递增先对变量进行++，再计算表达式

• 后置递增先计算表达式，后对变量进行++

• 请详细看下方代码并理解

//递增
int main() {

	//后置递增
	int a = 10;
	a++; //等价于a = a + 1
	cout << a << endl; // 11

	//前置递增
	int b = 10;
	++b;
	cout << b << endl; // 11

	//区别
	//前置递增先对变量进行++，再计算表达式
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << b2 << endl; //110

	//后置递增先计算表达式，后对变量进行++
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << b3 << endl; //100

	system("pause");

	return 0;
}

2.2、赋值运算符

作用：用于将表达式的值赋给变量

• 请详细看表格即可

运算符	术语	示例	结果
=	赋值	a=2; b=3;	a=2; b=3;
+=	加等于	a=0; a+=2;	a=2;
-=	减等于	a=5; a-=3;	a=2;
*=	乘等于	a=2; a*=2;	a=4;
/=	除等于	a=4; a/=2;	a=2;
%=	模等于	a=3; a%2;	a=1;

2.3、比较运算符

作用：用于表达式的比较，并返回一个真值或假值

• 请详细看表格即可

运算符	术语	示例	结果
==	相等于	4 == 3	0
!=	不等于	4 != 3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
<=	小于等于	4 <= 3	0
>=	大于等于	4 >= 1	1

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

2.4、逻辑运算符

作用：用于根据表达式的值返回真值或假值

• 请详细看表格即可

运算符	术语	示例	结果
!	非	!a	如果a为假，则!a为真； 如果a为真，则!a为假。
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
||	或	a || b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

3、流程结构

3.1、选择结构

3.1.1、if语句

• if语句较为简单，常常搭配else使用，且可以嵌套使用

3.1.2、三目运算符

作用： 通过三目运算符实现简单的判断

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

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

如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

• 此处常出程序阅读题！！！！

3.1.3、switch语句

作用：执行多条件分支语句

语法：

switch(表达式)

{

	case 结果1：执行语句;break;

	case 结果2：执行语句;break;

	...

	default:执行语句;break;

}

• switch语句中表达式类型只能是整型或者字符型
• case里如果没有break，那么程序会一直向下执行

3.2、循环结构

3.2.1、while

作用：满足循环条件，执行循环语句

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

解释：只要循环条件的结果为真，就执行循环语句

3.2.2、do…while

作用 ：满足循环条件，执行循环语句

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

注意：与while的区别在于do…while会先执行一次循环语句，再判断循环条件（这里常考两者区别，记住无论怎样，do…while都会必然执行一次循环语句）

3.2.3、for

• for循环中的表达式，要用分号进行分隔

int main() {

	for (int i = 0; i < 10; i++)
	{
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

3.3、跳转语句

3.3.1、break

作用: 用于跳出选择结构或者循环结构

3.3.2、continue

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

注意：continue并没有使整个循环终止，而break会跳出循环

4、数组

数组：所谓数组，就是一个集合，存放相同类型的数据元素

• 数组中的每个数据元素都是相同的数据类型
• 数组是由连续的内存位置组成的

4.1、一维数组

一维数组定义的三种方式：

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

int score[10];
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };

• 数组中下标是从0开始索引

• 在对全部数组元素赋初值时，可以不指定数组长度

• 直接打印数组名，可以查看数组所占内存的首地址

• 对数组名进行sizeof，可以获取整个数组占内存空间的大小

• 以上三种方式并不要求都会，但是需要都见过，防止在程序改错中乱改

4.2、二维数组

二维数组定义的四种方式：

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

int arr[2][3];

int arr2[2][3] =
{
    {1,2,3},
    {4,5,6}
};

int arr3[2][3] = { 1,2,3,4,5,6 }; 

int arr4[][3] = { 1,2,3,4,5,6 };

• 以上4种定义方式，利用第二种更加直观，提高代码的可读性
• 如果对全部元素赋初值，定义数组时对第一维的长度可以不指定，但是第二维的长度不能省略

5、函数

作用：将一段经常使用的代码封装起来，减少重复代码

5.1、函数定义

函数的定义一般主要有5个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

返回值类型 函数名 （参数列表）
{

       函数体语句

       return表达式

}

• 返回值类型 ：一个函数可以返回一个值。在函数定义中
• 函数名：给函数起个名称
• 参数列表：使用该函数时，传入的数据
• 函数体语句：花括号内的代码，函数内需要执行的语句
• return表达式： 和返回值类型挂钩，函数执行完后，返回相应的数据

示例：定义一个加法函数，实现两个数相加

//函数定义
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

5.2、函数调用

**功能：**使用定义好的函数

语法：函数名（参数）

int result = add(10,20);

• 函数定义里小括号内称为形参，函数调用时传入的参数称为实参

• 例如此处的num1,num2 为形参，10,20为实参

5.3、函数声明

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

//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

int main() {

	int a = 100;
	int b = 200;

	cout << max(a, b) << endl;

	system("pause");

	return 0;
}

5.4、值传递

• 所谓值传递，就是函数调用时实参将数值传入给形参
• 值传递时，如果形参发生改变，并不会影响实参（值传递时，形参是修饰不了实参的），请务必理解并记住，此处因篇幅就不进行讲解了！

5.5、函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。

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

int func(int a, int b = 10, int c = 10) {
	return a + b + c;
}

//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
	return a + b;
}

int main() {

	cout << "ret = " << func(20, 20) << endl;
	cout << "ret = " << func(100) << endl;

	system("pause");

	return 0;
}

• 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
• 如果函数声明有默认值，函数实现的时候就不能有默认参数

5.6、函数占位参数

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

语法： 返回值类型 函数名 (数据类型){}

//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
	cout << "this is func" << endl;
}
int main() {

	func(10,10); //占位参数必须填补

	system("pause");

	return 0;
}

5.7、函数重载

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

函数重载满足条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同 或者 个数不同 或者 顺序不同

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

//函数重载需要函数都在同一个作用域下
void func()
{
	cout << "func 的调用！" << endl;
}
void func(int a)
{
	cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
	cout << "func (double a)的调用！" << endl;
}
void func(int a ,double b)
{
	cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a ,int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
}

//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
//	cout << "func (double a ,int b)的调用！" << endl;
//}


int main() {

	func();
	func(10);
	func(3.14);
	func(10,3.14);
	func(3.14 , 10);
	
	system("pause");

	return 0;
}

6、指针

指针的作用： 可以通过指针间接访问内存

6.1、指针变量

指针变量定义语法： 数据类型 * 变量名；

• 请看下方代码示例，理解指针变量的定义与使用，期末一般不会出太难指针的题，但是基本用法一定要会！！

int main() {

	//1、指针的定义
	int a = 10; //定义整型变量a
	
	//指针定义语法： 数据类型 * 变量名 ;
	int * p;

	//指针变量赋值
	p = &a; //指针指向变量a的地址
	cout << &a << endl; //打印数据a的地址
	cout << p << endl;  //打印指针变量p
    //0073F8BC
    //0073F8BC

	//2、指针的使用
	//通过*操作指针变量指向的内存
	cout << "*p = " << *p << endl;
    // *p = 10

	system("pause");

	return 0;
}

指针变量和普通变量的区别

• 普通变量存放的是数据,指针变量存放的是地址
• 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结1： 我们可以通过 & 符号 获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

总结4：所有指针类型在32位操作系统下是4个字节（了解）

6.2、const修饰指针

const修饰指针有三种情况

1. const修饰指针 — 常量指针
2. const修饰常量 — 指针常量
3. const既修饰指针，又修饰常量

int main() {

	int a = 10;
	int b = 10;

	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错
	

	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");

	return 0;
}    

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

6.3、指针和数组

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

• C++规定，数组名就是数组的起始地址
• 数组的指针就是数组的起始地址

int main() {

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

	int * p = arr;  //指向数组的指针

	cout << "第一个元素： " << arr[0] << endl; 		//1
	cout << "指针访问第一个元素： " << *p << endl;	  //1

	for (int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}

	system("pause");

	return 0;
}

6.4、指针和函数

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

//值传递
void swap1(int a ,int b)
{
	int temp = a;
	a = b; 
	b = temp;
}
//地址传递
void swap2(int * p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {

	int a = 10;
	int b = 20;
	swap1(a, b); // 值传递不会改变实参

	swap2(&a, &b); //地址传递会改变实参

	cout << "a = " << a << endl;

	cout << "b = " << b << endl;

	system("pause");

	return 0;
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

7、引用

作用： 给变量起别名

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

int main() {

	int a = 10;
	int &b = a;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
    // 10
    // 10

	b = 100;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
    // 100
    // 100

	system("pause");

	return 0;
}

7.1、引用注意事项

• 引用必须初始化

  int &c; // 错误，引用必须初始化
  

• 在声明一个引用后，不能再使之作为另一变量的引用

7.2、引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

• 通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

//1. 值传递
void mySwap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}

//2. 地址传递
void mySwap02(int* a, int* b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}
//参数：把地址传进去，用指针接收

//3. 引用传递
void mySwap03(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
//参数：别名，下面的a是上面的a的别名，用别名操作修改可原名操作修改是一样的
int main() {

	int a = 10;
	int b = 20;
    // 值传递，形参不会修饰实参
	mySwap01(a, b);
	cout << "a:" << a << " b:" << b << endl;
    // a:10 b:20

    // 地址传递，形参会修饰实参
	mySwap02(&a, &b);
	cout << "a:" << a << " b:" << b << endl;
    // a:20 b:10

    // 引用传递，形参会修饰实参
	mySwap03(a, b);
	cout << "a:" << a << " b:" << b << endl;
    // a:10 b:20

	system("pause");

	return 0;
}

7.3、引用做函数返回值

作用：引用是可以作为函数的返回值存在的

//数据类型后加&，相当于用引用的方式返回 
int& test02() {
    // 必须使用静态变量,需加 static 关键字
	static int a = 20;
	return a;
}


int main(){
    int& ref2 = test02();
    system("pause");
    return 0;
}

8、类和对象

8.1、struct和class区别

在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：

• struct 默认权限为公共
• class 默认权限为私有

8.1、构造函数和析构函数

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

---

构造函数语法：类名(){}（构造和析构很容易出选择题，特点要记住）

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

---

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

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

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

void test01()
{
	Person p; //在栈上的数据，test01()执行完毕后，释放这个对象
}

int main() {
	
	test01();

	system("pause");

	return 0;
}

8.3、构造函数分类与调用

构造函数按参数分为： 有参构造和无参构造

调用方式：括号法

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
    //析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	// 括号法，常用
	Person p1(10);
}

• 尽管在一个类中可以包含多个构造函数，但是对于每一个对象来说，建立对象时只执行其中一个构造函数，并非每个构造函数都被执行

8.4、初始化列表

• 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(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {

	Person p(1, 2, 3);
	p.PrintPerson();


	system("pause");

	return 0;
}

8.5、类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

例如：

class A {}
class B
{
    A a；
}

• B类中有对象A作为成员，A为对象成员
• 那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？
  • 先调用对象成员的构造，再调用本类构造(如上例中，先调用A的构造函数)
  • 析构顺序与构造相反

8.6、静态成员

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

静态成员分为：

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

8.7、const修饰成员函数

常函数：

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性

常对象：

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

8.8、const型数据小结

形式	含义
Time const t1	t1 是常对象，其值在任何情况下都不能改变
void Time：：fun() const	fun 是 Time类中的常成员函数，可以引用，但不能修改本类中的数据成员
Time * const p	p 是指向Time对象的常指针，P的值不能改变
const Time *p	p是指向 Time 类常对象的指针，其指向的类对象的值不能通过指针来改变
Time &t1 = t；	t1是Time类对象t的引用，二者指向同一段内存空间

9、继承

继承的好处：可以减少重复的代码

继承的语法：class 子类 : 继承方式 父类

class A : public B;

A 类称为子类 或 派生类

B 类称为父类 或 基类

9.1、继承方式

继承方式一共有三种：

• 公共继承
• 保护继承
• 私有继承

简单的说：

• 公共继承：基类的公用成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类私有。
• 私有继承：基类的公用成员和保护成员在派生类中成了私有成员。其私有成员仍为基类私有
• 保护继承：基类的公用成员和保护成员在派生类中成了保护成员，其私有成员仍为基类私有。

9.2、继承中构造和析构顺序

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

• C++允许一个类继承多个类

10、多态

多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数

多态分为两类

• 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
• 动态多态: 派生类和虚函数实现运行时多态

class Animal
{
public:
	//Speak函数就是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog :public Animal
{
public:

	void speak()
	{
		cout << "小狗在说话" << endl;
	}

};
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编

void DoSpeak(Animal & animal)
{
	animal.speak();
}
//
//多态满足条件： 
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用：
//父类指针或引用指向子类对象

void test01()
{
	Cat cat;
	DoSpeak(cat);


	Dog dog;
	DoSpeak(dog);
}


int main() {

	test01();

	system("pause");

	return 0;
}

多态满足条件

• 有继承关系
• 子类重写父类中的虚函数