0、c++期末总结
更新时间：2022年8月21日
pdf版下面评论置顶有链接 重点已经用黑体和高亮表示，属于记忆理解部分,可收藏使用 后面考完找时间分享下c++面向对象程序设计课后习题答案(谭浩强版)与C++题库刷题部分！ 题库与答案链接：题库与答案链接（已失效，置顶评论有习题），设置为0积分下载，如果还不可下载请下方留邮箱，虽然各个学校情况各异，但是知识点是一样的，而且基本高校内C++考的也基本都是这些，大差不差吧~ 更新一下：习题和笔记pdf版均在置顶评论，自取
学校考试一般比较简单，更多在于概念和语法的考察，包括一些细节知识点在选择判断等。
是根据老师的PPT与自己所学进行总结的，基本不涉及偏难怪知识点，重点是为了期末考试。
全文长10400多字，基本可以囊括90%的考试知识点
个人感觉知识掌握了就是多做做习题，毕竟考试偏应试，想提高分请一定多做题！！！！
考试加油！！！！
只是知识点总结，请一定要理解记忆，由于博主这学期也要考，时间有限，难免有不全有误之处，望谅解。
10.时间充足者可以按如下顺序学习，更有利于掌握。
《黑马程序员》C++基础入门(一)《黑马程序员》通讯录管理系统实战《黑马程序员》通讯录管理系统源码《黑马程序员》C++核心编程(二)《黑马程序员》职工管理系统实战《黑马程序员》职工管理系统源码《黑马程序员》C++提高编程(三)《黑马程序员》演讲比赛管理系统实战《黑马程序员》演讲比赛管理系统源码《黑马程序员》演讲比赛管理系统成品0.1、程序的构成
一个C++程序可以由一个程序单位或多个程序单位构成。每一个程序单位作为一个文件。在程序编译时，编译系统分别对各个文件进行编译，因此，一个文件是一个编译单元。0.2、程序的编写与实践
用高级语言编写的程序称为“源程序”，C++的源程序是以.cpp作为后缀的对源程序(.cpp)进行编译 ➡ 目标程序(.obj) ➡ 二进制文件(.exe)编写C++程序一般需要经过的几个步骤是：编辑➡编译➡连接➡调试 1、数据类型
1.1、整型
作用：整型变量表示的是整数类型的数据
int - 占4个字节unsigned int - 无符号整型，占4个字节1.2、sizeof关键字
作用：利用sizeof关键字可以统计数据类型所占内存大小
1.3、浮点型
作用：用于表示小数
浮点型变量分为两种：
单精度float ➡占4个字节，提供6位有效数组双精度double ➡占8个字节，提供15位有效数字1.4、数值型常量
1.4.1数值常量
一个整型常量可以用3种不同的方式表示：
十进制整数。如1357,-432，0等八进制整数。在常数的开头加一个数字0，就表示这是以八进制数形式表示的常数。十六进制整数。在常数的开头加一个数字0和一个英文字母X(或x)，就表示这是以十六进制数形式表示的常数1.4.2浮点数的表示方法
一个浮点数可以用两种不同的方式表示：
十进制小数形式。如21.456,-7.98等。指数形式(即浮点形式)1.5、字符型常量
作用：字符型变量用于显示单个字符
语法：char ch = 'a';
注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号
注意2：单引号内只能有一个字符，不可以是字符串
C和C++中字符型变量只占用1个字节。
字符常量只能包括一个字符，如′AB′ 是不合法的
字符常量区分大小写字母，如′A′和′a′是两个不同的字符常量
字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元
1.6、字符串型常量
作用：用于表示一串字符
两种风格
C风格字符串：char 变量名[] = "字符串值" char str1[] = "hello world";注意：C风格的字符串要用双引号括起来
C++风格字符串：string 变量名 = "字符串值" string str = "hello world";注意：C++风格字符串，需要加入头文件==#include<string>==
字符串常量为双引号
常考：字符串 "abc" 在内存中占几个字节？
答：占4个字节，而不是3个字节，编译系统会在字符串最后自动加一个′＼0′作为字符串结束标志。但′＼0′并不是字符串的一部分，它只作为字符串的结束标志
常考: 字符串常量″abc＼n″包含几个字符?
答：不是5个而是4个字符，其中“＼n”是一个转义字符,但它在内存中占5个字节
1.7、布尔类型bool
作用：布尔数据类型代表真或假的值
bool类型只有两个值：
true — 真（本质是1）false — 假（本质是0）bool类型占1个字节大小
1.8、数据的输入输出
关键字：cin、cout
语法： cin >> 变量1>>变量2>>....>>变量n 、cout<<表达式1<<表达式2<<...<<表达式n
cout<<a,b,c; //错误，不能一次插入多项cout<<a+b+c; //正确，这是一个表达式，作为一项cin>>a>>b>>c>>d;1.9、变量命名规则
C++规定标识符只能由字母、数字和下划线3种字符组成，且第一个字符必须为字母或下划线不能是关键字区分大小写1.10、局部变量
在一个函数内部定义的变量是局部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的形参也是局部变量1.11、全局变量
在函数之外定义的变量是外部变量，称为全局变量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++中两个小数可以相除运算的两个数中有一个数为float型数据，则运算的结果是double型，因为C++在运算时对所有float型数据都按double型数据处理只有整型变量可以进行取模运算，两个小数不可以取模在除法运算中，除数不能为0取模运算时，除数也不能为0常考：
前置后置运算符单独使用没有什么区别
前置递增先对变量进行++，再计算表达式
后置递增先计算表达式，后对变量进行++
请详细看下方代码并理解
//递增int main() {//后置递增int a = 10;a++; //等价于a = a + 1cout << 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; //100system("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;}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 ...}; 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 };4.1.1、一维数组初始化
在定义数组时分别对数组元素赋予初值。例如int a[10]={0，1，2，3，4，5，6，7，8，9};int a[10]={0,1,2,3,4}; int a[10]={1，1，1，1，1，1，1，1，1，1};int a[10］={1*10}; // 错误写法,不能给数组整体赋初值int a[5]={1，2，3，4，5};// 可以写成int a[]={1，2，3，4，5};4.2、二维数组
二维数组定义的四种方式：
数据类型 数组名[ 行数 ][ 列数 ];数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据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.3、字符数组
用来存放字符数据的数组是字符数组，字符数组中的一个元素存放一个字符定义：
char c[10] = {′I′,′ ′,′a′,′m′,′ ′,′h′,′a′,′p′,′p′,′y′};赋值：
只能对字符数组的元素赋值，而不能用赋值语句对整个数组赋值
char c[5];c={′C′,′h′,′i′,′n′,′a′}; //错误，不能对整个数组一次赋值C[0]=′C′; c[1]=′h′; c[2]=′i′; c[3]=′n′; c[4]=′a′; //对数组元素赋值，正确int a[5],b[5]={1,2,3,4,5};a=b; //错误，不能对整个数组整体赋值a[0]=b[0]; //正确，引用数组元素 4.4、字符串函数
字符串连接函数 strcat
字符串复制函数 strcpy
字符串比较函数 strcmp
字符串长度函数 strlen
5、函数
作用：将一段经常使用的代码封装起来，减少重复代码
5.1、函数定义
函数的定义一般主要有5个步骤：
1、返回值类型
2、函数名
3、参数表列
4、函数体语句
5、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;}5.8、重载运算符规则
C++中有以下五个运算符不能重载
| 成员访问运算符 | 成员指针访问运算符 | 域运算符 | 长度运算符 | 条件运算符 |
|---|---|---|---|---|
| . | .* | ：： | sizeof | ？： |
重载运算符规则：
重载不能改变运算符运算对象（即操作数）的个数重载不能改变运算符的优先级别重载不能改变运算符的结合性运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数什么时候应该用成员函数方式，什么时候应该用友元函数方式？二者有何区别呢？（）
一般将单目运算符重载为成员函数，将双目运算符（二元运算符）重载为友元函数 重载为类的成员函数 -operator 函数有一个参数重载为类的友元函数 - operator 函数有两个参数只能将重载 “>>” （流插入运算符）和“<<” （流提取运算符）的函数作为友元函数或者普通函数重载，而不能将它们定义为成员函数，因为参数为两个类型转换运算符只能作为成员函数重载 单目运算符：只有一个操作数，如 !，-(负号)，&，*，++，–
双目运算符：*，/，%，+，-，==，!=，<,>,<=,>=,&&，||
5.9、内联函数
指定内置函数的方法很简单，只需在函数首行的左端加一个关键字inline即可。inline int max(int a,int b);5.10、函数模板
语法：
template<typename T>函数声明或定义解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母
只适用于函数体相同、函数的参数个数相同而类型不同的情况，如果参数的个数不同，则不能用函数模板。
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 = 10system("pause");return 0;}指针变量和普通变量的区别
普通变量存放的是数据,指针变量存放的是地址指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用总结1： 我们可以通过 & 符号 获取变量的地址
总结2：利用指针可以记录地址
总结3：对指针变量解引用，可以操作指针指向的内存
总结4：所有指针类型在32位操作系统下是4个字节（了解）
6.2、const修饰指针
const修饰指针有三种情况
const修饰指针 — 常量指针const修饰常量 — 指针常量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; //1cout << "指针访问第一个元素： " << *p << endl; //1for (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;}int a[10];int *p = &a[0]; // 等价于 int *p = a;*p = 1; // 等价于 a[0] = 1;*(p+1) = 2; // 等价于 a[1] = 2;// 所以 *(p+1) = a[1]; *(p+2) = a[2];void main(){ int array[10]; // 用数组名作形参，因为接收的是地址，所以可以不指定具体的元素个数 f(array,10);}// 形参数组f(int arr[],int n){ ....}void main(){ int a[10]; // 实参数组 f(a,10);}// 形参指针f(int *x,int n){ ...}总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递
6.4、返回指针值的函数
返回指针值的函数简称指针函数。定义指针函数的一般形式为：// 类型名 * 函数名（参数列表）int * a(int x,int y);7、引用
作用： 给变量起别名
语法： 数据类型 &别名 = 原名
int main() {int a = 10;int &b = a;cout << "a = " << a << endl;cout << "b = " << b << endl; // 10 // 10b = 100;cout << "a = " << a << endl;cout << "b = " << b << endl; // 100 // 100system("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:20 b:10system("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、构造函数和析构函数
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。构造函数语法：类名(){}（构造和析构很容易出选择题，特点要记住）
析构函数语法： ~类名(){}
~析构函数不可以有参数，因此不可以发生重载程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次 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；}8.6、静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
静态成员变量 所有对象共享同一份数据在编译阶段分配内存类内声明，类外初始化 静态成员函数 所有对象共享同一个函数静态成员函数只能访问静态成员变量**示例1 **：静态成员变量
class Person{public:static int m_A; //静态成员变量//静态成员变量特点：//1 在编译阶段分配内存//2 类内声明，类外初始化//3 所有对象共享同一份数据private:static int m_B; //静态成员变量也是有访问权限的};int Person::m_A = 10;int Person::m_B = 10;void test01(){//静态成员变量两种访问方式//1、通过对象Person p1;p1.m_A = 100;cout << "p1.m_A = " << p1.m_A << endl;Person p2;p2.m_A = 200;cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据cout << "p2.m_A = " << p2.m_A << endl;//2、通过类名cout << "m_A = " << Person::m_A << endl;//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到}int main() {test01();system("pause");return 0;}示例2：静态成员函数
class Person{public://静态成员函数特点：//1 程序共享一个函数//2 静态成员函数只能访问静态成员变量static void func(){cout << "func调用" << endl;m_A = 100;//m_B = 100; //错误，不可以访问非静态成员变量}static int m_A; //静态成员变量int m_B; // private://静态成员函数也是有访问权限的static void func2(){cout << "func2调用" << endl;}};int Person::m_A = 10;void test01(){//静态成员变量两种访问方式//1、通过对象Person p1;p1.func();//2、通过类名Person::func();//Person::func2(); //私有权限访问不到}int main() {test01();system("pause");return 0;}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、构造和析构函数
构造函数的主要作用是对数据成员初始化
派生类是不能继承基类的析构函数，也需要通过派生类的析构函数去调用基类的析构函数
继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
9.3、不能继承
C++中，不能被派生类继承的是：构造函数 9.4、继承特点
单继承：一个派生类只从一个基类派生
多继承：一个派生类有两个或多个基类的称为多重继承
10、多态
多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数
多态分为两类
静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名动态多态: 派生类和虚函数（virtual function）实现运行时多态10.1、虚函数
什么是虚函数？
在基类用virtual 声明成员函数为虚函数 虚函数的作用：
虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数虚函数的使用方法：
在基类用virtual 声明成员函数为虚函数。这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便地被调用 在类外定义虚函数时，不必再加virtual 在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据派生类的需要重新定义函数体 C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时，可以加virtual，也可以不加，但习惯上一般在每一层声明该函数时都加virtual，使程序更加清晰
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;}多态满足条件
有继承关系子类重写父类中的虚函数 纯虚函数纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚函数的一般形式是
virtual 函数类型 函数名 (参数表列) =0;纯虚函数没有函数体
最后面的 =0 ，并不表示函数返回值为0，它只告诉编译系统“老子是纯虚函数”
纯虚函数只有函数的名字而不具备函数的功能，不能被调用
抽象类凡是包含纯虚函数的类都是抽象类
一个基类如果包含一个或一个以上纯虚函数，就是抽象基类。抽象基类不能也不必要定义对象、
11、文件操作
C++中对文件操作需要包含头文件 < fstream >
文件类型分为两种：
文本文件 - 文件以文本的ASCII码形式存储在计算机中二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们操作文件的三大类:
ofstream：写操作ifstream： 读操作fstream ： 读写操作11.1、文本文件
5.1.1写文件
写文件步骤如下：
包含头文件
#include <fstream>
创建流对象
ofstream ofs;
打开文件
ofs.open(“文件路径”,打开方式);
写数据
ofs << “写入的数据”;
关闭文件
ofs.close();
文件打开方式：
| 打开方式 | 解释 |
|---|---|
| ios::in | 为读文件而打开文件 |
| ios::out | 为写文件而打开文件 |
| ios::ate | 初始位置：文件尾 |
| ios::app | 追加方式写文件 |
| ios::trunc | 如果文件存在先删除，再创建 |
| ios::binary | 二进制方式 |
注意： 文件打开方式可以配合使用，利用|操作符
**例如：**用二进制方式写文件 ios::binary | ios:: out
示例：
#include <fstream>void test01(){ofstream ofs;ofs.open("test.txt", ios::out);ofs << "姓名：张三" << endl;ofs << "性别：男" << endl;ofs << "年龄：18" << endl;ofs.close();}int main() {test01();system("pause");return 0;}总结：
文件操作必须包含头文件 fstream读文件可以利用 ofstream ，或者fstream类打开文件时候需要指定操作文件的路径，以及打开方式利用<<可以向文件中写数据操作完毕，要关闭文件5.1.2读文件
读文件与写文件步骤相似，但是读取方式相对于比较多
读文件步骤如下：
包含头文件
#include <fstream>
创建流对象
ifstream ifs;
打开文件并判断文件是否打开成功
ifs.open(“文件路径”,打开方式);
读数据
四种方式读取
关闭文件
ifs.close();
示例：
#include <fstream>#include <string>void test01(){ifstream ifs;ifs.open("test.txt", ios::in);if (!ifs.is_open()){cout << "文件打开失败" << endl;return;}//第一种方式//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();}int main() {test01();system("pause");return 0;}总结：
读文件可以利用 ifstream ，或者fstream类利用is_open函数可以判断文件是否打开成功close 关闭文件5.2 二进制文件
以二进制的方式对文件进行读写操作
打开方式要指定为 ios::binary
5.2.1 写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型 ：ostream& write(const char * buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
示例：
#include <fstream>#include <string>class Person{public:char m_Name[64];int m_Age;};//二进制文件 写文件void test01(){//1、包含头文件//2、创建输出流对象ofstream ofs("person.txt", ios::out | ios::binary);//3、打开文件//ofs.open("person.txt", ios::out | ios::binary);Person p = {"张三" , 18};//4、写文件ofs.write((const char *)&p, sizeof(p));//5、关闭文件ofs.close();}int main() {test01();system("pause");return 0;}总结：
文件输出流对象 可以通过write函数，以二进制方式写数据5.2.2 读文件
二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(char *buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
示例：
#include <fstream>#include <string>class Person{public:char m_Name[64];int m_Age;};void test01(){ifstream ifs("person.txt", ios::in | ios::binary);if (!ifs.is_open()){cout << "文件打开失败" << endl;}Person p;ifs.read((char *)&p, sizeof(p));cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;}int main() {test01();system("pause");return 0;}12、输入输出流
标准输出流：cout 、cerr、clog
cerr、clog流对象都是标准错误流，都是在终端显示器上显示出错信息
标准输入流：cin、get、getline
get函数读入一个字符，getline读入一行字符
eof函数：文件结束
peek函数：peek函数的作用是观测下一个字符。
putback函数：其作用是将前面用get或getline函数从输入流中读取的字符ch返回到输入流，插入到当前指针位置，以供后面读取
ignore函数：函数作用是跳过输入流中n个字符，或在遇到指定的终止字符时提前结束
13、异常
C++处理异常的机制是由3个部分组成的，即检查(try)、抛出(throw)和捕捉(catch)。
命名空间的作用是建立一些互相分隔的作用域，把一些全局实体分隔开来，以免产生名字冲突