admin管理员组文章数量:1599543
C++复习的长文指南(一)
- 一、面向对象基础知识
- 1.预备
- 1.1 main函数
- 1.2 注释
- 1.3 变量
- 1.3 常量
- 1.4 关键字
- 1.5 标识符明明规则
- 2. 数据类型
- 2.1 整型
- 2.1.1 sizeof关键字
- 2.2 实型(浮点型)
- 2.3 字符型
- 2.4 转义字符
- 2.5 字符串型
- 2.6 布尔类型bool
- 2.7 数据的输入
- 3. 运算符
- 3.1 算数运算符
- 3.2 赋值运算符
- 3.3 比较运算符
- 3.4 逻辑运算符
- 4. 程序流程结构
- 4.1 选择结构
- 4.1.1 if语句
- 4.1.2 三目运算符
- 4.1.3 switch语句
- 4.2 循环结构
- 4.2.1 while语句
- 4.2.2 do while语句
- 4.2.3 for循环语句
- 4.2.4 嵌套循环
- 4.3 跳转结构
- 4.3.1 break语句
- 4.3.2 continue语句
- 4.3.3 go to语句
- 5. 数组
- 5.1 概述
- 5.2 一维数组
- 5.2.1 一维数组定义方式
- 5.2.2 一维数组数组名
- 5.2.3 冒泡排序
- 5.3 二维数组
- 5.3.1 二维数组定义方式
- 5.3.2 二维数组数组名
- 6. 函数
- 6.1 概述
- 6.2 函数的定义
- 6.3 函数的调用
- 6.4 值传递
- 6.5 函数的常见样式
- 6.6 函数的申明
- 6.7 函数的分文件编写
- 7. 指针
- 7.1 指针的基本概念
- 7.2 指针变量的定义和使用
- 7.3 指针所占内存空间
- 7.4 空指针和野指针
- 7.4.1 空指针
- 7.4.2 野指针
- 7.5 const修饰指针
- 7.5.1 常量指针
- 7.5.2 指针常量
- 7.5.3 既修饰指针,又修饰常量
- 7.6 指针和数组
- 7.7 指针和函数
- 7.8 指针、数组、函数的综合案例
- 8.结构体
- 8.1 结构体的基本概念
- 8.2 结构体定义和使用
- 8.3 结构体数组
- 8.4 结构体指针
- 8.5 结构体嵌套结构体
- 8.6 结构体做函数参数
- 8.7 结构体中的const使用场景
- 二、C++核心编程
- 1.内存分区模型
- 1.1 程序运行前
- 1.2 程序运行后
- 1.3 new操作符
- 2. 引用
- 2.1 引用的基本使用
- 2.2 引用的注意事项
- 2.3 引用做函数参数
- 2.4 引用做函数返回值
- 2.5 引用的本质
- 2.6 常量引用
- 3. 函数提高
- 3.1 函数默认参数
- 3.2 函数占位参数
- 3.3 函数重载
- 3.3.1 函数重载概述
- 3.3.2 函数重载的注意事项
- 4. 面向对象
- 4.1 封装
- 4.1.1 封装的意义
- 4.1.2 struct和class区别
- 4.1.3 成员属性设置为私有
- 4.1.4 类的分文件编写
- 4.2 对象的初始化和清理
- 4.2.1 构造函数和析构函数
- 4.2.2 构造函数的分类及调用
- 4.2.3 拷贝构造函数的调用时机
- 4.2.4 构造函数的调用规则
- 4.2.5 深拷贝与浅拷贝
- 4.2.6 初始化列表
- 4.2.7 类对象做类成员
- 4.2.8 静态成员
- 4.3 C++对象模型和this指针
- 4.3.1 成员变量和成员函数分开存储
- 4.3.2 this指针
- 4.3.3 空指针访问成员函数
- 4.3.4 const修饰成员函数
- 4.4 友元
- 4.5 运算符重载
- 4.5.1 加号运算符重载
- 4.5.2 左移运算符重载
- 4.5.3 递增运算符重载
- 4.5.4 赋值运算符重载
- 4.5.5 关系运算符重载
- 4.5.6 函数调用运算符重载
- 4.6 继承
- 4.6.1 继承的语法
- 4.6.2 继承的方式
- 4.6.3 继承中的对象模型
- 4.6.4 继承中构造和析构顺序
- 4.6.5 继承同名成员处理方式
- 4.6.6 继承同名静态成员处理方式
- 4.6.7 多继承语法
- 4.6.8 菱形继承
- 4.7 多态
- 4.7.1 多态的基本概念
- 4.7.2 多态的案例
- 4.7.3 纯虚函数和抽象类
- 4.7.4 纯析构和纯虚析构
- 4.7.5 多态案例
一、面向对象基础知识
1.预备
1.1 main函数
任何c++程序都有的 main
。
#include<iostream>
using namespace std;
int main() {
cout << "hello world" << endl;
system("pause");
return 0;
}
1.2 注释
// 单行注释
//cout << "hello world" << endl;
// 多行注释
/*
cout << "hello world" << endl;
cout << "hello world" << endl;
*/
1.3 变量
变量
的作用:给内存起个名字,方便操作这块内存。
数据类型 变量名称 = 变量初始值;
int a = 10;
1.3 常量
常量
的作用:用于记录程序中不可更改的数据。
// 1.第一种#define 宏常量
#define Day 7
// 2.第二种const 修饰一个变量
const int a = 10;
1.4 关键字
关键字
的作用:c++中预先保留的单词(标识符),定义变量、常量名时不能再使用。
比如:int
、double
、bool
、long
、sizeof
…
1.5 标识符明明规则
1、 标识符不能为关键字;
2、 标识符只能是字母、数字、下划线;
3、 第1个标识符必须只能字母或下划线;
4、标识符字母区分大小写。
建议
:尽量做到“见名知意”。
int num1 = 10;
int num2 = 20;
int sum = num1 + num2;
cout << "和为:" << sum << endl;
2. 数据类型
2.1 整型
C++规定在创建一个变量或者常量时,必须要指定出相应的数据类型,否则无法给变量分配合适的内存。
比如,int a = 10;在内存中找一个空间存放数据10,并且给这块内存空间命名为a,想要操纵管理这个空间,用a就行。
那数据类型
存在的意义
?
存放一个数据10,可以用小内存,或者更大的内存空间存放,而加上数据类型,就不会造成下图的内存空间浪费
。
除了int,还有别的常用的整型,区别在于占用的内存空间不同。
2.1.1 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;
system("pause");
return 0;
}
整型结论:
short<int<= long<= long long(区分操作系统)
2.2 实型(浮点型)
作用
:用于表示小数
浮点型变量分为:
1.单精度float
;
2.双精度double
。
float f1 = 3.14f;
double d1 = 3.14;
// 4
cout << "float所占内存空间" << sizeof(float) << endl;
// 8
cout << "double所占内存空间" << sizeof(double) << endl;
// 科学计数法
float f2 = 3e2; // 3 * 10 ~ 2
float f3 = 3e-2; // 3 * 0.1 ~ 2
2.3 字符型
语法
:char ch = ‘a’;
注意1:在显示字符型变量时,用单引号将字符括起来,不要用双引号;
注意2:单引号内只能有一个字符,不可以是字符串。
结论:
1.c和c++中字符型只占1个字节的内存空间;
2.字符型变量并不是把字符本身放到内存中存储,而是将对应的ASCIl编码放入
到存储单元。
2.4 转义字符
作用
:用于显示一些不能显示出来的ASCII字符。
2.5 字符串型
作用
:用于表示一串字符
两种风格:
1.C风格字符串:char 变量名[] = “字符串值”
char str1[] = "hello world";
2.C++风格字符串:string 变量名 = “字符串值”
#include<string> // 使用c++风格时,需要包含这个头文件。
string str1 = "hello world";
2.6 布尔类型bool
作用
:用于表示真或假
布尔类型bool只占1个字节的内存空间;
bool flag = true;
cout << flag << endl; // 输出为1
2.7 数据的输入
作用
:用于从键盘获取数据
关键字
:cin
语法
:cin >> 变量
int a = 0;
cout << "请输入数据:" << endl;
cin >> a;
cout << "输入数据为:" << a << endl;
3. 运算符
作用
:用于执行代码的运算
3.1 算数运算符
作用
:用于处理四则运算
结论
:
1.两数相除(取模),除数不可以为0;
2.只有整型变量之间可以做取余运算;
3.++a,前置递增先让变量+1,然后进行表达式运算
4.a++,后置递增先进行表达式运算,后让变量+1
int a1 = 10;
int a2 = 3;
cout << a1 / a2 << endl; // 输出结果为3,取决于a1和a2的数据类型
float b1 = 0.55;
float b2 = 0.22;
cout << b1 / b2 << endl; // 输出结果为小数,取决于b1和b2的数据类型int a1 = 10;
3.2 赋值运算符
作用
:用于将表达式的值赋值给变量
3.3 比较运算符
作用
:用于表达式的比较,返回一个真值或假值
3.4 逻辑运算符
作用
:用于根据表达式的值返回真值或假值
4. 程序流程结构
作用
:用于执行代码的运算
C/C++支持最基本的三种程序运行结构:
顺序结构、选择结构、循环结构
1.顺序结构:程序按顺序执行,不发生跳转;
2.选择结构:依据条件是否满足,有选择的执行相应功能;
3.循环结构:依据条件是否满足,循环多次执行某段代码;
4.1 选择结构
4.1.1 if语句
作用
:执行满足条件的语句
if语句的三种形式:
1.单行格式if语句
int score = 70;
if (score > 60) //注意事项,if条件后面不要加分号
{
cout << "分数及格" << endl;
}
2.多行格式if语句
int score = 70;
if (score > 60) //注意事项,if条件后面不要加分号
{
cout << "分数及格" << endl;
}
else
{
cout << "分数不及格" << endl;
}
3.多条件的if语句
int score = 70;
if (score > 90) //注意事项,if条件后面不要加分号
{
cout << "分数优秀" << endl;
}
else if (score > 80)
{
cout << "分数良好" << endl;
}
else
{
cout << "分数及格" << endl;
}
4.多嵌套if语句
在if语句中,可以嵌套使用if语句,达到更精确的条件判断
int score = 70;
if (score > 90) //注意事项,if条件后面不要加分号
{
cout << "分数优秀" << endl;
// 嵌套if语句
if (score > 95)
{
cout << "分数特别优秀" << endl;
}
}
else if (score > 80)
{
cout << "分数良好" << endl;
}
else
{
cout << "分数及格" << endl;
}
4.1.2 三目运算符
作用
:通过三目运算符实现简单的判断
语法
:表达式1 ? 表达式2 : 表达式3
解释:
如果表达式1的值为真,执行表达式2,并返回表达式2的结果;
如果表达式1的值为假,执行表达式3,并返回表达式3的结果。
int a = 10;
int b = 20;
int c = 0;
c = (a > b ? a : b);
cout << c << endl;
// 在C++中三目运算符返回的是变量,可以继续赋值
(a > b ? a : b) = 30;
4.1.3 switch语句
作用
:执行多条件分支语句
语法
:
switch (表达式)
{
case 结果1: 执行语句; break;
case 结果2: 执行语句; break;
......
default: 执行语句; break;
}
示例:
int score = 90;
switch (score)
{
case 90:
cout << "成绩优秀" << endl;
break; // 退出当前分支
case 80:
cout << "成绩良好" << endl;
break; // 退出当前分支
case 70:
cout << "成绩及格" << endl;
break; // 退出当前分支
default:
cout << "成绩不及格" << endl;
break;
}
if和 switch 区别
?
switch缺点:判断时候只能是整型或者字符型,不可以是一个区间
switch优点:结构清晰,执行效率高
4.2 循环结构
4.2.1 while语句
作用
:满足循环条件,执行循环语句
语法
:while(循环条件){循环语句}
解释
:只要循环条件的结果为真,就执行循环语句
int num = 0;
while (num < 10)
{
cout << num << endl;
num++;
}
注意事项
:在写循环一定要避免死循环的出现
4.2.2 do while语句
作用
:满足循环条件,执行循环语句;
语法
:do{循环语句 } while(循环条件);
注意
:与while的区别在于do…while会先执行一次循环语句,再判断循环条件
int num = 0;
do
{
cout << num << endl;
num++;
} while (num < 10);
4.2.3 for循环语句
作用
:满足循环条件,执行循环语句;
语法
:for(起始表达式;条件表达式;末尾循环体){循环语句;};
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
4.2.4 嵌套循环
作用
:在循环体中再嵌套—层循环,解决—些实际问题
// 外层循环执行一次
for (int i = 0; i < 10; i++)
{
// 内层循环执行一周
for (int j = 0; j < 10; j++)
{
cout << "* ";
}
cout << endl;
}
4.3 跳转结构
4.3.1 break语句
作用
:用于跳出选择结构或者循环结构
break使用的时机:
1.出现在switch条件语句中,作用是终止case并跳出switch
2.出现在循环语句中,作用是跳出当前的循环语句
3.出现在嵌套循环中,跳出最近的内层循环语句
4.3.2 continue语句
作用
:在循环语句中,跳过本次循环中余下尚未执行的语句,继续执行下一次循环
4.3.3 go to语句
作用
:可以无条件跳转语句;
语法
:goto标记;
解释
:如果标记的名称存在,执行到goto语句时,会跳转到标记的位置
cout << "1" << endl;
cout << "2" << endl;
goto FLAG;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
注意
:在程序中不建议使用goto语句,以免造成程序流程混乱
5. 数组
5.1 概述
所谓数组,就是—个集合,里面存放了“相同类型”的数据元素
特点1:数组中的每个数据元素都是相同的数据类型
特点2:数组是由连续的内存位置组成的
好比,一个盒子放着同样的电池。
5.2 一维数组
5.2.1 一维数组定义方式
—维数组定义的三种方式:
1.数据类型 数组名[数组长度];
2.数据类型 数组名[数组长度] = { 值1,值2 …];
3.数据类型 数组名[ ] ={ 值1,值2 …};
数组特点:
1.放在一块连续的内存空间中
2.数组中每个元素都是相同数据类型
// 定义方式1
int score[10];
// 定义方式2
// 如果{}内不足10个数据,剩余数据用0补全
int score[10] = {10, 20, 30, 40};
// 定义方式3
// 如果{}有了初始长度,[]内也可以不用显式化数组长度
int score[] = { 10, 20, 30, 40 };
总结1:数组名的命名规范与变量名命名规范—致,不要和变量重名;
总结2:数组中下标是从0开始索引。
5.2.2 一维数组数组名
一维数组名称的用途:
1.可以统计整个数组在内存中的长度;
2.可以获取数组在内存中的首地址。
// 1.可以通过数组名统计整个数组占用内存大小
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组占用的内存空间为:" << sizeof(arr) << endl;
cout << "每个元素占用的内存空间为:" << sizeof(arr[0]) << endl;
cout << "数组中元素的个数为:" << sizeof(arr) / sizeof(arr[0]) << endl;
// 2.可以通过数组名查看数组首地址,加(int)将16进制地址强转成10进制数
cout << "数组首地址为:" << (int)arr<< endl;
cout << "数组中第一个元素的地址为:" << (int)&(arr[0])<< endl;
// 数组中存放的是整型,每个整型占用4个字节,所以每个元素地址差4
cout << "数组中第二个元素的地址为:" << (int)&(arr[1])<< endl;
// 数组名是常量,它已经指向了首地址,不可以进行赋值操作
// arr = 100;
示例,实现一个一维数组的逆置
// 1.创建数组
int arr[5] = { 1,3,2,5,4 };
cout << "数组逆置前:" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
// 2、实现逆置
// 2.1记录起始下标位置
int start = 0;
// 2.2记录结束下标位置
int end = sizeof(arr) / sizeof(arr[0]) - 1;
// 2.3起始下标与结束下标的元素互换
// 2.4起始位置++ 结束位置--
// 2.5循环执行2.1操作,直到起始位置>=结束位置
while (start < end)
{
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
cout << "数组逆置后:" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
5.2.3 冒泡排序
作用
:最常用的排序算法,对数组内元素进行排序
1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2.对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值。
3.重复以上的步骤,每次比较次数-1,直到不需要比较
首先看比几轮,每1轮比几次,比如第1轮, 就比8次;
其实第1轮的作用就是,两两比较,直到选到最大的数放在最后位置;
第2轮时候,因为第1轮已经找到最大数,所以比较次数-1,其作用就是第2大的数放在倒数第2位置。
int arr[9] = { 4,2,8,0,5,7,1,3,9 };
int arr_num = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < arr_num - 1; i++)
{
for (int j = 0; j < arr_num - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
cout << "排序后的结果:" << endl;
for (int i = 0; i < arr_num; i++)
{
cout << arr[i] << endl;
}
5.3 二维数组
二维数组就是在一维数组上,多加一个维度。通常以矩阵的形式进行体现。
5.3.1 二维数组定义方式
二维数组定义的四种方式:
1.数据类型 数组名[行数] [列数];
2.数据类型 数组名[行数] [列数] = { (值1,值2), (值3,值4) …];
3.数据类型 数组名[行数] [列数] ={ 值1,值2, 值3,值4…};
4.数据类型 数组名[ ] [列数] ={ 值1,值2, 值3,值4…};
建议
:以上4种定义方式,利用第二种更加直观,提高代码的可读性
// 1.数据类型 数组名[行数] [列数];
int arr1[2][3];
// 2.数据类型 数组名[行数] [列数] = { (值1,值2), (值3,值4) ...];
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
// 3.数据类型 数组名[行数] [列数] ={ 值1,值2,值3,值4...};
int arr3[2][3] = { 1,2,3,4,5,6 };
// 4.数据类型 数组名[ ] [列数] ={ 值1,值2,值3,值4...};
int arr4[][3] = { 1,2,3,4,5,6 };
总结
:在定义二维数组时,如果初始化了数据,可以省略行数
5.3.2 二维数组数组名
作用
:
1.查看二维数组所占内存空间
2.获取二维数组首地址
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
// 1.查看二维数组所占内存空间
cout << "二维数组所占内存空间为:" << sizeof(arr) << endl;
cout << "二维数组第一行所占内存空间为:" << sizeof(arr[0]) << endl;
cout << "二维数组第1个元素所占内存空间为:" << sizeof(arr[0][0]) << endl;
cout << "二维数组行数为:" << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组列数为:" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
// 2.获取二维数组首地址
cout << "二维数组首地址为:" << (int)arr << endl;
cout << "二维数组第1行首地址为:" << (int)arr[0] << endl;
// 第1行和第2行首地址差了12, 3x4
cout << "二维数组第2行首地址为:" << (int)arr[1] << endl;
// 第1个和第2个元素首地址差了4
cout << "二维数组第1个元素首地址为:" << (int)&arr[0][0] << endl;
cout << "二维数组第2个元素首地址为:" << (int)&arr[0][1] << endl;
6. 函数
6.1 概述
作用
:将一段经常使用的代码封装起来,减少重复代码
一个较大的程序,一般分为若干个程序块,每个模块实现特定的功能。
6.2 函数的定义
函数的定义一般主要有5个步骤:
1、返回值类型
2、函数名
3、参数表列
4、函数体语句
5、return表达式
// 函数定义的时候,num1和num2并没有真实数据,他只是一个形式上的参数,简称形参
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
6.3 函数的调用
功能
:使用定义好的函数
语法
:函数名(参数)
int a = 10;
int b = 10;
// a和b称为实际参数,简称实参
// 当调用函数时候,实参的值会传递给形参
int sum = add(a, b);
6.4 值传递
1.所谓值传递,就是函数调用时实参将数值传入给形参
2.值传递时,如果形参发生,并不会影响实参
6.5 函数的常见样式
1.无参无返
2.有参无返
3.无参有返
4.有参有返
6.6 函数的申明
作用
:告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
注意
:函数的声明可以多次,但是函数的定义只能有—次。
#include<iostream>
using namespace std;
// 提前告诉编译器函数的存在,可以利用函数的声明
int max(int a, int b);
// 声明可以多次,但是函数的定义只能有—次。
int max(int a, int b);
int main()
{
system("pause");
return 0;
}
int max(int a, int b)
{
return a > b ? a : b;
}
6.7 函数的分文件编写
作用
:让代码结构更加清晰
函数分文件编写一般有4个步骤:
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
#include<iostream>
using namespace std;
void swap(int a, int b);
4.在源文件中写函数的定义
#include"swap.h"
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a=" << a << endl;
cout << "b=" << b << endl;
}
主函数中进行调用
#include<iostream>
using namespace std;
#include"swap.h"
int main()
{
int a = 10;
int b = 20;
swap(a, b);
system("pause");
return 0;
}
7. 指针
7.1 指针的基本概念
作用
:可以通过指针间接访问内存
1.内存编号是从0开始记录的,一般用“十六进制数字”麦示
2.可以利用指针变量保存地址
7.2 指针变量的定义和使用
指针变量定义语法
:数据类型 * 变量名
// 1、定义指针,语法: 数据类型 * 变量名;
int a = 10;
int* p;
// 让指针记录变量a的地址
p = &a;
cout << "a的地址为:" << &a << endl;
cout << "指针p为:" << p << endl;
// 2、使用指针
// 可以通过解引用的方式来找到指针指向的内存
// 指针前加 *
*p = 1000;
cout << "a=" << a << endl;
cout << "*p=" << *p << endl;
7.3 指针所占内存空间
提问
:指针也是种数据类型,那么这种数据类型占用多少内存空间?
// 1、定义指针,语法: 数据类型 * 变量名;
int a = 10;
int* p = &a; // 让指针记录变量a的地址
// 在32位操作系统下,指针是占4个字节空间大小,不管是什么数据类型
// 在64位操作系统下,指针是占8个字节空间大小,不管是什么数据类型
cout << "int*所占内存空间为:" << sizeof(int*) << endl;
cout << "int*所占内存空间为:" << sizeof(p) << endl;
cout << "float*所占内存空间为:" << sizeof(float*) << endl;
cout << "double*所占内存空间为:" << sizeof(double*) << endl;
cout << "char* 所占内存空间为:" << sizeof(char*) << endl;
7.4 空指针和野指针
7.4.1 空指针
空指针
:指针变量指向内存中编号为0的空间
用途
:初始化指针变量
注意
:空指针指向的内存是不可以访问的
//空指针
// 1.初始化指针变量
int* p = NULL;
// 2.空指针指向的内存是不可以访问的
// 0-255之间的内存编号是系统占用的,因此不可以访问
//*p = 100;
7.4.2 野指针
野指针
:指针变量指向非法的内存空间
// 野指针
// 1.初始化指针变量
// 0x1100这个内存空间并不我们是申请的,没有权利操纵这块内存
// 在程序中,尽量避免出现野指针
int* p = (int*)0x1100;
cout << *p << endl;
总结
:空指针和野指针都不是我们申请的空间,因此不要访问。
7.5 const修饰指针
const修饰指针有三种情况;
7.5.1 常量指针
const修饰指针—常量指针
记忆技巧
:const修饰的是int *,所以 * 的操纵就不能了。
// 1.const修饰指针 常量指针
int a = 10;
int b = 10;
const int* p = &a;
// 指针指向的值不可以改,指针的指向可以改
// *p = 20;
p = &b;
7.5.2 指针常量
const修饰常量—指针常量
记忆技巧
:const修饰的是指针p,所以指针p就不能操纵了。
// 2.const修饰常量 指针常量
int* const p2 = &a;
// 指针指向不可以改,指针指向的值可以改
*p2 = 2;
// p2 = &b;
7.5.3 既修饰指针,又修饰常量
cons既修饰指针,又修饰常量
// 3.const既修饰指针,又修饰常量
const int* const p3 = &a;
// *p3 = 20;
// p3 = &b;
总结
:看const右侧紧跟着的是指针还是常量,是指针就是常量指针,是常量就是指针常量。
7.6 指针和数组
作用
:利用指针访问数组中元素。
// 指针和数组
// 利用指针访问数组中的元素
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "数组种第一个元素为:" << arr[0] << endl; //普通下标访问
int* p = arr; // 数组名就是数组的首地址
// 当使用指针指向数组首地址时,也可以通过p[0]这样下标的形式进行元素的访问。
cout << "利用指针访问的第一个元素为:" <<* p << endl;
p++; //将指针向后偏移4个字节
cout << "利用指针访问的第二个元素为:" << *p << endl;
// 利用循环
int* p2 = arr;
for (int i = 0; i < 10; i++)
{
cout << *p2 << endl;
p2++;
}
7.7 指针和函数
作用
:利用指针作函数参数,可以修改实参的值。
// 指针和函数
int a = 10;
int b = 20;
// 1.值传递
// 值传递不会改变实参
swap(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
// 2.地址传递
// 如果是地址传递,可以修饰实参
swap02(&a, &b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
总结
:如果不想修改实参,就用值传递,如果想修改实参,就用地址传递
7.8 指针、数组、函数的综合案例
案例
:封装一个函数,利用冒泡排序,实现对整型数组的升序排
#include<iostream>
using namespace std;
// 冒泡排序函数 参数1:数组的首地址 参数2:数组长度
void bubbleSort(int* arr, int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i -1; j++)
{
// 如果j > j+1 的值,就进行交换
// 当使用指针指向数组首地址时,也可以通过p[0]这样下标的形式进行元素的访问。
if (arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
// 1.创建数组
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
// 数组长度
int len = sizeof(arr) / sizeof(arr[0]);
// 2.创建函数,实现冒泡排序
bubbleSort(arr, len); //一般,我们函数传数组,会连着数组的长度一起传
// 3.打印结果
for (int i = 0; i < len; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
8.结构体
8.1 结构体的基本概念
结构体属于用户自定义的数据类型,允许用户存储不同的数据类型
8.2 结构体定义和使用
语法
:struct结构体名{结构体成员列表};
通过结构体创建变量的方式有三种:
1.struct 结构体名 变量名
2.struct 结构体名 变量名 = {成员1值,成员2值…}
3.定义结构体时顺便创建变量
#include<iostream>
using namespace std;
#include<string>
// 1.创建学生数据类型(3个属性)
// 自定义数据类型,其实就是一些内置数据类型的集合
struct Student
{
// 成员列表
string name; //姓名
int age; //年龄
int score; //分数
}s3; //顺便创建结构体变量s3
int main()
{
// 2.通过学生数据类型创建具体学生
// 2.1
struct Student s1;
// Student s1; struct关键字可以省略
// 给属性进行赋值
s1.name = "张三";
s1.age = 18;
s1.score = 100;
// 2.2 struct Student s2 = { ...}
struct Student s2 = { "李四", 19, 80 };
// 2.3 在定义结构体时顺便创建结构体变量
s3.name = "王五";
s3.age = 20;
s3.score = 60;
system("pause");
return 0;
}
总结1
:定义结构体时的关键字是struct,不可省略
总结2
:创建结构体变量时,关键字struct可以省略
总结3
:结构体变量利用操作符"."访问成员
8.3 结构体数组
作用
:将自定义的结构体放入到数组中方便维护
语法
:struct 结构体名 数组名[元素个数] = { {} , {}, … {}}
#include<iostream>
using namespace std;
#include<string>
// 结构体数组
// 1.定义结构体数组
struct Student
{
string name; // 姓名
int age; // 年龄
int score; // 分数
};
int main()
{
// 2.创建结构体数组并赋值
struct Student stuArray[3] =
{
{"张三", 18, 100},
{"李四", 28, 99},
{"王五", 38, 95},
};
// 3.修改结构体数组中的值
stuArray[2].name = "哈哈";
// 4.遍历结构体数组
for (int i = 0; i < 3; i++)
{
cout << "姓名:" << stuArray[i].name << endl;
cout << "年龄:" << stuArray[i].age << endl;
cout << "分数:" << stuArray[i].score << endl;
}
system("pause");
return 0;
}
8.4 结构体指针
作用
:通过指针访问结构体中的成员
利用操作符->可以通过结构体指针访问结构体属性
#include<iostream>
using namespace std;
#include<string>
// 结构体指针
// 定义学术结构体
struct student
{
string name; // 姓名
int age; // 年龄
int score; // 分数
};
int main()
{
// 创建学生结构体变量
struct student s = { "张三",18, 100 };
// 通过指针指向结构体变量
struct student* p = &s;
// 通过指针访问结构体变量中的数据
cout << "姓名:" << p->name << "年龄:" << p->age << "分数:" << p->score << endl;
system("pause");
return 0;
}
总结
:结构体指针可以通过->操作符来访问结构体中的成员
8.5 结构体嵌套结构体
作用
:结构体中的成员可以是另一个结构体
例如
:每个老师辅导一个学员,一个老师的结构体中,记录一个学生的结构体
#include<iostream>
using namespace std;
#include<string>
// 定义学生结构体
struct student
{
string name; // 学生姓名
int age; // 学生年龄
int score; //考试分数
};
// 定义老师结构体
struct teacher
{
int id; // 教师编号
string name; // 教师姓名
int age; // 年龄
struct student stu;
};
int main()
{
// 创建老师结构体变量
struct teacher t;
t.id = 1000;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 20;
t.stu.score = 60;
cout << "教师姓名:" << t.name << "编号:" << t.id << "年龄:" << t.age << endl;
cout << "学生姓名:" << t.stu.name << "年龄:" << t.stu.age << "分数:" << t.stu.score << endl;
system("pause");
return 0;
}
8.6 结构体做函数参数
作用
:将结构体作为参数向函数中传递
传递方式有两种:
1.值传递
2.地址传递
#include<iostream>
using namespace std;
#include<string>
// 定义学生结构体
struct student
{
string name; // 学生姓名
int age; // 学生年龄
int score; //考试分数
};
// 1.值传递
void printStudentInfo(struct student s)
{
s.name = "哈哈";
cout << "子函数中:" << "学生姓名:" << s.name << "年龄:" << s.age << "分数:" << s.score << endl;
}
// 2.地址传递
void printStudentInfo2(struct student* s)
{
s->name = "哈哈";
cout << "子函数中:" << "学生姓名:" << s->name << "年龄:" << s->age << "分数:" << s->score << endl;
}
int main()
{
// 创建学生结构体变量
struct student s;
s.name = "张三";
s.age = 20;
s.score = 85;
printStudentInfo(s);
printStudentInfo2(&s);
cout << "main函数中:" << "学生姓名:" << s.name << "年龄:" << s.age << "分数:" << s.score << endl;
system("pause");
return 0;
}
总结
:如果不想修改主函数中的数据,用值传递,反之用地址传递
8.7 结构体中的const使用场景
作用
:用const来防止误操作
当进行值传递时,实参和形参不是同一份数据,而当函数为结构体时,结构体内有多个成员变量,就会拷贝多少份数据,加大了内存负担。
因此,使用指针进行地址传递就减少了内存占用, 指针只占4个字节,但是为了更改的误操作,对结构体指针进行const修饰,防止误操作。
#include<iostream>
using namespace std;
#include<string>
// const使用场景
// 定义学生结构体
struct student
{
string name; // 学生姓名
int age; // 学生年龄
int score; //考试分数
};
// 将函数中的形参改为指针,可以减少内存空间,并且不会复制出新的副本
void printStudentInfo(const struct student* s)
{
//s->name = "哈哈"; //加入const后,就可以防止更改操作
cout << "学生姓名:" << s->name << "年龄:" << s->age << "分数:" << s->score << endl;
}
int main()
{
// 创建学生结构体变量
struct student s = { "张三",20, 85 };
printStudentInfo(&s);
system("pause");
return 0;
}
二、C++核心编程
本阶段主要针对C++面向对象的编程技术
1.内存分区模型
C++程序在执行时,将内存大方向划分为4个区域:
1.
代码区:存放函数体的二进制代码,由操作系统进行管理的
2.
全局区:存放全局变量和静态变量以及常量
3.
栈区︰由编译器自动分配释放,存放函数的参数值,局部变量等
4.
堆区:由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收
内存四区意义
不同区域存放的数据,赋予不同的生命周期,给我们更大的灵活编程
1.1 程序运行前
在程序编译后,生成了exe可执行程序,未执行该程序前
分为两个区域
代码区:
存放CPU执行的机器指令
代码区是共享的,共享的目的是对于频繁被执行的程序,只需要在内存中有一份代码即可
代码区是只读的,使其只读的原因是防止程序意外地修改了它的指令
全局区:
全局变量和静态变量存放在此.
全局区还包含了常量区,字符串常量和其他常量(比如const修饰的)也存放在此.
该区域的数据在程序结束后由操作系统释放
只要带“局部”的,哪怕加了const进行修饰,也不在全局区。
#include<iostream>
using namespace std;
// 全局变量
int g_a = 10;
int g_b = 10;
const int c_g_a = 10;
const int c_g_b = 10;
int main()
{
// 全局区
// 全局变量、静态变量、常量
// 创建普通局部变量
int a = 10;
int b = 10;
cout << "局部变量a的地址为:" << (int)&a << endl;
cout << "局部变量b的地址为:" << (int)&b << endl;
/*局部变量a的地址为:9829476
局部变量b的地址为:9829476
*/
cout << "全局变量g_a的地址为:" << (int)&g_a << endl;
cout << "全局变量g_b的地址为:" << (int)&g_b << endl;
/*全局变量g_a的地址为:11976756
全局变量g_b的地址为:11976760
*/
// 静态变量 在普通变量前面加static,属于静态变量
static int s_a = 10;
static int s_b = 10;
cout << "静态变量s_a的地址为:" << (int)&s_a << endl;
cout << "静态变量s_b的地址为:" << (int)&s_b << endl;
/*静态变量s_a的地址为:11976764
静态变量s_b的地址为:11976768
*/
// 常量
// 字符串常量
cout << "字符串常量的地址为:" << (int)&"hello world" << endl;
// 字符串常量的地址为:11967324
// const修饰的变量
// const修饰的全局变量
cout << "全局常量c_g_a的地址为:" << (int)&c_g_a << endl;
cout << "全局常量c_g_b的地址为:" << (int)&c_g_b << endl;
/*全局常量c_g_a的地址为:11968136
全局常量c_g_b的地址为:11968140
*/
// const修饰的局部变量
const int c_1_a = 10;
const int c_1_b = 10;
cout << "局部常量c_g_a的地址为:" << (int)&c_1_a << endl;
cout << "局部常量c_g_b的地址为:" << (int)&c_1_b << endl;
/*局部常量c_g_a的地址为:9829452
局部常量c_g_b的地址为:9829440
*/
system("pause");
return 0;
}
总结:
1.
C++中在程序运行前分为全局区和代码区
2.
代码区特点是共篡和只读
3.
全局区中存放全局变量、静态变量、常量
4.
常量区中存放const修饰的全局常量和字符串常量
1.2 程序运行后
栈区:
由编译器自动分配释放,存放函数的参数值,局部变量等
注意事项:
不要返回局部娈量的地址,栈区开辟的数据由编译器自动释放
#include<iostream>
using namespace std;
int* func(int b) // 形参也是放在栈区的
{
b = 100;
int a = 10; //局部变量 存放在栈区,栈区的数据在函数执行完后自动释放
return &a; // 返回局部变量的地址
}
int main()
{
// 注意事项:不要返回局部娈量的地址,栈区开辟的数据由编译器自动释放
int* p = func(1);
// 第一次正确输出,是因为编译器做了保留
cout << *p << endl;
// 第二次不再保留了,输出产生乱码
cout << *p << endl;
system("pause");
return 0;
}
堆区:
曲程序员分配释放,若程序员不释放,程序结束时由操作系统回收
在C++中主要利用new
在堆区开辟内存
new
int (10)创建的数据,并不是把数据本身返回出来,而是把数据的地址
返回出来,所以用指针接受/
#include<iostream>
using namespace std;
int* func()
{
// 利用new关键字,可以将数据开辟到堆区
// 指针本质也是变量,放在栈上,只是指针保存的数据放在堆区
int* p = new int(10);
return p;
}
int main()
{
// 在堆区开辟数据
int* p = func();
cout << *p << endl;
system("pause");
return 0;
}
总结:
堆区数据由程序员管理开辟和释放堆区
数据利用new关键字进行开辟内存
1.3 new操作符
C++中利用new
操作符在堆区开辟数据
堆区开辟的数据,由程序员手动开辟,手动释放,释放利用操作符delete
语法:
new 数据类型
利用new创建的数据,会返回该数据对应的数据类型
的指针
#include<iostream>
using namespace std;
int* func()
{
// 在堆区创建整型数据
// new返回的是该数据类型的指针
int* p = new int(10);
return p;
}
void test01()
{
int* p = func();
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
// 堆区的数据 由程序员管理开发,管理释放
// 如果想释放, 利用关键字delete
delete p;
//cout << *p << endl; // 内存已经被释放,再次访问就是非法操作,会报错
}
// 2、在堆区利用new开辟数组
void test02()
{
// 创建10个整型数据的数组
int* arr = new int[10]; // []时,10代表数组有10个元素
for (int i = 0; i < 10; i++)
{
arr[i] = i + 100;
}
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
// 释放堆区数组
// 释放数组的时候,要加[]才可以
delete[] arr;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
2. 引用
2.1 引用的基本使用
作用:
给变量起别名
语法:
数据类型 &别名 = 原名
// 引用基本语法
// 数据类型 &别名 = 原名
int a = 10;
// 创建引用
int& b = a;
b = 20;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
2.2 引用的注意事项
1.
引用必须初始化
2.
引用在初始化后,不可以改变
int a = 10;
// 引用必须初始化
// int& b;
int& b = a;
// 引用在初始化后,不可以改变
// 创建引用
int c = 20;
b = c; //这是赋值操作,而不是更改引用
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
2.3 引用做函数参数
作用:
函数传参时,可以利用引用的技术让形参修饰实参
优点:
可以简化指针修改实参
#include<iostream>
using namespace std;
// 交换函数
// 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;
}
int main()
{
int a = 10;
int b = 20;
//mySwap01(a, b); // 值传递,形参并不会修饰实参
//mySwap02(&a, &b); // 地址传递,形参可以修饰实参
mySwap03(a, b); // 引用传递,形参可以修饰实参
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
总结:
通过引用参数产生的效果同按地址传递是—样的。引用的语法更清楚简单
2.4 引用做函数返回值
作用:
引用是可以作为函数的返回值存在的
注意:
不要返回局部变量引用
用法:
函数调用作为左值
#include<iostream>
using namespace std;
// 1.不返回局部变量的引用
int& test01()
{
int a = 10; //局部变量存在在四区中的栈区
return a;
}
int& test02()
{
static int a = 10; //静态变量存在在四区中的全局区,由系统管理释放
return a;
}
int main()
{
//int& ref = test01();
int& ref = test02();
cout << "ref = " << ref << endl; //第一次结果正确,是因为编译器做了保留
cout << "ref = " << ref << endl; //第二次结果不正确,是因为a的内存已经做了释放
// 2.如果函数的调用返回值是引用,函数的调用可以作为左值
test02() = 1000;
cout << "ref = " << ref << endl;
cout << "ref = " << ref << endl;
system("pause");
return 0;
}
2.5 引用的本质
本质:
引用的本质在c++内部实现是一个指针常量
总结:
C++推荐用引用技术,因为语法方便,引用本质是指针常量,但是所有的指针操作编译器都帮我们做了
2.6 常量引用
本质:
常量引用主要用来修饰形参,防止误操作
在函数形参列表中,可以加const修饰形参,防止形参改变实参
#include<iostream>
using namespace std;
void showValue(const int& val)
{
//val = 1; // 为了防止误操作,在形参之前加上const进行修饰
cout << "val = " << val << endl;
}
int main()
{
// 常量引用
// 使用场景:用来修饰形参,防止误操作
int a = 10;
//int& ref = 10; // 引用必须引一块合法的内存空间
// 加上const后,编译器将代码修改为 int temp 10; const int& ref = temp;
const int& ref = 10;
//ref = 20; // 加入const之后变为只读,不可以修改
int b = 100;
showValue(b);
system("pause");
return 0;
}
3. 函数提高
3.1 函数默认参数
在C++中,函数的形参列表中的形参是可以有默认值的。
语法:
返回值类型 函数名 (参数=默认值) {}
#include<iostream>
using namespace std;
// 函数默认参数
// 如果我们自己传入数据,就用自己的数据,如果没有,那么用默认值
// 语法:返回值类型 函数名(形参=默认值){}
// 注意事项
// 1.如果某个位置已经有了默认参数,那么从这个位置往后,从左到右都必须有默认值
int func(int a, int b = 20, int c = 30)
{
return a + b + c;
}
// 2.如果函数声明有默认参数,函数实现就不能有默认参数
// 声明和实现只能有一个有默认参数
int func2(int a = 10, int b = 10);
int func2(int a = 10, int b = 10)
{
return a + b;
}
int main()
{
//cout << func(10) << endl;
//cout << func(10, 30) << endl;
cout << func2(10, 30) << endl;
system("pause");
return 0;
}
3.2 函数占位参数
C++中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置
语法:
返回值类型 函数名(数据类型){}
#include<iostream>
using namespace std;
// 占位参数
// 返回值类型 函数名(数据类型){}
// 占位参数还可以有默认参数 void func(int a, int = 10)
void func(int a, int)
{
cout << "this is func" << endl;
}
int main()
{
func(10, 10); // 占位参数必须要补
system("pause");
return 0;
}
3.3 函数重载
3.3.1 函数重载概述
作用:
函数名可以相同,提高复用性
函数重载满足条件:
1.
同一个作用域下
2.
函数名称相同
3.
函数参数类型不同,或者个数不同,或者顺序不同
注意:
函数的返回值不可以作为函数重载的条件
#include<iostream>
using namespace std;
// 函数重载
// 可以让函数名相同,提高复用性
// 函数重载满足条件:
// 1.同一个作用域下
// 2.函数名称相同
// 3.函数参数类型不同,或者个数不同,或者顺序不同
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 b, int a)
{
cout << "func(double b, int a) 的调用" << endl;
}
// 注意事项:函数的返回值不可以作为函数重载的条件
// // 因为不管是void func还是int func,函数调用都是func(),就会产生歧义。
//int func(double b, int a)
//{
// cout << "void func(double b, int a) 的调用" << endl;
//}
int main()
{
func();
func(10);
func(3.14);
func(10, 3.14);
func(3.14, 10);
system("pause");
return 0;
}
3.3.2 函数重载的注意事项
函数重载满足条件:
1.
引用作为重载条件
2.
函数重载碰到函数默认参数
#include<iostream>
using namespace std;
// 函数重载满足条件:
// 1.引用作为重载条件
void func(int& a) // int& =10 不合法
{
cout << "func(int& a) 的调用" << endl;
}
void func(const int& a) // const int& =10 会创建一个temp临时空间,合法
{
cout << "func(const int& a) 的调用" << endl;
}
// 2.函数重载碰到函数默认参数
void func2(int a, int b = 10)
{
cout << "func2(int a, int b) 的调用" << endl;
}
void func2(int a)
{
cout << "func2(int a) 的调用" << endl;
}
int main()
{
// a是一个变量,可读可写,所以当引用作为重载条件时,编译器默认走void func(int& a)的版本
int a = 10;
// func(a); // 调用无const
// 相当于 int& =10,这个没有引用一个合法空间,编译器不会通过的,编译器默认走void func(const int& a)的版本
// func(10); // 调用有const
// func2(10); // 两种都能调,因为默认参数b可以不传形参,出现了歧义
system("pause");
return 0;
}
4. 面向对象
C++面向对象的三大特性为:封装、继承、多态
C++认为万事万物都皆为对象,对象上有其属性和行为
例如:
人可以作为对象,属性有姓名、年龄、身高、体重…,行为有走、跑、跳、吃饭、唱歌…
车也可以作为对象,属性有轮胎、方向盘、车灯…行为有载人、放音乐、放空调…
具有相同性质的对象
,我们可以抽象称为类
,人属于人类,车属于车类
4.1 封装
4.1.1 封装的意义
封装是C++面向对象三大特性之一
封装的意义:
1.
将属性和行为作为一个整体,表现生活中的事物
2.
将属性和行为加以权限控制
封装意义一:
在设计类的时候,属性和行为写在一起,表现事物
语法:
class 类名 { 访问权限 : 属性 / 行为 };
#include<iostream>
using namespace std;
// 设计一个圆类,求圆的周长
const double PI = 3.14;
// class代表设计一个类
class Circle
{
// 访问权限
// 公共权限
public:
// 类中的属性和行为我们统一称为:成员
// 属性 成员属性、成员变量
// 行为 成员函数、成员方法
// 属性
// 半径
int m_r;
// 行为
// 获取圆的周长
double calculateZC()
{
return 2 * PI * m_r;
}
// 也可设置一个给属性赋值的行为
void setR(int r)
{
m_r = r;
}
};
int main()
{
// 通过圆类 创建具体的圆(对象)
// 实例化 (通过一个类创建一个对象的过程)
Circle c1;
// 给圆对象的属性进行赋值
c1.m_r = 10;
cout << "圆的周长为:" << c1.calculateZC() << endl;
Circle c2;
c2.setR(20); // 通过定义好的属性给行为直接赋值
cout << "圆的周长为:" << c2.calculateZC() << endl;
system("pause");
return 0;
}
封装意义二:
类在设计时,可以把属性和行为放在不同的权限下,加以控制
访问权限有三种:
1.
public公共权限
2.
protected保护权限
3.
private私有权限
#include<iostream>
using namespace std;
// 访问权限, 三种:
// public 公共权限 成员, 类内可以访问,类外也可以访问
// protected 保护权限 成员, 类内可以访问,类外不可以访问 儿子可以访问父亲中的保护内容
// private 私有权限 成员, 类内可以访问,类外不可以访问 儿子不可以访问父亲中的保护内容
class Person
{
// 访问权限
public:
// 公共权限
string m_Name; // 姓名
protected:
// 保护权限
string m_Car; //汽车
private:
// 私有权限
int m_Password; //银行卡密码
public:
// 行为
void func()
{
m_Name = "张三";
m_Car = "拖拉机";
m_Password = 12346;
}
};
int main()
{
// 实例化具体对象
Person p1;
p1.m_Name = "李四";
//p1.m_Car = "奔驰"; //m_Car是保护权限,类外不可以访问
//p1.m_Password = 123; //m_Car是私有权限,类外不可以访问
system("pause");
return 0;
}
4.1.2 struct和class区别
在C++中struct和class唯一的区别就在于:
默认的访问权限不同
区别:
1.
struct 默认权限为公共
2.
class默认权限为私有
#include<iostream>
using namespace std;
// struct和class唯一的区别就在于默认的访问权限不同
// 1.struct 默认权限为公共
// 2.class 默认权限为私有
class C1
{
int m_A; // 默认权限为私有
};
struct C2
{
int m_A; // 默认权限为公共
};
int main()
{
C1 c1;
//c1.m_A = 100; // 私有权限,类外不可以访问
C2 c2;
c2.m_A = 100; // 公共权限,类外可以访问
system("pause");
return 0;
}
4.1.3 成员属性设置为私有
在C++中struct和class唯一的区别就在于:
优点1:
将所有成员属性设置为私有,可以自己控制读写权限
优点2:
对于写权限,我们可以检测数据的有效性
其实,就是将属性设置私有后,设置public接口函数来控制对属性的读与写的状态。
#include<iostream>
using namespace std;
// 成员属性设置为私有
// 1、将所有成员属性设置为私有,可以自己控制读写权限
// 2、对于写权限,我们可以检测数据的有效性
// 定义一个人类
class Person
{
public:
// 设置姓名
void setName(string name)
{
m_Name = name;
}
// 获取姓名
string getName()
{
return m_Name;
}
// 获取年龄
int getAge()
{
return m_Age;
}
// 设置年龄 用于2,检测数据有效性时,设置为可写,但是年龄必须在0-150之间
void setAge(int age)
{
if (age < 0 || age > 150)
{
cout << "年龄输入有误,赋值失败" << endl;
return;
}
m_Age = age;
}
// 设置偶像
void setIdol(string idol)
{
m_Idol = idol;
}
private:
string m_Name; // 姓名 可读可写
int m_Age =18; // 年龄 只读 用于2,检测数据有效性时,设置为可写,但是年龄必须在0-150之间
string m_Idol; // 偶像 只写
};
int main()
{
Person p;
// 姓名的设置
//p.m_Name = "张三";
p.setName("张三");
cout << "姓名为:" << p.getName() << endl; // 设置了可读可写状态
// 年龄的设置
//p.m_Age = 20; // 只设置了可读状态,不可写
cout << "年龄为:" << p.getAge() << endl;
// 偶像的设置
p.setIdol("小明");
//cout << "偶像为:" << p.m_Idol << endl; // 只设置了写的状态,不可读
// 用于2,检测数据有效性时,设置为可写,但是年龄必须在0-150之间
p.setAge(160);
cout << "年龄为:" << p.getAge() << endl; //输出仍为18
system("pause");
return 0;
}
补充:
和结构体类似,类里面还可以让另一个类来作为本类中的成员!!!
4.1.4 类的分文件编写
1.
首先,先在头文件中进行类的申明,将所有成员函数的函数体去掉,只留下申明就行。
其实,类的分文间编写和上面的函数分文件编写类似,只要管函数就行。
#pragma once //防止头文件重复申明
#include<iostream>
using namespace std;
class Circle
{
public:
// 成员行为只留下函数的申明就行
// 设置半径
void setR(int r);
// 获取半径
int getR();
private:
int m_R; //半径
};
2.
接着,进行函数体的实现,新建.cpp文件
进行头文件的导入,类的申明中成员属性也不用管,只要实现成员函数的实现就行,在每个函数名之前加上函数的作用域
(不然就是全局函数,是不对的),最后进行一个缩进就完成了。
#include"circle.h"
// 设置半径
void Circle::setR(int r)
{
m_R = r;
}
// 获取半径
int Circle::getR()
{
return m_R;
}
4.2 对象的初始化和清理
1.
生活中我们买的电子产品都基本会有出厂设置,在某一天我们不用时候也会删除一些自己信息数据保证安全
2.
C++中的面向对象来源于生活,每个对象也都会有初始设置以及对象销毁前的清理数据的设置。
4.2.1 构造函数和析构函数
1.
对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态,对其使用后果是未知
2.
同样的使用完一个对象或变量,没有及时清理,也会造成—定的安全问题
C++利用了构造函数
和析构函数
解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制
要我们做的事情,因此如果我们不提供构造和析构,编译器会提供
编译器提供的构造函数和析构函数是空实现
。
构造函数:
主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
析构函数:
主要作用在于对象销毁前系统自动调用,执行一些清理工作。
构造函数语法:
类名() {}
1.
构造函数,没有返回值也不写void
2.
函数名称与类名相同
3.
构造函数可以有参数,因此可以发生重载
4.
程序在调用对象时候会自动调用构造,无须手动调用,而且只会调用一次
析构函数语法:
~类名() {}
1.
析构函数,没有返回值也不写void
2.
函数名称与类名相同,在名称前加上符号~
3.
析构函数不可以有参数,因此不可以发生重载
4.
程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用—次
#include<iostream>
using namespace std;
// 对象的初始化和清理
class Person
{
public:
// 1.构造函数 进行初始化操作
// 没有返回值也不写void
// 函数名称与类名相同
// 构造函数可以有参数,因此可以发生重载
// 创建对象时,构造函会自动调用,而且只会调用一次
Person()
{
// 不写,也会有构造函数,只不过是空实现
cout << "Person 构造函数的调用" << endl;
}
// 2.析构函数 进行清理的操作
// 没有返回值也不写void
// 函数名称与类名相同,在名称前加上符号~
// 析构函数不可以有参数,因此不可以发生重载
// 对象销毁前,析构函会自动调用,而且只会调用一次
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
};
// 构造和析构都是必须有的实现,如果我们自己不提供,编译器会提供一个空实现的构造和析构
void test01()
{
Person p; // 这个对象创建在栈区,test01()执行完毕后,编译器释放这个对象
}
int main()
{
//test01();
Person p; //将对象创建main()中,只有按任意键继续结束程序后,才会调用析构
system("pause");
return 0;
}
4.2.2 构造函数的分类及调用
两种分类方式:
按参数分为:
有参构造和无参构构造
按类型分为:
普通构造和拷贝构造
三种调用方式:
1.
括号法
2.
显示法
3.
隐式转换法
#include<iostream>
using namespace std;
// 1.构造函数的分类及调用
// 分类
// 按参数分为:有参构造和无参构构造
// 按类型分为:普通构造和拷贝构造
class Person
{
public:
// 构造函数
Person()
{
cout << "Person 无参构造函数调用" << endl;
}
// 有参构造
Person(int a)
{
m_Age = a;
cout << "Person 有参构造函数调用" << endl;
}
// 拷贝构造函数
Person(const Person &p)
{
cout << "Person 拷贝构造函数调用" << endl;
// 将传入的对象身上的所有属性,拷贝到身上
m_Age = p.m_Age;
}
// 析构函数
~Person()
{
cout << "Person 析构函数调用" << endl;
}
int m_Age; //年龄
};
// 调用
void test01()
{
// 1.括号法
//Person p1; // 默认构造函数调用
//Person p2(10); // 有参构造函数调用
//Person p3(p2);
// 注意事项:调用默认构造函数时候,不要加()
// 因为下面这行代码,编译器会认为是一个函数的声明,不会认为在创建对象|
//Person p1();
//cout << "p2的年龄" << p2.m_Age << endl;
//cout << "p3的年龄" << p3.m_Age << endl;
// 2.显示法
//Person p1;
//Person p2 = Person(10);
//Person p3 = Person(p2);
//Person(10); // 为匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名对象
//Person(p3); // 不要利用拷贝构造函数初始化匿名对象 编译器会认为Person (p3)=== Person p3;编译器会认为这是一个对象的申明
// 3.隐式转换法
Person p4 = 10; // 相当于写了Person p4 = Person(10); 有参构造
Person p5 = p4; // 拷贝构造
}
int main()
{
test01();
system("pause");
return 0;
}
4.2.3 拷贝构造函数的调用时机
C++中拷贝构造函数调用时机通常有三种情况
1.
使用一个已经创建完毕的对象来初始化—个新对象
2.
值传递的方式给函数参数传值
3.
以值方式返回局部对象
#include<iostream>
using namespace std;
// C++中拷贝构造函数调用时机通常有三种情况:
class Person
{
public:
Person()
{
cout << "Person 默认构造函数调用" << endl;
}
Person(int age)
{
m_Age = age;
cout << "Person 有参构造函数调用" << endl;
}
Person(const Person& p)
{
m_Age = p.m_Age;
cout << "Person 拷贝构造函数调用" << endl;
}
~Person()
{
cout << "Person 析构构造函数调用" << endl;
}
int m_Age;
};
// 1.使用一个已经创建完毕的对象来初始化—个新对象
void test01()
{
Person p1(20);
Person p2(p1);
cout << "p2的年龄为:" << p2.m_Age << endl;
}
// 2.值传递的方式给函数参数传值
void doWork(Person p) //值传递时,形参会拷贝一个副本出来,也就是调用了拷贝构造函数
{
}
void test02()
{
Person p;
doWork(p);
}
// 3.以值方式返回局部对象
Person doWork2()
{
Person p1; // 调用默认构造,是一个局部对象
cout << (int*)&p1 << endl;
return p1; // 返回对象的不是p1这个局部对象,而是会拷贝一个新的对象返回出来
}
void test03()
{
Person p = doWork2();
cout << (int*)&p << endl;
}
int main()
{
//test01();
//test02();
test03();
system("pause");
return 0;
}
4.2.4 构造函数的调用规则
默认情况下,C++编译器至少给一个类添加3个函数
1.
默认构造函数(无参,函数体为空)
2.
默认析构函数(无参,函数体为空)
3.
默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
1.
如果用户定义有参构造函数,c++不再提供默认无参构造,但是会提供默认拷贝构造
2.
如果用户定义拷贝构造函数,c++不再提供其他构造函数
#include<iostream>
using namespace std;
// 构造函数的调用规则
// 1.创建一个类,C++编译器至少给一个类添加3个函数
// 默认构造 (空实现)
// 析构函数 (空实现)
// 拷贝构造 (值拷贝)
// 2.如果我们写了有参构造函数,编译器就不再提供默认构造,依然提供拷贝构造
// 如果我们写了拷贝构造函数,编译器就不再提供其他普通构造函数了,因此我们必须进行写。
class Person
{
public:
// 如果写了有参构造,编译器就不再提供默认构造,我们将默认构造注释,就会报错
/*Person()
{
cout << "Person 默认构造函数调用" << endl;
}*/
Person(int age)
{
cout << "Person 有参构造函数调用" << endl;
m_Age = age;
}
// 拷贝构造函数即使注释了,仍然可以,因为编译器默认提供了拷贝构造
/*Person(const Person& p)
{
m_Age = p.m_Age;
cout << "Person 拷贝构造函数调用" << endl;
}*/
~Person()
{
cout << "Person 析构构造函数调用" << endl;
}
int m_Age;
};
//void test01()
//{
// Person p;
// p.m_Age = 18;
// Person p2(p);
// cout << "p2的年龄是:" << p2.m_Age << endl;
//}
void test02()
{
Person p(10);
Person p2(p);
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
4.2.5 深拷贝与浅拷贝
深浅拷贝是面试经典问题,也是常见的一个坑
浅拷贝:
简单的赋值拷贝操作(编辑器提供的拷贝构造函数的赋值操作)
深拷贝:
在堆区重新申请空间,进行拷贝操作
#include<iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "Person 默认构造函数调用" << endl;
}
Person(int age, int height)
{
m_Age = age;
m_Height = new int(height);
cout << "Person 有参构造函数调用" << endl;
}
~Person()
{
// 析构代码,将堆区开辟数据做释放操作
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL; // 为了防止野指针的操作,进行置空的规范 操作
}
cout << "Person 析构函数调用" << endl;
}
int m_Age; //年龄
int* m_Height; //身高
};
void test01()
{
Person p1(18, 160);
cout << "p1的年龄是:" << p1.m_Age << "身高为:" << *p1.m_Height << endl;
Person p2(p1);
cout << "p2的年龄是:" << p2.m_Age << "身高为:" << *p2.m_Height << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
上述代码,Person p2(p1),仅仅编辑器提供的拷贝构造函数的赋值操作,是“浅拷贝”
,由于p1是栈区数据,“先进后出”
,所以p2先进行析构代码进行释放 ,随后p1也进行1次析构代码进行释放就会报错,因为这块堆区开辟的内存空间进行在p1释放了。重复释放,属于“非法操作”
。
“浅拷贝”
的问题要利用“深拷贝”
进行解决。不使用编辑器提供的拷贝构造函数,重新写一个。
“深拷贝”
就是:让p2重新指向一个新的内存空间,但是两个内存空间的数据是一样的
#include<iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "Person 默认构造函数调用" << endl;
}
Person(int age, int height)
{
m_Age = age;
m_Height = new int(height);
cout << "Person 有参构造函数调用" << endl;
}
// 自己实现拷贝构造函数解决浅拷贝带来的问题
Person(const Person& p)
{
cout << "Person 拷贝构造函数调用" << endl;
m_Age = p.m_Age;
//m_Height = p.m_Height; // 编译器默认实现就是这行代码,问题就出现在堆区的指针
// 深拷贝操作,编译器默认的赋值浅拷贝操作就是:m_Height = p.m_Height;这就会造成析构函数重复释放内存的问题。
m_Height = new int(*p.m_Height);
}
~Person()
{
// 析构代码,将堆区开辟数据做释放操作
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL; // 为了防止野指针的操作,进行置空的规范 操作
}
cout << "Person 析构函数调用" << endl;
}
int m_Age; //年龄
int* m_Height; //身高
};
void test01()
{
Person p1(18, 160);
cout << "p1的年龄是:" << p1.m_Age << "身高为:" << *p1.m_Height << endl;
Person p2(p1);
cout << "p2的年龄是:" << p2.m_Age << "身高为:" << *p2.m_Height << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
4.2.6 初始化列表
作用:
C++提供了初始化列表语法,用来初始化属性
语法:
构造函数()∶属性1(值1),属性2(值2) …{}
#include<iostream>
using namespace std;
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)
{
}
// 更灵活的写法
Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
{
}
int m_A;
int m_B;
int m_C;
};
void test01()
{
//Person p(10, 20, 30);
Person p;
}
int main()
{
test01();
system("pause");
return 0;
}
4.2.7 类对象做类成员
C++类中的成员可以是另一个类的对象,我们称该成员为对象成员
例如:
class A {};
class B
{
A a;
};
B类中有对象A作为成员,A为对象成员
那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后?
#include<iostream>
using namespace std;
class Phone
{
public:
Phone(string pName)
{
m_pName = pName;
cout << "Phone 构造函数调用" << endl;
}
~Phone()
{
cout << "Phone 析构函数调用" << endl;
}
string m_pName;
};
class Person
{
public:
Person(string name, string pName):m_Name(name), m_Phone(pName)
{
cout << "Person 构造函数调用" << endl;
}
~Person()
{
cout << "Person 析构函数调用" << endl;
}
string m_Name; //姓名
Phone m_Phone;
};
// 当其他类对象作为本类成员,构造时候先构造类对象,再构造自身
// 析构的顺序与构造相反
void test01()
{
Person p("张三", "苹果max");
cout << p.m_Name << "拿了" << p.m_Phone.m_pName << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
4.2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员
静态成员分为:
静态成员变量
1.
所有对象共享同一份数据。
2.
在编译阶段分配内存。
3.
类内声明,类外初始化
#include<iostream>
using namespace std;
// 静态成员变量
class Person
{
public:
// 1.所有对象都共享同一份数据
// 2.编译阶段就分配内存
// 3.类内声明,类外初始化操作
static int m_A;
// 静态成员变量也是有访问权限的
private:
static int m_B;
};
int Person::m_A = 100;
int Person::m_B = 200;
void test01()
{
Person p;
cout << p.m_A << endl;
Person p2;
p2.m_A = 200;
cout << p.m_A << endl;
}
void test02()
{
// 静态成员变量不属于某个对象上,所有对象都共享同一份数据
// 因此静态成员变量有两种访问方式
// 1.通过对象访问
Person p;
cout << p.m_A << endl;
// 2.通过类名进行访问
cout << Person::m_A << endl;
//cout << Person::m_B << endl; // private权重,类外不可以访问
}
int main()
{
test01();
system("pause");
return 0;
}
静态成员函数
1.
所有对象共享同一个函数
2.
静态成员函数只能访问静态成员变量
#include<iostream>
using namespace std;
// 静态成员函数
// 1.所有对象共享同一个函数
// 2.静态成员函数只能访问静态成员变量
class Person
{
public:
static void func()
{
m_A = 200; // 静态成员函数可以访问静态成员变量
//m_B = 300; // 静态成员函数不可以访问非静态成员变量, 无法区分到底是哪个对象的
cout << "static void func()调用" << endl;
}
static int m_A;
int m_B; // 非静态成员变量
// 静态成员函数也是有访问权限的I
private:
static void func2()
{
cout << "static void func2()调用" << endl;
}
};
int Person::m_A = 100;
void test01()
{
// 1.通过对象访问
Person p;
p.func();
// 2.通过类名进行访问
Person::func();
//Person::func2(); // 类外访问不到私有静态成员函数
}
int main()
{
test01();
system("pause");
return 0;
}
4.3 C++对象模型和this指针
4.3.1 成员变量和成员函数分开存储
在C++中,类内的成员变量和成员函数分开存储
只有非静态成员变量
才属于类的对象上
#include<iostream>
using namespace std;
// 成员变量和成员函数分开存储
class Person
{
int m_A; //非静态成员变量, 属于类的对象上
static int m_B; // 静态成员变量,不属于类的对象上
void func() // 非静态成员函数,不属于类的对象上
{
}
static void func2() //静态成员函数,不属于类的对象上
{
}
};
void test01()
{
Person p;
// 空对象占用内存空间为:1
// C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
// 每个空对象也应该有一个独一无二的内存地址
cout << "size of p = " << sizeof(p) << endl;
}
void test02()
{
Person p;
cout << "size of p = " << sizeof(p) << endl;
}
int Person::m_B = 100;
int main()
{
//test01();
test02();
system("pause");
return 0;
}
4.3.2 this指针
在C++中,类内的成员变量和成员函数分开存储
只有才属于类的对象上
我们知道在C++中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例,也就是说多个同类型的对象会共用一块代码
那么问题是:这—块代码是如何区分那个对象调用自己的呢?
C++通过提供特殊的对象指针,this指针
,解决上述问题。this指针
指向被调用的成员函数所属的对象
this指针
是隐含每一个非静态成员函数内的一种指针
this指针
不需要定义,直接使用即可
this指针
的用途:
1.
当形参和成员变量同名时,可用this指针来区分
2.
在类的非静态成员函数中返回对象本身,可使用return *this
#include<iostream>
using namespace std;
// 成员变量和成员函数分开存储
class Person
{
public:
Person(int age)
{
//age = age; //这么写会乱码,编译器会认为这3个age(包括形参是同一份)
this->age = age;
}
Person& PersonAddAge(Person& p)
{
this->age += p.age;
// this指向p2的指针,而*this指向的就是p2这个对象本体
return *this;
}
int age;
};
// 1.解决名称冲突
void test01()
{
Person p1(18);
cout << "p1的年龄为:" << p1.age << endl;
}
// 2.返回对象本身用*this
void test02()
{
Person p1(18);
Person p2(20);
// 链式编程思想
p2.PersonAddAge(p1).PersonAddAge(p1);
cout << "p2的年龄为:" << p2.age << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
4.3.3 空指针访问成员函数
C++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针
如果用到this指针,需要加以判断保证代码的健壮性
#include<iostream>
using namespace std;
// 空指针调用成员函数
class Person
{
public:
void showClassName()
{
cout << "this is Person class" << endl;
}
void showPersonAge()
{
// m_Age前面其实默认是this->m_Age,但此时this指向NULL,所以报错
//如果用到this指针,可以加以判断保证代码的健壮性
if (this == NULL)
{
return;
}
cout << "age = " << m_Age << endl;
}
int m_Age;
};
void test01()
{
Person* p = NULL;
p->showClassName();
//p->showPersonAge();
}
int main()
{
test01();
system("pause");
return 0;
}
4.3.4 const修饰成员函数
常函数:
1.
成员函数后加const后我们称为这个函数为常函数
2.
常函数内不可以修改成员属性
3.
成员属性声明时加关键字mutable后,在常函数中依然可以修改
常对象:
1.
声明对象前加const称该对象为常对象
2.
常对象只能调用常函数
#include<iostream>
using namespace std;
class Person
{
public:
// 常函数
// this指针的本质是指针常量,指针的指向是不可以修改的
// Person* const this;
// 如果想让指针指向的值也不可以修改,就:const Person* const this;就写在void showPerson() const
void showPerson() const
{
//m_A = 100; // 其实是this->m_A = 100;
//this = NULL; // this指针不可以修改指针的指向的
this->m_B = 200;
}
int m_A;
mutable int m_B; // 特殊变量,即使在常函数中,也可以修改这个值,加关键字mutable
};
void test01()
{
Person p;
p.showPerson();
}
// 常对象
void test02()
{
const Person p; // 在对象前加const,变为常对象
//p.m_A = 100;
p.m_B = 100; // m_B是特殊值,在常对象下也可以修改
// 常对象只能调用常函数
// 常对象不可以调用普通成员函数,因为普通成员函数可以修改属性
p.showPerson();
}
int main()
{
//test01();
system("pause");
return 0;
}
4.4 友元
生活中你的家有客厅(Public),有你的卧室(Private)
客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去
但是呢,你也可以允许你的好闺蜜好基友进去。
在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问,就需要用到友元
的技术
友元
的目的就是让一个函数或者类访问另—个类中私有成员
友元
的关键字为friend
友元的三种实现
1.
全局函数做友元
#include<iostream>
using namespace std;
//房屋类
class Building
{
// 让全局函数goodGay访问Buildin类中的私有成员
friend void goodGay(Building* building);
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
string m_SittingRoom; // 客厅
private:
string m_BedRoom; // 卧室
};
// 全局函数
void goodGay(Building* building)
{
cout << "正在访问:" << building->m_SittingRoom << endl;
// 私有属性在类外不可以访问,需要用到友元friend
cout << "正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
Building building;
goodGay(&building);
}
int main()
{
test01();
system("pause");
return 0;
}
2.
类做友元
#include<iostream>
using namespace std;
class Building
{
// GoodGay类是本来的好朋友,可以访问本类中私有成员
friend class GoddGay;
public:
Building();
string m_SittingRoom; // 客厅
private:
string m_BedRoom; // 卧室
};
// 类做友元
class GoddGay
{
public:
GoddGay();
void visit(); // 参观函数访问Building中的属性
Building* building;
};
// 另一种写法:类内申明,类外写成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoddGay::GoddGay()
{
building = new Building;
}
void GoddGay::visit()
{
cout << "GoddGay类正在访问:" << building->m_SittingRoom << endl;
cout << "GoddGay类正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
GoddGay gg;
gg.visit();
}
int main()
{
test01();
system("pause");
return 0;
}
3.
成员函数做友元
#include<iostream>
using namespace std;
class Building;
class GoddGay
{
public:
GoddGay();
void visit(); // 让visit函数可以访问Building中私有成员
void visit2(); // 让visit2函数可以访问Building中私有成员
Building* building;
};
class Building
{
// 告诉编译器GoodGay类下的visit成员函数作为本类的好朋友,可以访问私有成员
friend void GoddGay::visit();
public:
Building();
string m_SittingRoom; // 客厅
private:
string m_BedRoom; // 卧室
};
// 另一种写法:类内申明,类外写成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoddGay::GoddGay()
{
building = new Building;
}
void GoddGay::visit()
{
cout << "visit()正在访问:" << building->m_SittingRoom << endl;
cout << "visit()正在访问:" << building->m_BedRoom << endl;
}
void GoddGay::visit2()
{
cout << "visit2()正在访问:" << building->m_SittingRoom << endl;
//cout << "visit2()正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
GoddGay gg;
gg.visit();
gg.visit2();
}
int main()
{
test01();
system("pause");
return 0;
}
4.5 运算符重载
运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
4.5.1 加号运算符重载
作用:
实现两个自定义数据类型相加的运算
#include<iostream>
using namespace std;
// 加号运算符重载
class Person
{
public:
// 1.成员函数重载+号
Person operator+(Person& p)
{
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
int m_A;
int m_B;
};
// 2.全局函数重载+号
//Person operator+(Person& p1, Person& p2)
//{
// Person temp;
// temp.m_A = p1.m_A + p2.m_A;
// temp.m_B = p1.m_B + p2.m_B;
// return temp;
//}
// 3.函数重载的版本
Person operator+(Person& p1, int num)
{
Person temp;
temp.m_A = p1.m_A + num;
temp.m_B = p1.m_B + num;
return temp;
}
void test01()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
// 成员函数重载本质调用
//Person p3 = p1.operator+(p2);
Person p3 = p1 + p2;
// 全局函数重载本质调用
//Person p3 = operator+(p1, p2);
cout << "p3.m_A=" << p3.m_A << "p3.m_B" << p3.m_B << endl;
// 运算符重载也可以发生函数重载
// 比如上面形参是传的两个对象的引用,下面这个就是1个对象的引用+整型
Person p4 = p1 + 100;
cout << "p4.m_A=" << p4.m_A << "p4.m_B" << p4.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结1:
对于内置的数据类型的表达式的的运算符是不可能改变的
总结2:
不要滥用运算符重载
4.5.2 左移运算符重载
作用:
可以输出自定义数据类型
#include<iostream>
using namespace std;
// 左移运算符重载
class Person
{
private:
// 改成private权限后,
friend ostream& operator<<(ostream& cout, Person& p);
//public:
// 利用成员函数重载左移运算符
// 起初写代码时,不知道返回类型,就先写void
// 类似上述+号重载,void operator<<(Person& p),p.operator<<p2肯定不对
// void operator<<(cout)也不对,p<<cout,cout在p的左边,我们要是cout << p;
// 因此,通常不会利用成员函数重载<<运算符,因为无法实现cout在左侧
/*void operator<<(cout)
{
}*/
int m_A;
int m_B;
};
// 只能利用全局函数重载左移运算符
ostream& operator<<(ostream& cout, Person& p) // 本质:operator<<(cout, p),简化:cout<<p
{
cout << "p.m_A=" << p.m_A << "p.m_B=" << p.m_B;
return cout;
}
void test01()
{
Person p;
p.m_A = 10;
p.m_B = 10;
// 直接cout<<p 会报错,因为编译器不知道怎么输出p这个数据类型
// 以ostream&返回cout,就可以以链式编程思想继续<<,(ostream& cout, Person& p)
cout << p << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
重载左移运算符配合友元可以实现输出自定义数据类型
4.5.3 递增运算符重载
作用:
通过重载递增运算符,实现自己的整型数据
#include<iostream>
using namespace std;
// 重载递增运算符
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger& myint);
public:
MyInteger()
{
m_Num = 0;
}
// 重载前置++运算符 返回引用为了一直对一个数据进行递增操作
MyInteger& operator++()
{
// 先进行++运算
m_Num++;
// 再将自身进行返回
return *this;
}
// 重载后置++运算符 int代表占位参数,可以用于区分前置和后置递增
// temp是一个局部变量,返回MyInteger&就是非法操作了,所以后置递增要返回值(而不是引用)
MyInteger& operator++(int)
{
// 先记录当时结果
MyInteger& temp = *this;
// 后递增
m_Num++;
// 最后将记录结果做返回
return temp;
}
private:
int m_Num;
};
// 重载<<运算符
ostream& operator<<(ostream& cout, MyInteger& myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
// 直接cout<<myint 会报错,因为编译器不知道怎么输出myint这个数据类型
cout << ++(++myint) << endl;
cout << myint << endl;
}
void test02()
{
MyInteger myint;
cout << myint++ << endl;
cout << myint << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
作用:
前置递增返回引用,后置递增返回值
4.5.4 赋值运算符重载
C++编译器至少给一个类添加4个函数
1.
默认构造函数(无参,函数体为空)
2.
默认析构函数(无参,函数体为空)
3.
默认拷贝构造函数,对属性进行值拷贝
4.
.赋值运算符operator=,对属性进行值拷贝
如果类中有属性指向堆区,做赋值操作时也会出现深浅拷贝问题
#include<iostream>
using namespace std;
class Person
{
public:
Person(int age)
{
m_Age = new int(age);
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
// 重载赋值运算符
Person& operator=(Person& p)
{
// 编译器是提供浅拷贝
//this->m_Age = p.m_Age;
// 应该先判断是否有属性在堆区,如果有先释放干净,然后再深拷贝
if (this->m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
// 深拷贝操作
this->m_Age = new int(*p.m_Age);
return *this;
}
int* m_Age;
};
void test01()
{
Person p1(18);
cout << *p1.m_Age << endl;
Person p2(20);
p2 = p1; // 看似没问题,但是new开辟的数据是在堆区,由程序员手动释放,所以得在析构函数中进行释放
cout << *p2.m_Age << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
4.5.5 关系运算符重载
作用:
重载关系运算符,可以让两个自定义类型对象进行对比操作
#include<iostream>
using namespace std;
class Person
{
public:
Person(string name, int age)
{
m_Name = name;
m_Age = age;
}
// 重载关系运算符
bool operator==(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
return false;
}
string m_Name;
int m_Age;
};
void test01()
{
Person p1("Tom", 18);
Person p2("Tom", 28);
if (p1 == p2)
{
cout << "p1和p2相等" << endl;
}
else
{
cout << "p1和p2不相等" << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
4.5.6 函数调用运算符重载
1.
函数调用运算符()也可以重载
2.
由于重载后使用的方式非常像函数的调用,因此称为仿函数
3.
仿函数没有固定写法,非常灵活
#include<iostream>
using namespace std;
#include<string>
// 打印输出类
class Myprint
{
public:
// 重载函数调用运算符
void operator()(string test)
{
cout << test << endl;
}
};
void Myprint2(string test)
{
cout << test << endl;
}
void test01()
{
Myprint myprint;
// 由于使用起来非常类似于函数调用,因此称为仿函数
myprint("hello world");
Myprint2("hello world");
}
// 仿函数非常灵活,没有固定写法
class MyAdd
{
public:
int operator()(int num1, int num2)
{
return num1 + num2;
}
};
void test02()
{
MyAdd myadd;
int ret = myadd(10, 20);
cout << ret << endl;
// 匿名函数对象
cout << MyAdd()(100, 100) << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
4.6 继承
继承
是面向对象三大特性之一
有些类与类之间存在特殊的关系,例如下图中:
我们发现,定义这些类时,下级别的成员除了拥有上一级的共性
,还有自己的特性
。这个时候我们就可以考虑利用继承
的技术,减少重复代码
。
4.6.1 继承的语法
例如我们看到很多网站中,都有公共的头部,公共的底部,甚至公共的左侧列表,只有中心内容不同。
接下来我们分别利用普通写法和继承
的写法来实现网页中的内容,看一下继承
存在的意义以及好处。
#include<iostream>
using namespace std;
#include<string>
// 普通实现页面
// Java页面
//class Java
//{
//public:
// void header()
// {
// cout << "首页、公开课、登录、注册...(公共头部)" << endl;
// }
// void footer()
// {
// cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
// }
// void left()
// {
// cout << "Java、Python、C++、...(公共分类列表)" << endl;
// }
// void content()
// {
// cout << "Java学科" << endl;
// }
//};
// Python页面
//class Python
//{
//public:
// void header()
// {
// cout << "首页、公开课、登录、注册...(公共头部)" << endl;
// }
// void footer()
// {
// cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
// }
// void left()
// {
// cout << "Java、Python、C++、...(公共分类列表)" << endl;
// }
// void content()
// {
// cout << "Python学科" << endl;
// }
//};
// C++页面
//class CPP
//{
//public:
// void header()
// {
// cout << "首页、公开课、登录、注册...(公共头部)" << endl;
// }
// void footer()
// {
// cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
// }
// void left()
// {
// cout << "Java、Python、C++、...(公共分类列表)" << endl;
// }
// void content()
// {
// cout << "CPP学科" << endl;
// }
//};
// 继承实现
// 继承的好处:减少重复代码
// 语法:class 子类:继承方式 父类
// 子类 也称为 派生类
// 父类 也称为基类
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册...(公共头部)" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java、Python、C++、...(公共分类列表)" << endl;
}
};
// Java
class Java : public BasePage
{
public:
void content()
{
cout << "Java学科" << endl;
}
};
// Python
class Python : public BasePage
{
public:
void content()
{
cout << "Python学科" << endl;
}
};
// CPP
class CPP : public BasePage
{
public:
void content()
{
cout << "CPP学科" << endl;
}
};
void test01()
{
cout << "Java如下:" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "Python如下:" << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "CPP如下:" << endl;
CPP cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.content();
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
继承的好处:可以减少重复的代码
语法:
class A : public B;
A类称为子类
或派生类
,B类称为父类
或基类
派生类中的成员,包含两大部分:
一类是从基类继承过来的,一类是自己增加的成员。
从基类继承过过来的表现其共性
,而新增的成员体现了其个性
。
4.6.2 继承的方式
继承的语法:
class 子类 : 继承方式 父类
继承方式—共有三种:
1.
公共继承
2.
保护继承
3.
私有继承
#include<iostream>
using namespace std;
#include<string>
// 继承方式
class Base1
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
// 公共继承
class Son1 : public Base1
{
public:
void func()
{
m_A = 10; // 父类中的公共权限成员到子类中依然是公共权限
m_B = 20; // 父类中的保护权限成员到子类中依然是保护权限
//m_C = 30; // 父类中的私有权限成员,子类访问不到
}
};
void test01()
{
Son1 s1;
s1.m_A = 10;
//s1.m_B = 10; // 到Son1中是保护权限, 类外访问不到
}
// 保护继承
class Son2 : protected Base1
{
public:
void func()
{
m_A = 10; // 父类中的公共权限成员,到子类中是保护权限
m_B = 20; // 父类中的保护权限成员,到子类中依然是保护权限
//m_C = 30; // 父类中的私有权限成员,子类访问不到
}
};
void test02()
{
Son2 s2;
//s2.m_A = 10; // 到Son2中是保护权限, 类外访问不到
//s2.m_B = 100; // 到Son2中是保护权限, 类外访问不到
}
// 私有继承
class Son3 : private Base1
{
public:
void func()
{
m_A = 10; // 父类中的公共权限成员,到子类中变为私有权限
m_B = 20; // 父类中的保护权限成员,到子类中变为私有权限
//m_C = 30; // 父类中的私有权限成员,子类访问不到
}
};
void test03()
{
Son3 s3;
//s3.m_A = 10; // 到Son3中是私有权限, 类外访问不到
//s3.m_B = 100; // 到Son3中是私有权限, 类外访问不到
}
int main()
{
test01();
system("pause");
return 0;
}
4.6.3 继承中的对象模型
问题:
从父类继承过来的成员,哪些属于子类对象中?
#include<iostream>
using namespace std;
#include<string>
// 继承中的对象模型
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C; // 私有成员只是被隐藏了,但是还是会继承下去
};
// 公共继承
class Son : public Base
{
public:
int m_D;
};
void test01()
{
// 父类中所有非静态成员属性都会被子类继承下去
// 父类中私有成员属性是被编译器给隐藏了,因此是访问不到,但是确实被继承下去了
cout << "sizeof(Son) = " << sizeof(Son) << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
打开VS开发人员命令提示符
进入到创建的c++的.cpp文件所在路径:
cl /dl reportSingleClassLayout 类名文件名
cl /d1 reportSingleClassLayoutSon main.cpp
总结:
父类中私有成员也是被子类继承下去了,只是由编译器给隐藏后访问不到
4.6.4 继承中构造和析构顺序
子类继承父类后,当创建子类对象,也会调用父类的构造函数
问题:
父类和子类的构造和析构顺序是谁先谁后?
#include<iostream>
using namespace std;
#include<string>
// 继承中构造和析构顺序
class Base
{
public:
Base()
{
cout << "Base构造函数!" << endl;
}
~Base()
{
cout << "Base析构函数!" << endl;
}
};
// 公共继承
class Son : public Base
{
public:
Son()
{
cout << "Son构造函数!" << endl;
}
~Son()
{
cout << "Son析构函数!" << endl;
}
};
void test01()
{
// 继承中的构造和析构顺序如下:
// 先构造父类,再构造子类,析构的顺序与构造的顺序相反
Son s1;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
继承中先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反。
4.6.5 继承同名成员处理方式
子类继承父类后,当创建子类对象,也会调用父类的构造函数
问题:
当子类与父类出现同名的成员,如何通过子类对象,访问到子类或父类中同名的数据呢?
1.
访问子类同名成员直接访问即可
2.
访问父类同名成员需要加作用域
#include<iostream>
using namespace std;
#include<string>
// 继承中同名成员处理
class Base
{
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base - func()调用" << endl;
}
void func(int a)
{
cout << "Base - func(int a)调用" << endl;
}
int m_A;
};
// 公共继承
class Son : public Base
{
public:
Son()
{
m_A = 200;
}
void func()
{
cout << "Son - func()调用" << endl;
}
int m_A;
};
// 同名成员属性处理
void test01()
{
Son s1;
cout << "Son下s1.m_A = " << s1.m_A << endl;
// 如果通过子类对象访问到父类中同名成员,需要加作用域
cout << "Base下s1.m_A = " << s1.Base::m_A << endl;
}
// 同名成员函数处理
void test02()
{
Son s1;
s1.func(); // 直接调用调用是子 类中的同名成员
s1.Base::func(); // 加作用域
// 哪怕只有Base类里才有的有参成员函数,
// 如果子类中出现和父类同名的成员函数,子类的同名成员会隐藏掉父类中所有同名成员函数
// 所以要调Base,必须加作用域,s1.Base::func(10);
//s1.func(10);
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:
1.
子类对象可以直接访问到子类中同名成员
2.
子类对象加作用域
可以访问到父类同名成员
3.
当子类与父类拥有同名的成员函数,子类会隐藏
父类中同名成员函数,加作用域
可以访问到父类中同名函数
4.6.6 继承同名静态成员处理方式
问题:
继承中同名的静态成员在子类对象上如何进行访问?
静态成员和非静态成员出现同名,处理方式一致
1.
访问子类同名成员直接
访问即可
2.
访问父类同名成员需要加作用域
#include<iostream>
using namespace std;
#include<string>
// 继承中同名静态成员处理
class Base
{
public:
static void func()
{
cout << "Base的static void func()调用" << endl;
}
static void func(int a)
{
cout << "Base的static void func(int a)调用" << endl;
}
static int m_A;
};
int Base::m_A = 100;
// 公共继承
class Son : public Base
{
public:
static void func()
{
cout << "Son的static void func()调用" << endl;
}
static int m_A;
};
int Son::m_A = 200;
// 同名成员静态属性处理
void test01()
{
// 1.通过对象来访问数据
Son s1;
cout << "Son下s1.m_A = " << s1.m_A << endl;
// 如果通过子类对象访问到父类中同名成员,需要加作用域
cout << "Base下s1.m_A = " << s1.Base::m_A << endl;
// 2.通过类名访问
cout << "Son下s1.m_A = " << Son::m_A << endl;
// 如果通过子类对象访问到父类中同名成员,需要加作用域
cout << "Base下s1.m_A = " << Base::m_A << endl;
// 这样写,也是可以的,第1个::代笔通过类名的方式访问,第2个::代笔代表访问父类的作用域下
cout << "Base下s1.m_A = " << Son::Base::m_A << endl;
}
// 同名成员函数处理
void test02()
{
// 1.通过对象访问
Son s1;
s1.func(); // 直接调用调用是子 类中的同名成员
s1.Base::func(); // 加作用域
// 通过类名的方式访问
Son::func();
Base::func();
Son::Base::func();
// 哪怕只有Base类里才有的有参静态成员函数,
// 如果子类中出现和父类同名的静态成员函数,子类的同名成员会隐藏掉父类中所有同名静态成员函数
// 所以要调Base,必须加作用域,s1.Base::func(10);
//Son::func(100);
Son::Base::func(100);
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:
同名静态成员处理方式和非静态处理方式一样,只不过有两种访问的方式(通过对象和通过类名)
4.6.7 多继承语法
C++允许一个类继承多个类
语法:
class子类∶继承方式 父类1 ,继承方式 父类2…
多继承可能会引发父类中有同名成员
出现,需要加作用域
区分
C++实际开发中不建议
用多继承
#include<iostream>
using namespace std;
#include<string>
// 多继承语法
class Base1
{
public:
Base1()
{
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_A = 200;
}
int m_A;
};
// 子类
// 语法:class子类∶继承方式 父类1 ,继承方式 父类2...
class Son : public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test01()
{
Son s;
cout << "sizeof(s) = " << sizeof(s) << endl;
// 两个父类Base1和Base2都有成员属性m_A,产生了二义性
//cout << "s.m_A = " << s.m_A << endl;
cout << "Base1下s.m_A = " << s.Base1::m_A << endl; //需要加作用域进行区分
cout << "Base2下s.m_A = " << s.Base2::m_A << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
多继承中如果父类中出现了同名情况,子类使用时候要加作用域
4.6.8 菱形继承
菱形继承概念:
两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承
,或者钻石继承
菱形继承问题:
1.
羊继承了动物的数据,驼同样继承了动物的数据,当草泥马使用数据时
就会产生二义性。
2.
草泥马继承自动物的数据继承了两份,其实我们应该清楚,这份数据我们只需要一份就可以。
#include<iostream>
using namespace std;
// 动物类
class Animal
{
public:
int m_Age;
};
// 利用虚继承解决菱形继承的问题
// 继承之前加上关键字virtual变为虚继承
// Animal类称为虚基类
// 羊类
class Sheep : virtual public Animal
//class Sheep : public Animal
{
};
// 鸵类
class Tuo : virtual public Animal
{
};
// 羊鸵类
class SheepTuo : public Sheep, public Tuo
{
};
void test01()
{
SheepTuo st;
// 因为这份数据m_Age,两个父类都继承的Animal类,所以两个父类Sheep、Tuo都有1份数据m_Age
//st.m_Age = 18;
// 当菱形继承,两个父类拥有相同数据,需要加以作用域区分
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;
// 这份数据我们知道只有有一份就可以,菱形继承导致数据有两份,资源浪费
// 其中一个父类改为虚基类后,st.m_Age = 18也不会因为不明确报错了
st.m_Age = 18;
// m_Age就变为1份了,上述先是st.Sheep::m_Age = 18;再是st.Tuo::m_Age = 28;
// 所以不管输出哪份m_Age,最后都变为:28
}
int main()
{
test01();
system("pause");
return 0;
}
可以发现,左边由原始的成员属性m_Age变为了虚基类指针vbptr(virtual base pointer)
,会指向1个 vbtable
最后,指针的偏移量都是指向同一份数据
。
总结:
1.
菱形继承带来的主要问题是子类继承两份相同的数据,导致资源浪费以及毫无意义
2.
利用虚继承
可以解决菱形继承问题
4.7 多态
4.7.1 多态的基本概念
多态
是C++面向对象三大特性之一
多态
分为两类:
1.
静态多态:函数重载
和运算符重载
属于静态多态
,复用函数名(就是让相同的函数名有不同的形态,不同的运算符有不同的功能形态)
2.
动态多态:派生类和虚函数实现运行时多态
静态多态和动态多态区别:
1.
静态多态的函数地址早绑定–编译阶段确定函数地址
2.
动态多态的函数地址晚绑定–运行阶段确定函数地址
#include<iostream>
using namespace std;
// 多态
// 动物类
class Animal
{
public:
// 虚函数
virtual void speak()
//void speak()
{
cout << "动物在说话" << endl;
}
};
// 猫类
class Cat : public Animal
{
public:
// 重写, 函数返回值类型 函数名 参数列表 都完全相同(与重载区分)
void speak()
{
cout << "猫在说话" << endl;
}
};
// C++中允许父子之间的转换,不需要强制转换,父类的引用/指针可以直接指向子类
// 地址早绑定,编译阶段就确定了函数的地址,不管传的哪个子类,都会走Animal里面的函数
// 如果想执行让猫说话,那么这个函数地址就不能提前绑定,需要在运行阶段进行绑定,地址晚绑定(动态动态)
// 动态多态满足条件:
// 1、有继承关系
// 2、子类“重写”父类的虚函数
// 动态多态使用
// 父类的指针或者引用 指向-->子类对象
void doSpeak(Animal& animal) // Animal& animal = cat;
{
animal.speak();
}
int main()
{
Cat cat;
doSpeak(cat);
system("pause");
return 0;
}
总结:
多态满足条件:
1.
有继承关系
2.
子类重写父类中的虚函数
动态多态使用条件
1.
父类指针或引用指向子类对象
重写:
函数返回值类型 函数名 参数列表 完全—致,才称为重写。
#include<iostream>
using namespace std;
// 多态
// 动物类
class Animal
{
public:
// 虚函数
virtual void speak()
//void speak()
{
cout << "动物在说话" << endl;
}
};
// 猫类
class Cat : public Animal
{
public:
// 重写, 函数返回值类型 函数名 参数列表 都完全相同(与重载区分)
void speak()
{
cout << "猫在说话" << endl;
}
};
void test01()
{
// 如果仅有1个非静态成员函数void speak(),是占1个字节,因为只有非静态成员变量是属于类的对象上的
// virtual void speak()变为虚函数,就占4个字节
cout << "sizeof(Animal) = " << sizeof(Animal) << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
4.7.2 多态的案例
多态
的优点:
1.
代码组织结构清晰
2.
可读性强
3.
利于前期和后期的扩展以及维护
#include<iostream>
using namespace std;
// 分别利用普通写法和多态技术实现计算器
// 普通写法
class Calculator
{
public:
int getResult(string oper)
{
if (oper == "+")
{
return m_Num1 + m_Num2;
}
else if (oper == "-")
{
return m_Num1 - m_Num2;
}
else if (oper == "*")
{
return m_Num1 * m_Num2;
}
// 如果想扩展新的功能,需求修改源码
// 在真实开发中 提倡开闭原则
// 开闭原则:对扩展进行开发,对修改进行关闭
}
int m_Num1; // 操作数1
int m_Num2; // 操作数2
};
void test01()
{
// 创建计算器对象
Calculator c;
c.m_Num1 = 10;
c.m_Num2 = 10;
cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
}
// 利用多态实现计算器
// 多态好处:
// 1.组织结构清晰,哪里出错看哪里就行
// 2.可读性强
// 3.对于前期和后期扩展以及维护性高
// 实现计算器的抽象类
class AbstractCalculator
{
public:
virtual int getResult()
{
return 0;
}
int m_Num1; // 操作数1
int m_Num2; // 操作数2
};
// 加法类
class AddCalculator : public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 + m_Num2;
}
};
// 减法类
class SubCalculator : public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 - m_Num2;
}
};
// 乘法类
class MulCalculator : public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 * m_Num2;
}
};
void test02()
{
// 多态使用条件
// 父类指针或者引用指向子类对象
// 加法运算
AbstractCalculator* abc = new AddCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
// 用完堆区数据,手动进行释放
delete abc;
// 减法运算
abc = new SubCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
// 用完堆区数据,手动进行释放
delete abc;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:
C++开发提倡利用多态设计程序架构,因为多态优点很多
4.7.3 纯虚函数和抽象类
在多态中,通常父类中虚函数
的实现是毫无意义的,主要都是调用子类重写
的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法:
virtual 返回值类型 函数名(参数列表) = 0 ;
当类中有了纯虚函数,这个类也称为抽象类
抽象类特点:
1.
无法实例化对象
2.
子类必须重写抽象类中的纯虚函数,否则也属于抽象类
#include<iostream>
using namespace std;
// 纯虚函数和抽象类
class Base
{
public:
// 这是1个纯虚函数, 这个类就称为抽象类
// 抽象类特点:
// 1.无法实例化对象
// 2.抽象类的子类必须要重写父类中的纯虚函数,否则也属于抽象类
virtual void func() = 0;
};
class Son : public Base
{
public:
void func()
{
cout << "func()的函数调用" << endl;
}
};
void test1()
{
//Base b; // 抽象类是无法实例化对象
//new Base; // 抽象类是无法实例化对象
Son s; // 子类必须重写父类中的纯虚函数,否则无法实例化对象
Base* b = new Son;
b->func();
};
int main()
{
test1();
system("pause");
return 0;
}
4.7.4 纯析构和纯虚析构
多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码
解决方式:
将父类中的析构函数改为虚析构
或者纯虚析构
虚析构和纯虚析构共性:
1.
可以解决父类指针释放子类对象
2.
都需要有具体的函数实现
虚析构和纯虚析构区别:
1.
如果是纯虚
析构,该类属于抽象类,无法实例化对象
虚析构语法:
virtual ~类名() { }
纯虚析构语法:
virtual ~类名() = 0;
#include<iostream>
using namespace std;
// 虚析构和纯虚析构
class Animal
{
public:
Animal()
{
cout << "Animal构造函数" << endl;
}
// 利用虚析构可以解决父类指针释放子类对象时不干净的问题
/*virtual ~Animal()
{
cout << "Animal虚析构函数" << endl;
}*/
// 纯虚析构 需要声明也需要实现
// 有了纯虚析构之后,这个类也属于抽象类,无法实例化对象
virtual ~Animal() = 0;
// 纯虚函数
virtual void speak() = 0;
};
Animal::~Animal()
{
cout << "Animal纯虚析构函数" << endl;
}
class Cat : public Animal
{
public:
Cat(string name)
{
cout << "Cat构造函数" << endl;
m_Name = new string(name);
}
virtual void speak()
{
cout << *m_Name << "小猫在说话" << endl;
}
// 由于构造函数中开辟数据到堆区了,所以要在析构中释放
~Cat()
{
if (m_Name != NULL)
{
cout << "Cat析构函数" << endl;
delete m_Name;
m_Name = NULL;
}
}
string* m_Name;
};
void test1()
{
Animal* animal = new Cat("Tom");
animal->speak();
// 父类指针在析构时候不会调用子类中析构函数,导致子类如果有堆区属性,出现内存泄漏
// 只要将父类中的析构函数更改为虚析构就行,~Animal() -->> virtual ~Animal()
delete animal;
};
int main()
{
test1();
system("pause");
return 0;
}
总结:
1.
虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2.
如果子类中没有堆区
数据,可以不写为虚析构或纯虚析构
3.
拥有纯虚析构函数的类也属于抽象类
4.7.5 多态案例
#include<iostream>
using namespace std;
// 抽象不同的零件类
// 抽象CPU类
class CPU
{
public:
// 抽象的计算函数
virtual void calculate() = 0;
};
// 抽象显卡类
class VideoCard
{
public:
// 抽象的计算函数
virtual void display() = 0;
};
// 抽象内存条类
class Memory
{
public:
// 抽象的计算函数
virtual void storage() = 0;
};
// 电脑类
class Computer
{
public:
Computer(CPU* cpu, VideoCard* vc, Memory* mem)
{
m_cpu = cpu;
m_vc = vc;
m_mem = mem;
}
// 提供1个工作的函数
void doWork()
{
// 让零件工作起来,调用接口
m_cpu->calculate();
m_vc->display();
m_mem->storage();
}
// 提供析构函数释放3个电脑零件
~Computer()
{
// 释放CPU
if (m_cpu != NULL)
{
delete m_cpu;
m_cpu = NULL;
}
// 释放显卡
if (m_vc != NULL)
{
delete m_vc;
m_vc = NULL;
}
// 释放内存条
if (m_mem != NULL)
{
delete m_mem;
m_mem = NULL;
}
}
private:
CPU* m_cpu; // CPU的零件指针
VideoCard* m_vc; // CPU的零件指针
Memory* m_mem; // 显卡的零件指针
};
// 具体厂商
// 1.Intel厂商
class IntelCPU : public CPU
{
virtual void calculate()
{
cout << "Intel的CPU开始计算了" << endl;
}
};
class IntelVideoCard : public VideoCard
{
virtual void display()
{
cout << "Intel的显卡开始显示了" << endl;
}
};
class IntelMemory : public Memory
{
virtual void storage()
{
cout << "Intel的内存条开始存储了" << endl;
}
};
// 2.Leveo厂商
class LeveoCPU : public CPU
{
virtual void calculate()
{
cout << "Leveo的CPU开始计算了" << endl;
}
};
class LeveoVideoCard : public VideoCard
{
virtual void display()
{
cout << "Leveo的显卡开始显示了" << endl;
}
};
class LeveoMemory : public Memory
{
virtual void storage()
{
cout << "Leveo的内存条开始存储了" << endl;
}
};
void test01()
{
// 第1台电脑
CPU* intelCpu = new IntelCPU;
VideoCard* intelCard = new IntelVideoCard;
Memory* intelMem= new IntelMemory;
// 创建第1台电脑
Computer* computer1 = new Computer(intelCpu, intelCard, intelMem);
computer1->doWork();
delete computer1;
// 创建第2台电脑
Computer* computer2 = new Computer(new LeveoCPU, new LeveoVideoCard, new LeveoMemory);
computer2->doWork();
delete computer2;
}
int main()
{
test01();
system("pause");
return 0;
}
版权声明:本文标题:C++复习的长文指南(一) 内容由热心网友自发贡献,该文观点仅代表作者本人, 转载请联系作者并注明出处:https://m.elefans.com/dianzi/1728313049a1153277.html, 本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,一经查实,本站将立刻删除。
发表评论