C++学习笔记

最新推荐文章于 2024-05-28 21:13:10 发布

The FoolandThe World

最新推荐文章于 2024-05-28 21:13:10 发布

阅读量1.6k

点赞数

文章标签： c++ 学习

本文链接：https://blog.csdn.net/qq_74202016/article/details/128976991

版权

C++学习笔记

文章目录

C++基础

一，变量类型和C语言基本相同

（1）int,char,float,double,bool(布尔型只有0或1)等，各类型在C++中区别在于所占内存空间不同。

（2）C和C++中字符型（char）变量只占用1个字节。

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

拓展：(ASCII码大致由以下两部分组成:1. ASCII非打印控制字符: ASCII表上的数字0-31分配给了控制字符，用于控制像打印机等一些外围设备。2 . ASCII打印字符:数字32-126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。)

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

（）例

int c_l_a=10;//即c-const  g-global  l-local
string name;//即创建名字的字符串

（1）标识符不能是关键字。例（for,case,define,等）。

（2）第一个字符必须为字母或下划线。例（DO，Size，_G3 ，IF ）错误例子（4d， -sub）。

（3）标识符中字母区分大小写。例（for不可以使用，For则可以）。

三，转义字符（作用:用于表示-些不能显示出来的ASCII字符）

（1）\a 含义：警报 ASCII（十进制）007

（2）\n 含义：换行(LF)，将当前位置移到下一行开头 ASCII（十进制）010

（3）\t 含义：水平制表(HT) (跳到下个TAB位置)即可以整齐输出数据 ASCII（十进制）009

（4）\ \ 含义：代表-个反斜线字符"\" ASCII（十进制）092

（5）\r 含义：回车(CR)，将当前位置移到本行开头 ASCII（十进制）013

（6）\b 含义：退格(BS)，将当前位置移到前一-列 ASCII（十进制）008

（7）\0 含义：数字0

四，字符串

（1） C++中字符串可以 string 变量名=“字符串值” 需要加入头文件#include

用string创建后，字符串一旦初始化就不能更改, 因为string类中所有字符串都是常量,数据是无法更改,由于string对象的不可变, 所以可以共享。对String类的任何改变,都是返回-一个新的String类对象。

（2）null空字符（\0）用他标记字符串的结束

（3）用%s来读取字符串的数据

五，运算符

1.C++中访问具体的数需要用&取址符

六，系统生成随机数方法

#include<ctime>

//time系统时间头文件包含

srand((unsingned int)time(NULL));

//随机数种子：利用当前系统时间生成随机数

int num=rend()%100+1;

//rend()%100+1生成0+1~99+1随机数。

七，跳转语句（break）

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

break使用的时机：

1.出现在switch条件语句中，作用是终止case并跳出switch

2.出现在循环语句中，作用是跳出当前的循环语句

3.出现在嵌套循环中，跳出最近的内层循环语句

八，数组元素互换输出

1，计算数组长度下标方法：

int end = sizeof (arr) / sizeof (arr[0]) -1

;//减1是因为sizeof (arr) / sizeof (arr [0])=5而数组下标为0 4故需减去1。

for(start = 0; start < end; start++, end-){

int temp=arr[start];

arr[start]=arr[end];

arr[end]=temp;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S7ALQkJG-1676032966222)(C:\Users\y’z\Desktop\C++\C++基础\屏幕截图 2022-11-05 105844.png)]

九，数组冒泡排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HyqP6mSs-1676032966223)(C:\Users\y’z\Desktop\C++\C++基础\屏幕截图 2022-11-05 111133.png)]

十，函数

在函数定义中

声明可以写多次，但定义只能有一次。

十一，函数的值传递和地址传递

1，值传递时，形参发生任何的改变都不会影响实参。

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gFbI6vfJ-1676032966224)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-12 145443.png)]

2，地址传递时，形参发生改变可以影响实参。

例

void func(int*a,int*b)
{
  int temp;
  a=b;
  b=temp;
}
int main()
{
int a=10;
int b=20;
func(&a,&b);
}

总结:如果不想修改主函数中的数据，用值传递，反之用地址传递。

十二，指针

1，字节大小

在32位操作系统下，撞针是占4个字节空间大小，不管是什么数据类型。

在64位操作系统下，指针是占8个字节空间大小。

2，指针作用

可以通过指针来保存一个地址。

3，空指针和野指针

（1）空指针用于给指针变量进行初始化。

例赋值时

 int *p=NULL;

（2）空指针是不可以进行访问的。

(0~255之间的内存编号是系统占用的，因此不可以访间)

（3）空指针和野指针都不是我们申请的空间，因此不要访问。

4，coust修饰指针有三种情况:

（1）const修饰指针-- 常量指针。

例

coust int *p=&a;

*p=20;错误,指向的值不可以改。

p=&b正确,指针指向可以改.

特点：指针的1指向可以修改，但是指针指向的值不可以修改。

（2）const修饰常量— 指针常量。

例

int * const p=&a;

*p=20;正确，指向的值可以改。

p=&b: 错误，指针指向不可以改。

特点:指针的指向不可以改，指针指向的值可以改。

（3）const即修饰指针，又修饰常星

例

inta=10;

intb=10;

int*p=&a；

const int*const p=&a;

*p=20; //错误。

p=&b: //错误。

特点:指针的指向和指针指向的值都不可以改。

十二，结构体基本概念

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

1，结构体定义和使用

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

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

（1）struct结构体名变量名例

struct Student s1

（2）struct结构体名变量名={成员1值，成员2…}例

struct Student s2={....}

（3）定义结构体时顺便创建变量，例

struct Student s3{成员1值，成员2..}chengji；

2，结构体定义和使用的总结

总结1: 定义结构体时的关键字是struct,不可省略。

总结2: 创建结构体变量时，关键字struct可以省略。

总结3:结构体变量利用操作符"."访问成员。

3，结构体指针

（1）通过指针访问结构体变量中的数据

通过结构体指针访问结构体中的属性，需要利用“->”

例

struct student

{

string name;

int age;

string score;

}

int main ()

{

student s={"张三"，18，100}；

student *p=&s;

cout<<"姓名："<<p->name<<"年龄"<<p->age<<"分数"<<p->score<<endl;

}

4.结构体中coust使用场景

作用：用const来防止误操作。

例const使用场景

void printStudent( const student*stu) //加const防止函数体中的误操作

{

stu->age=100; //操作失败，因为加了const修饰

cout <<“姓名:”<< stu->name <<”年龄:”<< stu->age << ”分数:”<< stu->score << endl;

}

5,结构体中的地址传递

struct Hare
{
	string name;
	int age;
	string xb;
};
void bubbleSort (struct Hero heroArray[] ，int len)
{
for(inti=0;i<len-1;1++){
   for(intj=0;j<1en-i-1;j++){
    if (heroArray[j]. age〉heroArray[j + 1]. age)
         {
        struct Hero demp = heroArray[j];
        struct Hero demp = heroArray[j];
        heroArray[j] = heroArray[j + 1];
        heroArray[j + 1] = temp;
         }
      }
   }
}
int main()
{
struct Hare xinx[5]= { {"刘备",22,"男"},{"关羽",23,"男"},{"张飞",20,"男"},
		{"赵云",21,"男"},{"貂蝉",19,"女"} };
bubbleSort(xinx);
for (int i = 0; i < 5; i++)
	{
		cout << xinx[i].name << xinx[i].age<<xinx[i].xb<< endl;
	}
return 0;
}

数组名即是地址，因此本次实参到形参是地址传递非值传递。

通讯录管理系统

通讯录管理系统源代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
void showMenu()
{
	cout << "添加联系人请输1" << endl;
	cout << "显示联系人请输2" << endl;
	cout << "删除联系人请输3" << endl;
	cout << "查找联系人请输4" << endl;
	cout << "修改联系人请输5" << endl;
	cout << "清空联系人请输6" << endl;
	cout << "退出通讯录请输0" << endl;
}
void xiugai2()
{
	cout << "如果修改联系人姓名请输1" << endl;
	cout << "如果修改联系人性别请输2" << endl;
	cout << "如果修改联系人年龄请输3" << endl;
	cout << "如果修改联系人联系电话请输4" << endl;
	cout << "如果修改联系人家庭住址请输5" << endl;
	cout << "退出修改请输0" << endl;
}
struct lxr
{
	string name;
	string sex;
	int age;
	int phone;
	string tiz;
};
struct Adds
{
	struct lxr arr[1000];
	int rs;
};
void tj(Adds *abs)//解码abs的地址将结构体Adds中的所有成员输入函数
{
	int i=0;
	if (abs->rs == 1000)
	{
		cout << "通讯录已满，无法添加" << endl;
		return;
	}
	else {
		string name;
		string sex;
		int age;
		int phone;
		string tiz;
		cout << "请输入姓名" << endl;
		cin >>  name;
		abs->arr[abs->rs].name = name;//变量abs即（结构体Abbs）中的arr数组中的第abs中的第rs个元素的name成员
		cout << "请输入性别" << endl;
		cin >> sex;
		abs->arr[abs->rs].sex=sex;
		cout << "请输入年龄" << endl;
		cin >> age;
		abs->arr[abs->rs].age = age;
		cout << "请输入联系电话" << endl;
		cin >> phone;
		abs->arr[abs->rs].phone = phone;
		cout << "请输入家庭住址" << endl;
		cin >> tiz;
		abs->arr[abs->rs].tiz = tiz;
		abs->rs++;//更新通讯录人数
		cout << "添加成功" << endl;
		system("pause");//请按任意键继续
		system("cls");//清屏
	}
	
	cout << endl;
}
void show(Adds * abs) 
{

	if (abs->rs == 0)
	{
		cout << "通讯录中没有人" << endl;
	}
	else
	{
		for (int i = 0; i < abs->rs; i++)//判断条件i<变量abs即（结构体Abbs)中rs即（人数）
		{
			cout << "姓名" << " " <<abs->arr[i].name << "\t";//变量abs即（结构体Abbs)中arr数组中第i个元素的name成员
			cout << "性别" << " " <<abs->arr[i].sex << "\t";
			cout << "年龄" << " " << abs->arr[i].age <<"\t";
			cout << "联系电话" << " " <<abs->arr[i].phone <<"\t";
			cout << "家庭住址" << " " <<abs->arr[i].tiz << endl;
		}
	}
	system("pause");
	system("cls");
}
int cazhao(Adds*abs,string name)//进入函数的参数1为 通讯录 参数2为 对比的姓名，方法可改进即（对比姓名改为对比电话号码）
{
	for (int i = 0; i < abs->rs; i++)
	{
		if (abs->arr[i].name == name)
		{
			return i;//找到返回i即数组下标编号
		}
	}
	return -1;//没找到返回-1
}
void deleteren(Adds*abs)
{
	cout << "请输入你要删除的联系人" << endl;
	string name1;
	cin >> name1;
	int b=cazhao(abs, name1);
	if (b !=-1)//查到此人
	{
		for (int i = b; i < abs->rs; i++)
		{
			abs->arr[i] = abs->arr[i + 1];
		}
		abs->rs--;
		cout << "删除成功" << endl;
	}
	else 
	{
		cout <<"查无此人"<<endl;
	}
	system("pause");
	system("cls");
}
void findren(Adds* abs)
{
	cout << "请输入你要查找的联系人姓名" << endl;
	string name2;
	cin >> name2;
	int c = cazhao(abs, name2);
	if (c != -1)//找到了联系人
	{
		cout << "姓名" << abs->arr[c].name <<"\t";
		cout << "性别" << abs->arr[c].sex <<"\t";
		cout << "年龄" << abs->arr[c].age <<"\t";
		cout << "联系电话" << abs->arr[c].phone <<"\t";
		cout << "家庭地址" << abs->arr[c].tiz << endl;
	}
	else //没找到
	{
		cout << "查无此人" << endl;
	}
	system("pause");
	system("cls");
}
void xiugai(Adds* abs)

{
	cout << "请输入你要修改的联系人姓名" << endl;
	string name3;
	cin >> name3;
	int d = cazhao(abs, name3);
	if (d != -1)//找到了联系人
	{
		xiugai2();
		int z;
		cin >> z;
		switch (z)
		{
		case 1: 
		{string name4;//姓名
			cout << "请输入修改的名字" << endl;
			cin >> name4;
			abs->arr[d].name = name4;
			cout << "联系人修改成功" << endl;
		}; break;
		case 2: 
		{string sex;//性别
			cout << "请输入修改的性别" << endl;
			cin >> sex;
			abs->arr[d].sex = sex;
			cout << "联系人修改成功" << endl;
		}; break;
		case 3: 
		{ int age;//年龄
			cout << "请输入修改的年龄" << endl;
			cin >> age;
			abs->arr[d].age = age;
			cout << "联系人修改成功" << endl;
		}; break;
		case 4: 
		{int phone;//联系电话
			cout << "请输入修改的联系电话" << endl;
			cin >> phone;
			abs->arr[d].phone = phone;
			cout << "联系人修改成功" << endl;
		}; break;
		case 5:{string tiz;//家庭住址
			cout << "请输入修改的家庭地址" << endl;
			cin >> tiz;
			abs->arr[d].tiz = tiz;
			cout << "联系人修改成功" << endl;
		}; break;
		case 0: {
			cout << "欢迎下次使用" << endl;
		}; break;
		
		}
	}
	else//没找到联系人
	{
		cout << "查无此人" << endl;
	}
	system("pause");
	system("cls");
}
void cleanren(Adds*abs)
{
	cout << "是否确定清空通讯录，如果确定请输入“是”，否则请输入“否”" << endl;
	string y;
	cin >> y;
		if (y  =="是")
		{
			abs->rs = 0;//将当前联系人数量置为0，做一个逻辑上的清空
			cout << "通讯录已清空" << endl;
			system("pause");
			system("cls");
		}
		else {
			system("pause");
			system("cls");
		}
}
int main()
{
	int a=0;
	Adds abs;//定义结构体变量，故下方&abs为结构体Adds中的数据包含数组lxr和rs
	abs.rs = 0;//先定义人数为0
	while (true) {
		showMenu();
		cout << "请输入你的选择" << endl;
		cin >> a;
		switch (a)
		{
		case 1:tj(&abs); break;//向tj函数传递abs的地址即（结构体Adds中的所有成员）
		case 2:show(&abs); break;
		case 3:deleteren(&abs); break;
		case 4:findren(&abs); break;
		case 5:xiugai(&abs); break;
		case 6:cleanren(&abs); break;
		case 0:cout << "欢迎下次使用" << endl;
			system("pause");
			return 0;
		}
	}
	system("pause");
	return 0;
}

第一部分，程序主页面

void showMenu()
{
	cout << "添加联系人请输1" << endl;
	cout << "显示联系人请输2" << endl;
	cout << "删除联系人请输3" << endl;
	cout << "查找联系人请输4" << endl;
	cout << "修改联系人请输5" << endl;
	cout << "清空联系人请输6" << endl;
	cout << "退出通讯录请输0" << endl;
}

并在主函数中进行调用即showMenu();

第二部分，创建结构体lxr和Adds

struct lxr
{
	string name;
	string sex;
	int age;
	int phone;
	string tiz;
};
struct Adds
{
	struct lxr arr[1000];
	int rs;
};

1，其中lxr为存放联系人信息格式的结构体即（姓名，性别，年龄，联系电话，家庭住址）。

2，而Adds结构体中嵌套了结构体lxr并创建了结构体lxr类型的数组和整形变量re来存放人数。

第三部分，程序第一个功能输入联系人信息并存储

void tj(Adds *abs)//解码abs的地址将结构体Adds中的所有成员输入函数
{
	int i=0;
	if (abs->rs == 1000)
	{
		cout << "通讯录已满，无法添加" << endl;
		return;
	}
	else {
		string name;
		string sex;
		int age;
		int phone;
		string tiz;
		cout << "请输入姓名" << endl;
		cin >>  name;
		abs->arr[abs->rs].name = name;//变量abs即（结构体Abbs）中的arr数组中的第abs中的第rs个元素的name成员
		cout << "请输入性别" << endl;
		cin >> sex;
		abs->arr[abs->rs].sex=sex;
		cout << "请输入年龄" << endl;
		cin >> age;
		abs->arr[abs->rs].age = age;
		cout << "请输入联系电话" << endl;
		cin >> phone;
		abs->arr[abs->rs].phone = phone;
		cout << "请输入家庭住址" << endl;
		cin >> tiz;
		abs->arr[abs->rs].tiz = tiz;
		abs->rs++;//更新通讯录人数
		cout << "添加成功" << endl;
		system("pause");//请按任意键继续
		system("cls");//清屏
	}
	
	cout << endl;
}

1，函数名void tj(Adds *abs)//解码abs的地址将结构体Adds中的所有成员输入函数

注：abs为在主函数int main（）中定义的结构体变量名，其中包含结构体Adds中的数据包含数组lxr和rs，并定义abs中的rs变量为0。

    int a=0;
	Adds abs;//定义结构体变量，故下方&abs为结构体Adds中的数据包含数组lxr和rs
	abs.rs = 0;//先定义人数为0

2，用if语句判断abs中的rs变量中的人数是否达到1000达到则输出：通讯录已满，无法添加。

否则则添加联系人信息即一项一项输入，例：

string name;
cout << "请输入姓名" << endl;
		cin >>  name;
		abs->arr[abs->rs].name = name;//变量abs即（结构体Abbs）中的arr数组中的第abs中的第rs个元素的name成员
		abs->rs++

即将键盘输入的name赋值给变量abs即（结构体Abbs）中的arr数组中的第abs中的第rs个元素的name成员,最后人数要加一。

3，清屏代码

system("pause");//请按任意键继续
		system("cls");//清屏

第四部分，展示全部联系人

void show(Adds * abs) 
{

	if (abs->rs == 0)
	{
		cout << "通讯录中没有人" << endl;
	}
	else
	{
		for (int i = 0; i < abs->rs; i++)//判断条件i<变量abs即（结构体Abbs)中rs即（人数）
		{
			cout << "姓名" << " " <<abs->arr[i].name << "\t";//变量abs即（结构体Abbs)中arr数组中第i个元素的name成员
			cout << "性别" << " " <<abs->arr[i].sex << "\t";
			cout << "年龄" << " " << abs->arr[i].age <<"\t";
			cout << "联系电话" << " " <<abs->arr[i].phone <<"\t";
			cout << "家庭住址" << " " <<abs->arr[i].tiz << endl;
		}
	}
	system("pause");
	system("cls");
}

1，先用if判断abs->rs中是否有人，如果没有输出通讯录中没有人，否则进入for循环，循环判断条件i<变量abs即（结构体Abbs)中rs即（人数）。

2，按顺序输出联系人信息，例：

cout << "姓名" << " " <<abs->arr[i].name << "\t";//变量abs即（结构体Abbs)中arr数组中第i个元素的name成员

注：\t为水平制表符

第五部分，创建查找联系人的函数

int cazhao(Adds*abs,string name)//进入函数的参数1为 通讯录 参数2为 对比的姓名，方法可改进即（对比姓名改为对比电话号码）
{
	for (int i = 0; i < abs->rs; i++)
	{
		if (abs->arr[i].name == name)
		{
			return i;//找到返回i即数组下标编号
		}
	}
	return -1;//没找到返回-1
}

1，给函数输入两个形参即参数1为通讯录参数2为对比的姓名，方法可改进即（对比姓名改为对比电话号码）。

2，利用for循环遍历abs数组在用if语句判断即(abs->arr[i].name == name)找到则返回i即数组下标编号，若没找到则返回-1。

第六部分，删除的联系人

void deleteren(Adds*abs)
{
	cout << "请输入你要删除的联系人" << endl;
	string name1;
	cin >> name1;
	int b=cazhao(abs, name1);
	if (b !=-1)//查到此人
	{
		for (int i = b; i < abs->rs; i++)
		{
			abs->arr[i] = abs->arr[i + 1];
		}
		abs->rs--;
		cout << "删除成功" << endl;
	}
	else 
	{
		cout <<"查无此人"<<endl;
	}
	system("pause");
	system("cls");
}

1，先输入一个要查找的名字，利用第五部分的查找联系人的函数来进行查找。

2，用if语句来进行判断若变量b不等于-1则找到联系人并利用for循环将该联系人的信息用后面联系人的信息给覆盖，最后对abs人数减一。

3，如果if语句等于1则输出查无此人。

第七部分，查找联系人并输出

void findren(Adds* abs)
{
	cout << "请输入你要查找的联系人姓名" << endl;
	string name2;
	cin >> name2;
	int c = cazhao(abs, name2);
	if (c != -1)//找到了联系人
	{
		cout << "姓名" << abs->arr[c].name <<"\t";
		cout << "性别" << abs->arr[c].sex <<"\t";
		cout << "年龄" << abs->arr[c].age <<"\t";
		cout << "联系电话" << abs->arr[c].phone <<"\t";
		cout << "家庭地址" << abs->arr[c].tiz << endl;
	}
	else //没找到
	{
		cout << "查无此人" << endl;
	}
	system("pause");
	system("cls");
}

1，先输入一个要查找的名字，利用第五部分的查找联系人的函数来进行查找。

2，用if语句来进行判断若变量c不等于-1则找到联系人并输出联系人信息。

3，如果if语句等于1则输出查无此人。

第八部分，修改联系人

void xiugai(Adds* abs)
{
	cout << "请输入你要修改的联系人姓名" << endl;
	string name3;
	cin >> name3;
	int d = cazhao(abs, name3);
	if (d != -1)//找到了联系人
	{
		xiugai2();
		int z;
		cin >> z;
		switch (z)
		{
		case 1: 
		{string name4;//姓名
			cout << "请输入修改的名字" << endl;
			cin >> name4;
			abs->arr[d].name = name4;
			cout << "联系人修改成功" << endl;
		}; break;
		case 2: 
		{string sex;//性别
			cout << "请输入修改的性别" << endl;
			cin >> sex;
			abs->arr[d].sex = sex;
			cout << "联系人修改成功" << endl;
		}; break;
		case 3: 
		{ int age;//年龄
			cout << "请输入修改的年龄" << endl;
			cin >> age;
			abs->arr[d].age = age;
			cout << "联系人修改成功" << endl;
		}; break;
		case 4: 
		{int phone;//联系电话
			cout << "请输入修改的联系电话" << endl;
			cin >> phone;
			abs->arr[d].phone = phone;
			cout << "联系人修改成功" << endl;
		}; break;
		case 5:{string tiz;//家庭住址
			cout << "请输入修改的家庭地址" << endl;
			cin >> tiz;
			abs->arr[d].tiz = tiz;
			cout << "联系人修改成功" << endl;
		}; break;
		case 0: {
			cout << "欢迎下次使用" << endl;
		}; break;
		}
	}
	else//没找到联系人
	{
		cout << "查无此人" << endl;
	}
	system("pause");
	system("cls");
}

1，先输入一个要查找的名字，利用第五部分的查找联系人的函数来进行查找。

2,用if语句来进行判断若变量d不等于-1则找到联系人并输出修改列表xiugai2()并输入一个变量z进行修改选择。

3，利用switch语句进行修改选择。例：

case 1: 
		{string name4;//姓名
			cout << "请输入修改的名字" << endl;
			cin >> name4;
			abs->arr[d].name = name4;
			cout << "联系人修改成功" << endl;
		}; break;

输入想改的姓名放入变量name4中并赋值给abs->arr[d].name。

4.如果if语句等于1则输出查无此人。

第九部分，清空联系人

void cleanren(Adds*abs)
{
	cout << "是否确定清空通讯录，如果确定请输入“是”，否则请输入“否”" << endl;
	string y;
	cin >> y;
		if (y  =="是")
		{
			abs->rs = 0;//将当前联系人数量置为0，做一个逻辑上的清空
			cout << "通讯录已清空" << endl;
			system("pause");
			system("cls");
		}
		else {
			system("pause");
			system("cls");
		}
}

先用if语句进行判断确认是否要清空联系人，如果“是”则abs->rs = 0;//将当前联系人数量置为0，做一个逻辑上的清空。否则返回主菜单。

第十部分，主函数部分

int main()
{
	int a=0;
	Adds abs;//定义结构体变量，故下方&abs为结构体Adds中的数据包含数组lxr和rs
	abs.rs = 0;//先定义人数为0
	while (true) {
		showMenu();
		cout << "请输入你的选择" << endl;
		cin >> a;
		switch (a)
		{
		case 1:tj(&abs); break;//向tj函数传递abs的地址即（结构体Adds中的所有成员）
		case 2:show(&abs); break;
		case 3:deleteren(&abs); break;
		case 4:findren(&abs); break;
		case 5:xiugai(&abs); break;
		case 6:cleanren(&abs); break;
		case 0:cout << "欢迎下次使用" << endl;
			system("pause");
			return 0;
		}
	}
	system("pause");
	return 0;
}

1，定义主函数int main（）中abs为结构体变量名，其中包含结构体Adds中的数据包含数组lxr和rs，并定义abs中的rs变量为0。

2，利用switch进行选择要进行的操作，输入一个变量a,然后判断。例

case 1:tj(&abs); break;//向tj函数传递abs的地址即（结构体Adds中的所有成员）

C++核心编程（内存和引用）

一，内存分区模型

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

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

2，全局区:存放全局变量和静态变量以及常量。

3，全局区:存放全局变量和静态变量以及常量。

4，堆区:由程序员分配和释放若程序员不释放程序结束时由操作系统回收。

二，内存四区意义

不同区域存放的数据，赋予不同的生命周期,给我们更大的灵活编程。

三，程序运行前

即在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域。（每次运行程序都会重新分配内存）

1，代码区

（1）存放CPU执行的机器指令。

（2）代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。

（3）代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令。

2，全局区

（1）全局变量和静态变量存放在此。

（2）全局区还包含了常量区,字符串常量和其他常量也存放在此。

（3）该区域的数据在程序结束后由操作系统释放。

例：

#include<iosteam>
using namespace std;
int a=10;
int main()
{
int b=20;
static c=30;
}

其中a为全局变量，b为局部变量，c为静态变量

全局区总结，1，局部变量、const修饰的局部变量(局部常量)（不在全局区中）。

2，全局变量，静态变量static关键字，常量，字符串常量，const修饰的全局变量(全局常量)（在全局区中）。

3，总结

（1），C++中在程序运行前分为全局区和代码区。

（2），代码区特点是共享和只读。

（3），全局区中存放全局变量、静态变星、常量。

（4），常量区中存放const修饰的全局常星和字符串常量。

四，程序运行后

1，栈区

（1），由编译器自动分配释放,存放函数的参数值,局部变量等。

（2），注意事项:不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。

例

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
int *func()栈区数据注意事项---不要返回局部变量的地址
{
	int a = 10;
	int *p = &a;//说明了指针*p只能存放地址
	return p;//因为函数类型为int故返回的值只能为数字 而p是地址，改法1，将函数改为int*func()或将返回值改为*p
	//故这返回的是局部变量的地址，所以在下面主函数int main()调用中出现错误
}
int main()
{
	int *q = func();//因为func为指针类型返回地址故创建int*q来保存
	cout << *q << endl; //第一次可以打印正确的数字，是因为编译器做了保留
	cout << *q << endl;//第二次以后这个数据就不再保留了
	cout << *q << endl;
	return 0;
}

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b7kF05ej-1676032966224)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-12 110019.png)]

2,堆区

（1），由程序员分配释放,若程序员不释放,程序结束时由操作系统回收。

（2），在C++中主要利用new在堆区开辟内存。

例

#include<iostream>
using namespace std;
int *func()
}
//利用new关键字可以将数据开 辟到堆区
//指针γ本质也是局部变量，放在栈上，指针保存的数据是放在堆区
    int *p=new int(10)
        return p
}
int main()
{
    //在堆区开辟数据
    int*p=func();
    return 0;
}

3，new操作符

（1），C++中利用new操作符在堆区开辟数据。

（2），堆区开辟的数据，由程序员手动开辟，手动释放,释放利用操作符delete。

（3），语法:new 数据类型。

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

例：new基础语法

int*func()
{
    //在堆区创建整形数据
    //new返回是 该数据类型的指针
    int*p=new int(10);//或tz=new int（10） //并在main中写int*tz;
    return p;
}
int main()
{
   
    int*q=func();
    cout<<*q<<endl;
    cout<<*q<<endl;
    cout<<*q<<endl;
    //堆区的数据 由程序员开辟，程序员管理释放
    //如果想释放堆区的数据，需利用关键字 delete
    delete p;
    //释放堆区数组
    //释放数组的时候要加[]才可以
    delete[]arr;
    cout<<*q<<endl;
    //内存已经被释放，再次访问为非法操作，会报错
    
    
    
}

五，引用的基本使用

作用 : 给变量起别名

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

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ps5Ebmca-1676032966225)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-12 111855.png)]

例

int main()
{
    int a;
    int&b=a;//b就是a的别名
    b=20;//也会改变a的数据
}

六，引用注意事项

1，引用必须初始化

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

例

int main()
{
   int a=10;
   int c=20;
   int&b=a;//引用必须初始化即int &b//错误的
   //引用一旦初始化后，不可以改变即int&b=a;后不可以int&b=c;
   //并且int &b=a;相当于指针常量 int *coustp=a;
}

七，引用做函数参数

作用:函数传参时，可以利用|用的技术让形参修饰实参。

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

引用传递，例

void  func(int&a,int&b)
{
int temp;
a=b;
b=temp;
}
int main()
{
int a=10;
int b=20;
func(a,b)
}//引用传递，形参会修饰实参

八，引用做函数返回值

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

注意：不要返回局部变量引用。

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

例

//注意：不要返回局部变量引用。
int & test01()
{
int a=10;//局部变量存放在栈区
return a;
}
//函数调用作为左值。
int & test02()
{
    static int a=10;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
    return a;
}
int main()
{
    int &ref=test01();
    test02() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值
    cout<<"ref="<<ref<<endl;//第一次结果正确，是因为编译器做了保留
    cout<<"ref="<<ref<<endl;//第二次结果错误，因为a的内存已经释放
}

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BVXVloAH-1676032966225)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-12 165603.png)]

九，常量引用

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

在函数形参列表中，可以const修饰形参，防止形参改变实参。

例

int main()
{
//加上const之后编译器将代码修改int temp = 10(系统自动创造一个变量temp); const int & ref = temp;
coust int &ref=10;
ref=20; //加入const之后变为只读，不可以修改
}

函数提高

一，函数默认参数

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

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

例

int func(int a,int b,int c=30)
{
return 0;
}
int main()
{
    cout<<func(10,10)<<endl;//即最后的int c的形参可以不用填
    system("pause");
    return 0;
}

注意事项

1，如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值。

例

int func2(int a = 10， int b，int C，int d) //如果int a有默认值则b,c,d都要有默认值
{
   return 0;
}

2，如果函数声明有默认参数，函数实现就不能有默认参数。

声明和实现只能有一个有默认参数。

例

int func2(int a,int b);//函数声明
//若为int func2(int a=10,int b=10)即错误
int func(int a=10,int b=10)//函数实现
{
return 0;
}

二，占位参数

返回值类型函数名 (数据类型) {}。

占位参数，还可以有默认参数。

例

void func(int a,int)//即可以改为void func(int a,int=10)就可以在函数调用时只输入一个数字
{
cout<<"this is func"<<endl;
}
int main()
{
    func(10,20);//因为函数中形参存在占位int故再调用函数时要输入两个数字不然会报错
    system("pause");
    return 0;
}

三，函数重载

1，函数重载概述

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

2，函数重载满足条件:

（1）同一个作用域下。

（2）函数名称相同。

（3）函数参数类型不同或者个数不同或者顺序不同。

例

void func()//1
{
    cout<<"func的调用"<<endl;
}
void func(int a)//2
{
    cout<<"func(int a)的调用"<<endl;
}
void func(double a)//3
{
    cout<<"func(double a)的调用"<<endl;
}
void func(int a，double b)//4
{
cout<<"func (int a, double b) 的调用"<< endl;
}
void func (double a， int b)//5
{
cout <<"func (double a, int b)的调用"<<endl;
}

如图所示1，2，4，5为个数不同.

2和3为类型不同。

4和5为顺序不同。

注意事项，1，函数的返回值不可以作为函数重载的条件

2，引用作为重载的条件

例

void func(int &a) // int &a = 10;不合法但是可以调用int &a=a
{
cout<<"func(int &a)调用"<<endl;
}
void func(const int &a) //const int &a = 10; 合法
{
coust<< "func(const int &a)调用"<< endl;
}
int main
{
    int a=10;
    func(a);//调用无const
    func(10);//调用有const
}

3, 函数重载碰到默认参数

错误例子

void func2(int a，int b = 10)
{
cout <<"func2(int a，int b)的调用"<< endl;
}
void func2(int a)
{
cout<<" func2(int a )的调用"<< endl;
}

当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况。

四，类和对象

1，C++面向对象雨三大特性为:封装、继承、多态。

2，C++认为万事万物都皆为对象，对象上有其属性和行为。

例

1，人可以作为对象，属性有姓名、年龄、身高体重…行为有走、跑、跳吃饭、唱歌…

2，也可以作为对象，属性有轮胎、向盘、…行为有载人。放音乐、放空调…

3，具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类。

1，封装

1，封装的意义

1，封装是C++面向对象三大特性之一。

2，封装的意义:

(1)将属性和行为作为一个整体，表现生活中的事物。

(2)将属性和行为加以权限控制。

2，封装意义一

在设计类的时候，属性和行为写在一起，表现事物

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

例

#include<iostream>
using namespace std;
class yun
{
    public://访问权限公共权限
    int m_r;//属性
    double cocang()//行为
    {
        return 2*pi*m_r;
    }
}
int main()
{
//通过圆类创建具体的圆(对象)
    yun c1;
//给圆对象的属性进行赋值
    c1.m_r=10;
    
}

行业黑话

1，类中的属性和行为我们统一称为成员

2，属性成员属性成员变量

3，行为成员函数成员方法

3，封装意义二（三种权限）

1，类在设计时，可以把属性和行为放在不同的权限下，加以控制

2，访问权限有三种:

（1）public 公共权限（成员类内可以访问类外可以访问）

（2）protected 保护权限（成员类内可以访问类外不可以访问例如儿子可以访问父亲中的保护内容）

（3）private 私有权限（成员类内可以访问类外不可以访问例如儿子不可以访问父亲的私有内容）

使用方法例

class Person
{
public:
//公共权限
string m_Name; // 姓名
protected:
//保护权限
string m_Car; //汽车
private:
//私有权限
int m_Password; //银行卡密码
}
int main()
{
Person pl;
p1.m_Name = "李四”:
p1.m_Car =”奔驰”: //保护权限内容，在类外访问不到
p1.m_Password = 123://私有权限内容，类外访问不到
  system(" pause" );
  return 0;
}

4,struct和class区别

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

2，区别:

（1）struct默认权限为公共。

（2）class 默认权限为私有。

5，成员属性设置为私有

优点1:将所有成员属性设置为私有，可以自己控制读写权限。

优点2:对于写权限，我们可以检测数据的有效性。

例

class xinx
{
public://设置姓名 故名字可读可写 若只有上部分则只可写，若只有下部分则只读
      void setName(string name)
      {
      m_Name=name
      }
      //获取姓名
      string getName()
      {
      return m_name
      }
    
}

案例1 立方体

源代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
class cube
{
public:
	void setl(int l//设置长  下一致
	{
		m_l = l;
	}
	int getl()//获取长  下一致
	{
		return m_l;
	}
	void seth(int h)
	{
		m_h = h;
	}
	int geth()
	{
		return m_h;
	}
	void setw(int w)
	{
		m_w = w;
	}
	int getw()
	{
		return m_w;
	}
public:
	int mj()//计算面积
	{
		return (2 * (m_l * m_w + m_l * m_h + m_w * m_h));
	}
	int tj()//计算体积
	{
		return m_l * m_h * m_w;
	}
	//利用成员函数判断是否相当
	bool issame2(cube z)
	{
		if (m_h == z.geth() && m_w == z.getw() && m_l == z.getl())
		{
		return true;
		}return false;
	}
private:
	int m_l;
	int m_w;
	int m_h;
};
//利用全局函数判断是否相当
bool issame(cube z1, cube z2）//利用bool类型返回1或0
{
	if (z1.geth() == z2.geth() && z1.getw() == z2.getw() && z1.getl() == z2.getl())
	{
		return 1;
	}	
	return 0;
}
int main()
{
	cube z1;
	cube z2;
	z1.seth(10);//设定立方体z1初始值
	z1.setl(10);
	z1.setw(6);
	cout<<"c1面积为" << z1.mj() << endl;;
	cout<<"c1体积为"<<z1.tj()<<endl;
	z2.seth(10//设定立方体z2初始值
	z2.setl(10);
	z2.setw(10);
	cout << "c2面积为" << z2.mj() << endl;;
	cout << "c2体积为" << z2.tj() << endl;
	//全局
	bool ret = issame(z1, z2);
	if (ret==1)
	{
		cout << "z1和z2相等"<< endl;
	}
	else {
		cout << "z1和z2不相等" << endl;
	}
	//成员
	bool a = z1.issame2(z2);//直接用z1的issame2和z2进行比较故只用输入一个形参
	cout << a << endl;
	if (a)
	{
		cout << "z1和z2相等" << endl;
	}
	else {
		cout << "z1和z2不相等" << endl;
	}
	return 0;

}

注意事项

成员函数判断

bool a = z1.issame2(z2);

若改为

bool a = issame2(z2);

则会报错因为issame2在封装内故要用z1.进行调用因为已经用z1或z2进行调用所以只用在函数内填入一个参数（z1或z2）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D8b3K0rN-1676032966226)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-13 181416.png)]

案例2 点和圆的关系

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<math.h>
using namespace std;

class Point
{
public:
	void setX(int x)
	{
		m_X = x;
	}
	int getX()
	{
		return m_X;
	}
	void setY(int y)
	{
		m_Y = y;
	}
	int getY()
	{
		return m_Y;
	}
private:
	int m_X;
	int m_Y;
};
class Circle
{
public:
	void setR(int r)
	{
		m_R = r;
	}
	int getR()
	{
		return m_R;
	}
	void setxinx(Point xinx)
	{
		m_Center = xinx;
	}
	Point getxinx()
	{
		return m_Center;
	}

private:
	int m_R;//半径
	Point m_Center;
};
void isinCircle(Circle&c,Point&p)
{
	float a,b;
	a = pow((c.getxinx().getX() - p.getX()), 2) + pow((c.getxinx().getY() - p.getY()), 2);
	b = c.getR() * c.getR();
	if (a > b) {
		cout << "点在圆外" << endl;
	}
	else if (a == b)
	{
		cout << "点在圆上" << endl;
	}
	else if (a < b) {
		cout << "点在圆内" << endl;
	}
}
int main()
{
	Circle c;
	c.setR(10);
	Point d;//即命名圆心
	d.setX(10);//即给圆心参数
	d.setY(0);
	c.setxinx(d);
	Point p;
	p.setX(10);
	p.setY(9);
	isinCircle(c, p);
}

注意事项1

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<math.h>

<math.h>数学函数库，在此作用为后面使用pow函数即平方根函数

	a = pow((c.getxinx().getX() - p.getX()), 2) + pow((c.getxinx().getY() - p.getY()), 2);

注意事项2

class Circle
{
public:
	void setR(int r)
	{
		m_R = r;
	}
	int getR()
	{
		return m_R;
	}
	void setxinx(Point xinx)
	{
		m_Center = xinx;
	}
	Point getxinx()
	{
		return m_Center;
	}

private:
	int m_R;//半径
	Point m_Center;
};

封装中可以建立其他封装的内容函数即在类中可以让另一个类作为成员

void setxinx(Point xinx)
    {
		m_Center = xinx;
	}
	Point getxinx()
	{
		return m_Center;
	}

圆与点关系拓展（重点）

我们可以再创建一个头文件和源文件

作用：在大型项目中可以更加清晰制作项目

例point.h(头)

并在头文件中输入#pragma once

并在头文件中将点类函数声明放入其中例

#pragma once
#include<iostream>
using namespace std;
class Point
{
public:
	void setX(int x)

	int getX()

	void setY(int y)

	int getY()

private:
	int m_X;
	int m_Y;
};

在本例中创建圆类的源文件中因为圆类中存在点类故需加入#include"point.h"

其他部分类似

point.cpp（源）

并在源文件中输入#include"point.h"

并在源文件中将点类函数实现放入其中例

但是要在命名前输入 Point::即(定义域)


	void Point::setX(int x)
	{
		m_X = x;
	}
	int Point::getX()
	{
		return m_X;
	}
	void Point::setY(int y)
	{
		m_Y = y;
	}
	int Point::getY()
	{
		return m_Y;
	}

2，对象的初始化和清理

1，生活中我们买的电子产品都基本会有出厂设置，在某-天我们不用时候也会删除一些自己信息数据保证安全

2，C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

1，构造函数和析构函数

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

（1）一个对象或者变是没有初始状态，对其使用后果是未知。

（2）同样的使用完一个对象或变量，没有及时清理,也会造成一定的安全问题。

2，C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

3，对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供。

4，编译器提供的构造函数和析构函数是空实现。

2，作用

构造函数:主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

析构函数:主要作用在于对象销毁前系统自动调用，执行一些清理工作。

3，语法

构造函数语法:类名(){}

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

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

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

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

例

class person
{
    public:
    person()
    {
        cout<<"person 构造函数的调用"<<endl;//你不写他就空实现即没有东西输出你写了就用你的
    }
}
void test01()
{
   Person p; //只是创建了一个对象并没有调用，在栈上的数据，test01执行完毕后，释放这个对象
}
int main()
{
    test01()
    system("pause")
    return 0;
}

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

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

2.函数名称与类名相同,在名称前加上符号~即（esc键下方）。

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

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

例

class person
{
~person()
  {
  cout<<"person的析构函数"<<endl;
  }
}
void test01()
{
   Person p; //只是创建了一个对象并没有调用，在栈上的数据，test01执行完毕后，释放这个对象即自动调用析构函数
}
int main()
{
    test01();
    person p;//创建在main()中则在请输入任意键继续后才调用一瞬间
    system("pause")
    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vTd0oOBL-1676032966226)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-14 211352.png)]

构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构。

4，构造函数的分类及调用

两种分类方式:

（1）按参数分为:有参构造和无参构造（无参又称为默认构造函数）。

（2）按类型分为:普通构造和拷贝构造。

三种调用方式:

（1）括号法

（2）显示法

（3）隐式转换法

例,分类方式

class Person
{
Person()
   {
   cout<<"person的无参构造调用"<<endl;
   }
Person(int a)
  {
  cout<<"Person的有参构造函数的调用"<<endl;
  }
    //拷贝构造函数
Person(const Person &p)
 {//将传入的人身上的所有属性，拷贝到我身上
    age=p.age;
 }
    int p;
}

例，调用方式

1,括号法

Person p1; //默认构造函数调用
Person p2(10); //有参构造函数
Person p3(p2); //拷贝构造函数

注意事项

调用默认构造函数时候，不要加()

因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象

Person p1()

2、显示法

Person p1;
Person p2=Person(10);//有参构造
Person P3=Person(P2);//拷贝构造
//单个时为匿名对象
//Person(10); //匿名对象特点: 当前行执行结束后，系统会立即回收掉匿名对象

注意事项2

不要利用拷贝构造函数初始化匿名对象编译器会认为 Person (p3) == Person p3;对象声明

（匿名对象就是没有名字的对象，没有对象名的对象）

作用:
（1）提高开发效率；匿名对象当前行使用之后，如果没有其他引用数据类型的变量保存其地址，直接销毁；
（2）简化代码结构
（3）通过匿名对象直接调用成员方法；
（4）使用匿名对象作为方法的参数；

Person p5(p4);

5，拷贝构造函数调用时机

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

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

（2）值传递的方式给函数参数传值。

（3）以值方式返回局部对象。

//1、 使用一个己经创建完毕的对象来初始化一个新对象
class Person
{
    public:
    Person(int a)
    {
       age=a;
    }
    Person(const Person &p)
    {
        age=p.age;//要用p.引用age
    }
    public:
    int age;
    
};
void test01()
{
Person p1(20) ;
Person p2(p1) ;
cout <<"P2的年龄为"<< p2.Age 《endl;
}
//2. 值传递的方式给函数参数传值
void doWork(Person p)//值传递会拷贝一个临时的副本即调用了拷贝构造函数
{
    
}
void test02()
{
    Person p;
    doWord(p);
}
//方式返回局部对象
Person dowork02()
{
    person P1;//并不是返回P1,而是拷贝一个P1返回
    cout<<(int*)&p1<<endl;
    return p;//因为返回值为p1即Person中成员故要用Person类型接收
}
void test03()
{
    Person p=dowork2();
}

6，构造函数调用规则

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

（1）默认构造函数(无参，函数体为空即空实现 )。

（2）默认析构函数(无参，函数体为空即空实现)。

（3）默认拷贝构造函数,对属性进行值拷贝。

例（3）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-scGChhOT-1676032966226)(C:\Users\y’z\Desktop\C++\屏幕截图 2022-11-18 193010.png)]

没写拷贝构造函数但他默认提供了m_Age=p.m_Age;

构造函数调用规则如下:

（1）如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造。

如果没有默认构造函数则无法调用

Person p;//创建一个p类名

（2）如果用户定义拷贝构造函数，C++不会再提供其他构造函数。

7，深拷贝与浅拷贝

浅拷贝:简单的赋值拷贝操作。

深拷贝:在堆区重新申请空间,进行拷贝操作。

例


class person
{
public:
	person()
	{
		cout << "person 无参函数的调用" << endl;
	}
	person(int p,double c)
	{
		age = p;
		height = new double(c);
		cout << "person 有参函数的调用" << endl;
	}
//自己实现拷贝构造函数解决浅拷贝带来的问题即系统自带的拷贝构造函数无法运行析构内代码
person(const person &p)
{
   age=p.age 
  //height = p.height;编译器默认实现就是这行代码
  //深拷贝操作
  height = new int (*p.height); 
}
	~person()
	{
//析构代码，将堆区开辟数据做释放操作
        if(height!=NULL)
        {
            delete height;
            height=NULL;
        }
		cout << "person的析构函数的调用" << endl;
	}
	int age;
	double* height;
};
void test01()
{
	person p1(18,160);//即浅拷贝
//栈区的数据先进后出
    person P2(P1)
	cout << p1.age <<" " << *p1.height << endl;
    cout << p2.age <<" " << *p2.height << endl;
}
int main()
{
	test01();
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dCSOCYXF-1676032966226)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-17 125258.png)]

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

8，初始化列表

作用:

C++提供了初始化列表语法，用来初始化属性

语法:构造函数(): 属性1(值1),属性2 (值2) … {}

//传统初始化操作
person(int a,int b,int c)
{
    A=a;
    B=b;
    C=c;
}
person():A(10),B(20),C(30)
{
    
}
person(int a,int b,int c,)A(a),B(b),C(c)
int A;
int B;
int C;

9, 类对象作为类成员

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

例

class Phone
{
    public:
    Phone(string pName)
    {
        m_PName=PName;
    }
    string m_PName;
};
class person
{
    public:
    person(string name,string pName):m_Name(name),m_phone(pName)//m_phone m_Phone=pName
};
string m_Name;
Phone m_Phone;
void test01()
{
    person p("张三"，"苹果")
}

person 类中有对象Phone作为成员，Phone为对象成员。

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后?

当其他类对象作为本类成员，构造时候先构造类对象，再构造自身，析构的顺序与构造相反

即在本例中先构造手机在构造人

10,静态成员

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

静态成员分为:

（1）静态成员变量

所有对象共享同一份数据。

在编译阶段分配内存。

类内声明,类外初始化。

例

class Person
{
public:
 //所有对象共享同一份数据。
 static int m_A;//类内声明
    //静态成员变量也有访问权限的
    private:
    static int m_B;
}
int Person::m_A=100;//类外初始化
int Person::m_B=200;
void test01()
{
//静态成员变量不属于某个对象上，所有对象都共享同一份数据
//因此静态成员变量有两种访问方式
//1、通过对象进行访问
    Person p;
//cout<<p.m_A<< endl;
//2、 通过类名进行访问
cout < Person::m_A << endl;
//cout < Person::m_B << endl;//不可以访问因为为私有权限
}

int main()
{
}

（2）静态成员函数

所有对象共享同一个函数。

静态成员函数只能访问静态成员变量。

例

class Person
{
public:
 static void func()//静态成员函数
 {
     m_a=100;//静态成员函数能访问静态成员变量。因为为静态成员变量大家都用同一份
     m_B=200;//马上报错因为m_B非静态成员变量,无法区分到底是那个对象的m_B属性例如果p1和p2同时调用无法区分
     cout<<"static void func()的调用"<<endl;
     //静态成员函数也有访问权限的
 private:
     static void func2()
     {
     cout<<"static void func2()的调用"<<endl;
     }
 }
 static int m_A;
    int m_B;
}
int Person::m_A=0;
void test01()
{
    //通过对象进行访问
    Person p;
    p.func();
    //通过类名进行访问
    Person::func();
    Person::func2()//类外访问不到私有静态成员函数
}
int main()
{
}

3，C++对象模型和this指针

1，成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储。

只有非静态成员变量才属于类的对象上。

注意事项

空对象占用内存空间为: 1。

C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置。

每个空对象也应该有一个独一无二的内存地址。

2， this指针概念

（1）指针的定义

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

（2）this指针的用途: .

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

例

class Person
{
public:
    Person(int age)
    {
//this指针指向 被调用的成员函数所属的对象
        this->age=age;//当形参和成员变量同名时，可用this指针来区分因为this为指针所以要用this->来引用
    }
    int age;
};
void test01()
{
 Person p1();
    cout<<p.age<<endl;
}
int main()
{

}

链式编程思想出现

在类的非静态成员函数中返回对象本身，可使用return *this。即链式编程思想

例

class Person
{
public:
 Person(int age)
    {
        this->age=age;
    }
    int age;
 Person& PersonAddAge(Person &p)
  {
    this->age+=p.age
    return *this;//因为返回值为this指针即p2所以要用Person类型来接收，返回本体用&
     //的方式返回,如果不用&则返回p2的值，则会拷贝一份新的数据并不会继续引用
//this指向p2的指针，而*this指向的就是p2这个对象本体
  }
};

void test01()
{
Person p1(10);
Person p2(10);//当p2去调用函数时this指向p2故函数返回为p2时可以继续调用函数
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge( p1);//即链式编程思想
    cout<<p2.age<<endl;
}
int main()
{

}

3，空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

在函数内打印成员都默认加了this->

例

void showPersonAge()
{
//报错原因 是因为传入的指针是为NULL
    if(this==NULL)
    {
        return;
}
cout<<age<<endl;==cout<<this->age<<endl;
}
void test01()
{
    Person *p=NULL;
    p->showPersonAge;
}

4, const修饰成员函数

常函数:

（1）成员函数后加const后我们称为这个函数为常函数

（2）常函数内不可以修改成员属性

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

常对象:

（1）声明对象前加const称该对象为常对象

（2）声明对象前加const称该对象为常对象

例

class Person
{
public:
//this指针的本质是 指针常量 指针的指向是不可以修改的
    //即Person *const this;如果后加const则为const Person *const this
    void showPerson()const//即在后面写const后就无法修改m_A
    {
       this->m_A=100;//即报错
    }
    int m_A
    mutable int m _B: //特殊变量，即使在常函数中，也可以修改这个值,因为关键字mutable
};
void test01()
{
const Person p; //在对象前加const,变为常对象
p.m_A=100;
p.m_B = 100; //m_ B是特殊值，在常对象下也可以修改
//常对象只能调用常函数
p.showPerson() ;
//p. func(): //常对象 不可以调用普通成员函数，因为普通成员函数可以修改属性|
}
int main()
{

}

4，友元

友元的目的就是让一个函数或者类访问另一个类中私有成员

友元的关键字为friend。

友元的三种实现

1，全局函数做友元

即在类中前面添加

friend void goodGay (Building *building);

即goodGay全局函数是Building好朋友，可以访问Building中私有成员

2，类做友元

目的为了可以样一个类访问另一个类的私有成员

即在包含类中前面添加被包含的类名称

friend class GoodGay ;

GoodGay类是本来的好朋友，可以访问本类中私有成员|

类外写成员函数

Building::Building()//类中要包含Building()声明
{
m_SittingRoom ="客厅" ;
m_BedRoom ="卧室" ;|
}

3，成员函数做友元

即在包含类中前面添加被包含的类的成员函数名称

friend void GoodGay::visit();

告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友，可以访问私有成员

5，运算符重载

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

1，加号运算符重载

作用:实现两个自定义数据类型相加的运算关键字**（operator+）**

例


class Person
{
public:
    int m_A;
    int m_B;
};
void test01()
{
    Person p1;
    Person p2;
    p1.m_A=10;
    p1.m_B=10;
    p2.m_A=10;
    P2.m_B=10;
Person p3=p1+p2;
    cout<<"p3.m_A="<<p3.m_A<<endl;
    cout<<"p3.m_B="<<p3.m_B<<endl;
}
//全局函数重载+号
Person operator+(Person &p1,Person &P2)
{
    Person temp;
    temp.m_A=p1.m_A+p1.m_B;
    return temp;
}
int main()
{
tset01();
return 0;
}

2，左移运算符重载（运用了链式结构）

作用:可以输出自定义数据类型关键字**(operator<<)和cout的数据类型为（ostream）**

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-11mX3ZUm-1676032966227)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 103537.png)]

故只能用全局函数来定义左移运算符重载

class Person
{
	friend ostream& operator<<(ostream& cout, Person& p);
	friend void test01();//用二个友元开放权限
public:

private:
	int m_A;
	int m_B;
};
ostream& operator<<(ostream& cout, Person& p)//链式思想来使其不断的返回cout使test01的cout<<p<<endl;代码不报错
{
	cout << "m_A=" << p.m_A << " m_B=" << p.m_B;
	return cout;
}
void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout << p << endl;
}
int main()
{
	test01();
	return 0;
}

3，递增运算符重载（递减）

作用:通过重载递增运算符,实现自己的整型数据（递减基本一致）

前置递增一定要返回值，后置递增一定要返回引用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tVYkn0mE-1676032966227)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 110752.png)]

class Person
{
	friend ostream& operator<<(ostream& cout, Person p);
	friend void test01();//用二个友元开放权限
public:
//void operator++(int) int代表占位参数， 可以用于区分前置和后置递增
	Person operator++(int)//后置递增++
	{
		Person temp;
		temp = *this;//先保存数据
		m_A++;//然后再++
		return  temp;//返回局部变量temp,用值接收因为temp为栈区数据用完清除
	}
	Person& operator++()//前置递增++
	{
		++m_A;
		return *this;//this指针返回最近的对象即++m_A，要用引用接收，不然则会重新拷贝一份数据
	}
private:
	int m_A=0;
	int m_B;
};
ostream& operator<<(ostream& cout, Person p)//链式思想来使其不断的返回cout使test01的cout<<p<<endl;代码不报错
{
	cout << p.m_A<< endl;
	return cout;
}
void test01()
{
	Person p1;
	cout << ++p1 << endl;
	cout << p1 << endl;
}
void test02()
{
	Person p;
	cout << p++ << endl;
	cout << p << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}

4，赋值运算符重载

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

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

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

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

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7vVxcVG0-1676032966227)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 125718.png)]

例

class Person
{
public:
	Person(int age)
	{
		m_age = new int(age);//浅拷贝
	}
	~Person()
	{
		if (m_age != NULL)//自主释放堆区内存即上步new int(age)中的内存
			//但是因为浅拷贝问题会崩故需要重载=号并利用深拷贝
		{
			delete m_age;
			m_age = NULL;
		}
	}
	Person& operator=(Person& p)
	{
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
		m_age = new int(*p.m_age);//深拷贝
		return *this;//返回最近的对象在本例中为p3
	}
public:
	int *m_age;
};
void test01()
{
	Person p1(18);
	Person p2(19);
	Person p3(20);
	p1 = p2 = p3;
	cout << *p1.m_age<<" " << *p2.m_age <<" " << *p3.m_age << endl;
}
int main()
{
	test01();
	return 0;
}

5，关系运算符重载

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

例

class Person
{
	friend bool operator!=(Person& p, Person& q);//友元
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)//即如果我自身的m_Name==传进来的p.m_Name
		{
			return true;
		};
		return false;
	}
private:
	string m_Name;
	int m_Age;
};
bool operator!=(Person &p, Person &q)//全局函数重载
{
	if (p.m_Name != q.m_Name || p.m_Age != q.m_Age)//如果m_Name和m_Age有一个不一样则返回true
	{
		return true;
	};
	return false;
}

void test01()
{
	Person p1("张三",18);
	Person p2("李四", 18);
	if (p1 == p2)
	{
		cout << "p1和p2相等" << endl;
	}
	else cout << "p1和p2不相等" << endl;
}
void test02()
{
	Person p1("张三", 18);
	Person p2("李四", 18);
	if (p1 != p2)
	{
		cout << "p1和p2不相等" << endl;
	}
	else cout << "p1和p2相等" << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}

6，函数调用运算符重载

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

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

仿函数没有固定写法，非常灵活（在类内）

例

class Person
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};
void test01()
{
	Person p;
	int ret=p(100, 100);
	cout << ret << endl;
}
int main()
{
	test01();
	return 0;
}

6，继承

继承是面向对象三大特性之一

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-331Q90sg-1676032966228)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 172818.png)]

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

1，继承的基本语法

继承的好处:减少重复代码

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

子类也称为派生类

派生类中的成员，包含两大部分:

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

父类也称为基类

例

class BasePage
{
public:
	void header() {
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer() {
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++、...(公共分类列表)" << endl;
	}
};
class Java:public BasePage//即继承方法
{
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};
class Python :public BasePage//即继承方法
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
class CPP :public BasePage//即继承方法
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};
void test01()
{
	cout << "Java下载视频页面如下:" << endl; 
	Java ja;
	ja.header(); 
	ja.footer(); 
	ja.left(); 
	ja.content();
	cout << "---------------------" << endl;
	cout << "C++下载视频页面如下:" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
	cout << "---------------------" << endl;
	cout << "Python下载视频页面如下:" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
}
int main()
{
	test01();
	return 0;
}

2，继承方式

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

继承方式—共有三种:

公共继承（成员类内可以访问类外可以访问）

保护继承（成员类内可以访问类外不可以访问）

私有继承（成员类内可以访问类外不可以访问）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7xarMFq6-1676032966228)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 180511.png)]

3，继承中的对象模型

问题:从父类继承过来的成员，哪些属于子类对象中?

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xGkgldZ3-1676032966228)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 193247.png)]

打开vs开发人员命令工具

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aGb8b7Ph-1676032966229)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 193956.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Fd7Eco0-1676032966229)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 193722.png)]

4，继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题:父类和子类的构造和析构顺序是谁先谁后?

继承中的构造和析构顺序如下:

先构造父类，再构造子类，析构的顺序与构造的顺序相反

（和类嵌套一样）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PyePffsN-1676032966229)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 194757.png)]

5，继承同名成员处理方式

问题:当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢?

同名成员属性处理

访问子类同名成员直接访问即可

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tTBxtoPP-1676032966229)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 195935.png)]

访问父类同名成员需要加作用域

例

cout<<"父类 下的成员"<<s.父类名::m_A<<endl;

同名成员函数处理

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-43R50qXj-1676032966229)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-20 200737.png)]

总结:

1.子类对象可以直接访问到子类中同名成员

2.子类对象加作用域可以访问到父类同名成员

3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

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

静态成员和非静态成员出现同名，处理方式—致（只不过有两种访问方法）

（1）访问子类同名成员直接访问即可

（2）访问父类同名成员需要加作用域

访问静态成员可通过两种方式

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Y0TGNkU-1676032966230)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-21 130235.png)]

访问静态成员函数也可通过两种方式

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oOO8xAAg-1676032966230)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-21 130939.png)]

7，多继承语法

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

语法:class子类∶继承方式父类1,继承方式父类2…

多继承可能会引发父类中有同名成员出现，需要加作用域区分（即二义性）

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

8，菱形继承

菱形继承概念:

两个派生类继承同一个基类

又有某个类同时继承者两个派生类

这种继承被称为菱形继承，或者钻石继承

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l2fsWRvl-1676032966230)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-21 192440.png)]

利用虚继承，可以菱形继承的问题

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xQhxOIl7-1676032966230)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-21 193539.png)]

底层图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RNo3XbOu-1676032966231)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-21 194043.png)]

总结

（1）菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

（2）利用虚继承可以解决菱形继承问题（即virtual关键字）

4，多态

1，多态的基本概念

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

多态分为两类

静态多态:函数重载和运算符重载属于静态多态，复用函数名（）

动态多态:派生类和虚函数实现运行时多态

静态多态和动态多态区别:

静态多态的函数地址早绑定 - 编译阶段确定函数地址

动态多态的函数地址晚绑定 - 运行阶段确定函数地址

函数重写定义

重写函数返回值类型函数名参数列表完全相同

虚函数关键字（virtual)

class Person
{
public:
	//虚函数
	virtual void speak()
	{
		cout << "人在说话" << endl;
	}
};
class xiaoming:public Person
{
public:
	void speak()
	{
		cout << "小明在说话" << endl;
	}
};
class xiaohong :public Person
{
public:
	void speak()
	{
		cout << "小红在说话" << endl;
	}
};
//执行说话的函数
//地址早绑定在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定
//需要在运行阶段进行绑定，地址晚绑定
//即使用虚函数
// 父类的指针或者引用执行子类对象
void doSpeak(Person &person)//Person &person=xm;
{
	person.speak();
}
void test01()
{
	xiaoming xm;
	xiaohong xh;
	doSpeak(xm);
	doSpeak(xh);
}
int main()
{
	test01();
	return 0;
}

多态满足条件:

1、有继承关系

2、子类重写分类中的虚函数

多态使用:

父类指针或引用指向子类对象

指针类型字节大小为4个字节

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dAWjlfjk-1676032966231)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-21 215116.png)]

2，多态案例一计算器类

案例描述:

分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类。

多态的优点:

代码组织结构清晰。

可读性强。

利于前期和后期的扩展以及维护。

例

//传统计算机方法
class Calculator
{
public:
	int getRseult(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;
		}
		else if(oper=="/")
		{
			return m_Num1 / m_Num2;
		}
	}
	int m_Num1;
	int m_Num2;
};
//使用多态的方法
class AbstractCalculator
{//实现计算机抽象类即类内没有计算过程
public:
	virtual int gtResult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
class Add :public AbstractCalculator
{
	int gtResult()
	{
		return m_Num1 + m_Num2;
	}
};
class jian :public AbstractCalculator
{
	int gtResult()
	{
		return m_Num1 - m_Num2;
	}
};
class ceng :public AbstractCalculator
{
	int gtResult()
	{
		return m_Num1 * m_Num2;
	}
};
void test01()
{
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getRseult("*") << endl;
}
void test02()
{    //多态使用条件
	//父类指针或者引用指向子类对象
	AbstractCalculator* abc = new ceng;//创建乘法计算器所以下面计算为乘法
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->gtResult() << endl;
    delete abc//即使用完了删除数但是下面还是可以使用new指针只是没有数据
}
int main()
{
	//test01();
	test02();
	return 0;
}

3，纯虚函数和抽象类

在多态中，通常父类中虚函教的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法:

virtual返回值类型函数名(参数列表)= 0 ;

当类中有了纯虚函数,这个类也称为抽象类

抽象类特点:

（1）无法实例化对象

（2）子类必须重写抽象类中的纯虚函数，否则也属于抽象类

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rw0zmkhk-1676032966231)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 131509.png)]

多态案例2，制作饮品

代码

class yinpin//纯虚函数
{
public:
	virtual void Boil() = 0;
	virtual void Brew() = 0;
	virtual void PourInCup() = 0;
	virtual void Putthing() = 0;
	void makeyinpin()
	{
		Boil();
		Brew();
		PourInCup();
		Putthing();
	}
};
class kaf:public yinpin
{
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void Putthing()
	{
		cout << "加入糖和奶" << endl;
	}
};
class caye:public yinpin
{
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void Putthing()
	{
		cout << "加入柠檬" << endl;
	}
};
void doWork(yinpin* abc)//用指针来接收new的指针
{
	abc->makeyinpin();
}
void test01()//我想的方法
{
	kaf k;
	k.makeyinpin();
	caye c;
	c.makeyinpin();
}
void test02()//老师想的方法
{
	doWork(new kaf);//使用new返回一个堆区的指针要用对应的指针来接收
}
int main()
{
	test01();
	test02();
	return 0;
}

5，虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bJU76ZCd-1676032966231)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 162307.png)]

解决方式:将父类中的析构函数改为虚析构或者纯虚析构

虚析构图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Anhfx1W7-1676032966231)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 162455.png)]

纯虚析构图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4trFQr21-1676032966232)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 163223.png)]

虚析构和纯虚析构共性:

可以解决父类指针释放子类对象

都需要有具体的函数实现虚析构和纯虚析构

区别:

如果是纯虚析构，该类属于抽象类,无法实例化对象

虚析构语法:

virtual ~类名(){}

纯虚析构语法:

virtual ~类名()=0;
类名::~类名(){}

总结:

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

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

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

多态案例3，电脑组装

案例思路图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T3Y5fEW5-1676032966232)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 165028.png)]

案例代码

//抽象CPU类
class CPU
{
public:
	virtual void jisuan() = 0;
};

//抽象显卡类
class Xiank
{
public:
	virtual void xians() = 0;
};

//抽象类
class Neic
{
public:
	virtual void cengc() = 0;
};
class Computer
{
public:
    Computer(CPU*cpu,Xiank*xk,Neic*nc)//将三个指针传入构造函数
	{
		m_cpu = cpu;//并用类内指针来接收
		m_vc = xk;
		m_mem = nc;
	}
	void zuz(CPU* cpu, Xiank* xk, Neic* nc)//将三个指针传入构造函数
	{
		m_cpu = cpu;//并用类内指针来接收
		m_vc = xk;
		m_mem = nc;
	}
	void work()
	{
		m_cpu->jisuan();//将上个函数传入的指针再传入个个分类中
		m_vc->xians();
		m_mem->cengc();
	}
	//提供析构函数来释放三个电脑零件
	~Computer()
	{
		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指针
	Xiank* m_vc;//显卡指针
	Neic* m_mem;//内存指针
};
//Intel厂商
class IntelCpu:public CPU
{
	void jisuan()
	{
		cout << "Intel的CPU开始计算了"<<endl;
	}
};
class IntelXiank :public Xiank
{
	void xians()
	{
		cout << "Intel的显卡开始显示了" << endl;
	}
};
class IntelNeic :public Neic
{
	void cengc()
	{
		cout << "Intel的内存开始存储了" << endl;
	}
};
//Lenovo厂商
class LenovoCpu :public CPU
{
	void jisuan()
	{
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};
class LenovoXiank :public Xiank
{
	void xians()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};
class LenovoNeic :public Neic
{
	void cengc()
	{
		cout << "Lenovo的内存开始存储了" << endl;
	}
};
void test01()
{
	CPU* intelCpu = new IntelCpu;
	Xiank* intelxiank = new IntelXiank;
	Neic* intelneic = new IntelNeic;
	//创建第一台电脑
	cout << "第一台电脑" << endl;
	Computer* computer1 = new Computer(intelCpu,intelxiank, intelneic);
	computer1->work();
	delete computer1;
	//创建第二台电脑
	cout << "第二台电脑" << endl;
	Computer* computer2 = new Computer(new LenovoCpu, new LenovoXiank, new LenovoNeic);
	computer2->work();
	delete computer2;
	cout << "第三台电脑" << endl;
	Computer* computer3 = new Computer(new LenovoCpu, new IntelXiank, new LenovoNeic);
	computer3->work();
	delete computer3;
}
int main()
{
	test01();
	return 0;
}

五，文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放

通过文件可以将数据持久化

C++中对文件操作需要包含头文件**< fstream >**

文件类型分为两种:

1.文本文件 - 文件以文本的ASCII码形式存储在计算机中

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

操作文件的三大类

1.ofstream:写操作

2.fstream :读写操作

3.fstream :读写操作

1，文本文件

1，写文件写文件

步骤如下:

1.包含头文件

#include

2.创建流对象

ofstream ofs；

3.打开文件

ofs.open(“文件路径”.,打开方式)；

4.写数据

ofs <<“写入的数据”"；

5.关闭文件

ofs.close();

文件打开方式图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LQ8Eti6m-1676032966232)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 190358.png)]

注意:文件打开方式可以配合使用，利用|操作符

例如:用二进制方式写文件

ios::binary |ios::out

代码案例

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<math.h>
#include<fstream>
using namespace std;
//创建流对象
void test01()
{//创建流对象
	ofstream ofs;
	//指定打开方式
	ofs.open("test.txt", ios::out);
	//写内容
	ofs << "姓名：张三" << endl;
	ofs << "性别：男" << endl;
	ofs << "年龄：18" << endl;
	//关闭文件
	ofs.close();
	//创建流对象
	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)//EOF endl of file
	//{
		//cout << c;
	//}
	//关闭文件
	ifs.close();
}

总结:

文件操作必须包含头文件fstream

读文件可以利用ofstream ，或者fstream类

打开文件时候需要指定操作文件的路径，以及打开方式

利用<<可以向文件中写数据

操作完毕，要关闭文件

2，二进制文件

以二进制的方式对文件进行读写操作

打开方式要指定为ios:binary

1，写文件

二进制方式写文件主要利用流对象调用成员函数write

函数原型:

ostream& write(const char * buffer,int len);

参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数

二进制写文件

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xSC4LafA-1676032966232)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 200134.png)]

2，读文件

二进制方式读文件主要利用流对象调用成员函数read

函数原型:

istream& read(char *buffer,int len);

参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数示例:

图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1mKYkJxR-1676032966233)(C:\Users\y’z\Desktop\C++\c++核心编程\屏幕截图 2022-11-22 201057.png)]

职工管理系统

第一部分，职工管理系统主文件即菜单

利用while先做死循环，在用switch进行分支选择

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include"workerManager.h"

using namespace std;

int main()
{  
	//实例化对象
	WorkerManager wm;
	//调用展示菜单成员函数
	int cus = 0;//存储用户选项
	while (true)//死循环可以无限选择
	{
		wm.Show_Menu();
		cout << "请输入你的选择" << endl;
		cin >> cus;
		switch (cus)
		{
		case 0:wm.ExitSystem();//退出系统
			break;
		case 1:wm.Add_Emp();//添加职工
			break;
		case 2: wm.Show_Emp();//显示职工
			break;
		case 3:wm.Del_Emp();//删除职工
			break;
		case 4:wm.Mod_Emp();//修改职工
			break;
		case 5:wm.Find_Emp();//查找职工
			break;
		case 6:wm.Sort_Emp();//编号排序
			break;
		case 7:wm.Clean_File();//清空文档
			break;
		default:
			system("cls");//清空屏幕
				break;
		}
		
	}
	system("pause");
	return 0;
}

第二部分，职工管理类（主要部分）

先创建一个workerManager.h头文件内只放函数声明并在workerManager.cpp做实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once//防止头文件重复包含
#include<iostream>//包含输入输出流的文件
#include<fstream>
#define FILENAME "empFile.txt"//宏常量定义文件名
#include"worker.h"
#include"employee.h"
#include"manager.h"
#include"boss.h"

using namespace std;//使用标准命名空间
//菜单抽象类
class WorkerManager
{
public:
	//构造函数
	WorkerManager();
	//展示函数
	void Show_Menu();
	//退出系统
	void ExitSystem();
	
	//保存文件
	void save();
	//添加职工函数
	void Add_Emp();

	//判断文件是否为空的标志
	bool m_FileIsEmpty;

	//统计人数
	int getp_EmpNum();

	//初始化职工
	void init_Emp();

	//显示职工
	void Show_Emp();

	//删除职工
	void Del_Emp();

	//查找职工是否存在通过编号来查找如果存在返回在数组中的位置
	//不存在返回-1
	int IsExist(int id);

	//显示修改例表
	void xiugai2();

	//修改职工
	void Mod_Emp();

	//查找职工
	void Find_Emp();

	//排序职工
	void Sort_Emp();

	//清空职工
	void Clean_File();

	//析构函数
	~WorkerManager();
    
    //记录职工人数
	int m_EmpNum;
	// 职工数组指针
	Worker** m_EmpArray;//一个Worker类的空间内有类成员三个属性
	//**二级指针可以存放其他指针的地址
};

第三部分，创建职工类及旗下类

创建职工类（worker.h）并在其下方创建三个子类（manager.h,employee.h,boos.h）

worker.h抽象类（只放函数定义）

#pragma once
#include<iostream>
#include<string>
using namespace std;
//职工抽象类
class Worker
{
public:
	//显示个人信息
	virtual void showInfo() = 0;//纯虚函数
	//获取岗位名称
	virtual string getDeptName() = 0;
	int m_Id;//成员编号
	string m_Name;//职工姓名
	int m_DeptIdl;//职工所在部门名称编号
};

manager.h抽象类及旗下manager.cpp

#pragma once
#include<iostream>
using namespace std;
#include"worker.h"

class Manager :public Worker
{
public:
	//构造函数因每个经理在创造时应该初始化属性
	Manager(int id, string name, int did);
	
	virtual void showInfo();//展示信息函数
    //virtual关键字可以删除可以不删
	virtual string getDeptName();//获得部门函数
};

manager.cpp（函数实现）

#define _CRT_SECURE_NO_WARNINGS 1
#include"manager.h"


Manager::Manager(int id, string name, int did)
{
	this->m_Id=id;
	this->m_Name=name;
	this->m_DeptIdl=did;
}
void Manager::showInfo()
{
	cout << "职工编号：" << this->m_Id
		<< "\t职工姓名" << this->m_Name
		<< "\t岗位" << this->getDeptName()
		<< "\t岗位职责：完成老板提交的任务，并下发任务给员工" << endl;
}
string Manager::getDeptName()
{
	return"经理";//return "经理"==return string("经理")
	//如果不写string则系统自带即帮我们隐实现
}

employee.h抽象类及旗下employee.cpp

#pragma once
//普通职工文件
//只放函数定义
#include<iostream>
using namespace std;
#include"worker.h";
class Employee :public Worker
{
public:
	//构造函数因每个员工在创造时应该初始化属性
     Employee(int id, string name, int dId);
	
	//显示个人信息
	virtual void showInfo();//virtual关键字可以删除可以不删
    //获取岗位名称
	virtual string getDeptName();

};

employee.cpp（函数实现）

#define _CRT_SECURE_NO_WARNINGS 1
#include"employee.h"
//构造函数
//只放函数实现所以不用写类
Employee::Employee(int id, string name, int dId)
{
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptIdl = dId;
}
//显示个人信息
void Employee::showInfo()
{
	cout << "职工编号：" << this->m_Id 
		<< "\t职工姓名" << this->m_Name
		<<"\t岗位"<<this->getDeptName()
		<<"\t岗位职责：完成经理提交的任务"<<endl;
}
//获取岗位名称
string Employee::getDeptName()
{
	return "员工";
}

boss.h抽象类及旗下boss.cpp

#pragma once
#include<iostream>
using namespace std;
#include"worker.h"
class Boss :public Worker
{
	public:
	//构造函数因每个老板在创造时应该初始化属性
     Boss(int id, string name, int dId);
	//显示个人信息
	virtual void showInfo();
	//获取岗位名称
	virtual string getDeptName();
};