Visual Studio 2022版本 B站黑马程序员C++自学分享－第二阶段（主要包括：自己敲的代码、通过注释来备注上自己对代码的理解）

littleCodeLearner

已于 2023-03-19 16:48:10 修改

阅读量1.7k

点赞数 33

分类专栏： C++学习文章标签： c++ visual studio 开发语言数据结构开源

于 2023-03-12 17:07:07 首次发布

本文链接：https://blog.csdn.net/qq_63317769/article/details/129476992

版权

C++学习专栏收录该内容

4 篇文章 7 订阅

订阅专栏

Visual Studio 2022版本 B站黑马程序员C++自学分享－第二阶段（主要包括：自己敲的代码、通过注释来备注上自己对代码的理解）

前言
二、第二阶段 C++核心编程介绍C++面向对象编程，为大型项目做铺垫

前言

黑马的课程里面分为了三大阶段
一、第一阶段 C++基础语法入门对C++有初步了解，能够有基础编程能力
二、第二阶段 C++核心编程介绍C++面向对象编程，为大型项目做铺垫
三、第三阶段 C++提高编程介绍C++泛型编程思想，以及STL的基本使用
※※※我会一个阶段发一个文章，一共发布三个文章来把学习的代码还有自己在代码旁边标注的对于这些代码的理解和心得体会一起分享给大家！！！

该文章的目的：
1.把本人跟着黑马敲的代码都发布在文章内，供大家复制粘贴和参考等等
2.就当作存储代码的一个云空间了，放在电脑里还占内存
3.在学习的时候，对于代码的理解我都在旁边进行了注释，望大家能够快速消化吸收

因为本人还有好多代码是没有深究的，到了后来我记得有一个地方要在类内成员函数后面要加const的这个（2022版本要敲，但是黑马那个2015的就不用），类似的等等，没有特别研究，是看弹幕大佬这么说的我就这么去敲的，所以如果大家能够对这篇文章所有的代码有疑问的话请积极在评论区留言，大家一块讨论。

二、第二阶段 C++核心编程介绍C++面向对象编程，为大型项目做铺垫

1.内存分区模型

1.1程序运行前

/*
内存分区模型：
C++程序在执行时，将内存大方向划分为4个区域
1、代码区：存放函数体的二进制代码，由操作系统进行管理的
2、全局区：存放全局变量和静态变量以及常量
3、栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
4、堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存四区意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程
*/
/*
1.1程序运行前
在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域
代码区：
存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此
全局区还包含了常量区，字符串常量和其他常量也存放在此
该区域地数据在程序结束后由操作系统释放
*/
/*
综上所述：
C++在程序运行前分为全局区和代码区
代码区特点是共享和只读
不在全局区中：局部变量、局部常量（const修饰的局部变量）
在全局区中：全局变量、静态变量（static关键字）、字符串常量、全局常量（const修饰的全局变量）
*/
#include <iostream>
using namespace std;

//全局变量
int g_a = 10;
int g_b = 10;
//const修饰的全局变量，叫全局常量
const int c_g_a = 10;
const int c_g_b = 10;
int main1()
{
	//全局区

	//全局变量、静态变量、常量

	//创建普通局部变量
	int a = 10;
	int b = 10;
	cout << "局部变量a的地址为： " << (int)&a << endl;
	cout << "局部变量b的地址为： " << (int)&b << endl;

	cout << "全局变量g_a的地址为： " << (int)&g_a << endl;
	cout << "全局变量g_b的地址为： " << (int)&g_b << endl;

	//静态变量
	static int s_a = 10;//在普通变量前面加上static则属于静态变量
	static int s_b = 10;
	cout << "静态变量s_a的地址为： " << (int)&s_a << endl;
	cout << "静态变量s_b的地址为： " << (int)&s_b << endl;

	//常量
	//字符串常量
	cout << "字符串常量的地址为： " << (int)&"hello world" << endl;
	//const修饰的变量
	//const修饰的全局变量，const修饰的局部变量

	cout << "全局常量c_g_a的地址为：" << (int)&c_g_a << endl;
	cout << "全局常量c_g_b的地址为：" << (int)&c_g_b << endl;

	const int c_l_a = 10;//c—const修饰符 g—global全局  l—local局部
	const int c_l_b = 10;
	cout << "局部常量c_l_a的地址为：" << (int)&c_l_a << endl;
	cout << "局部常量c_l_b的地址为：" << (int)&c_l_b << endl;

	system("pause");
	return 0;
}

1.2程序运行后

/*
栈区：
由编译器自动分配释放，存放函数的参数值，局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
*/

/*
堆区：
由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存
*/
#include <iostream>
using namespace std;
//栈区
//不要返回局部变量的地址，
//栈区开辟的数据由编译器自动释放
int* func1(int b)//形参数据也会放在栈区
{
	b = 100;
	int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;//返回局部变量的地址
}

//堆区
int * func2()
{
	//利用new关键字 可以将数据开辟到堆区
	int *p=new int(10);//从堆区里拿出来到栈区的不是其数据本身，而是地址，因此要用指针来接收
	return p;
}
int main2()
{
	//栈区
	//接收func函数的返回值
	int *p1 = func1(1);
	cout << *p1 << endl;//第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p1 << endl;//第二次这个数据就不再保留了

	//堆区
	//在堆区开辟数据
	//指针本质也是局部变量，是放在栈区的，而指针保存的数据是放在堆区的
	int* p2 = func2();
	
	cout << *p2 << endl;
	cout << *p2 << endl;
	cout << *p2 << endl;
	cout << *p2 << endl;

	system("pause" );
	return 0;
}

1.3new操作符

#include <iostream>
using namespace std;
//1、new的基本语法
double* func()
{
	//在堆区创建整形数据
	//new返回的是该数据类型的指针
	double* p = new double(10);
	return p;
}

void test01()
{
	double* 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;//给10个元素赋值100~109
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	//释放堆区数组
	//释放数组的时候 要加[]才可以
	delete[] arr;
}
int main3()
{
	test01();
	test02();
	system("pause");
	return 0;
}

2.引用

2.1引用的基本使用

#include <iostream>
using namespace std;
//作用：给变量起别名
//语法 数据类型 &别名 = 原名
int main1()
{
	int a = 10;
	//创建引用
	int& b = a;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	b = 100;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	system("pause");
	return 0;
}

2.2引用注意事项

#include <iostream>
using namespace std;

int main2()
{
	int a = 10;
	//1、引用必须要初始化
	//int &b;//错误，必须要初始化
	int& b = a;
	//2、引用一旦初始化后，就不可以更改了
	int c = 20;
	b = c;//赋值操作，而不是更改引用
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	cout << "c= " << c << endl;
	system("pause");
	return 0;
}

2.3引用做函数参数

#include <iostream>
using namespace std;
//交换函数

//1、值传递
void mySwap01(int a,int b)
{
	int  temp = a;
	a = b;
	b = temp;
	cout << "swap01 a= " << a << endl;
	cout << "swap01 b= " << b << endl;
}
//2、地址传递
void mySwap02(int* c, int* d)
{
	int  temp = *c;
	*c = *d;
	*d = temp;
	cout << "swap02 c= " << *c << endl;
	cout << "swap02 d= " << *d << endl;
}
//3、引用传递
void mySwap03(int& e, int& f)
{
	int  temp = e;
	e = f;
	f = temp;
	cout << "swap03 e= " << e << endl;
	cout << "swap03 f= " << f << endl;
}
int main3()
{
	//作用：函数传参时，可以利用引用的技术让形参修饰实参
	//优点：可以简化指针修改实参
	int a = 10; int b = 20;
	mySwap01(a, b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;

	int c = 10; int d = 20;
	mySwap02(&c, &d);
	cout << "c= " << c << endl;
	cout << "d= " << d << endl;

	int e = 10; int f = 20;
	mySwap03(e, f);
	cout << "e= " << e << endl;
	cout << "f= " << f << endl;

	system("pause");
	return 0;
}

2.4引用做函数返回值

#include <iostream>
using namespace std;
//引用做函数的返回值
//1、不要返回局部变量引用
int& test01()
{
	int a = 10;//局部变量存放在四区中的栈区
	return a;
}

//2、函数调用作为左值
int& test02()
{
	static int a = 10;//静态变量存放在全局区,全局区上的数据在程序结束后系统释放
	return a;
}
int main4()
{
	//作用：引用是可以作为函数的返回值存在的

	//1、不要返回局部变量引用
	int& ret = test01();
	cout << "ret= " << ret << endl;//第一次结果正确，是因为编译器做了保留
	cout << "ret= " << ret << endl << endl;//第二次结果错误，因为a的内存已经释放
	
	//2、函数的调用作为左值
	int& ret2 = test02();
	cout << "ret2= " << ret2 << endl;
	cout << "ret2= " << ret2 << endl;
	cout << "ret2= " << ret2 << endl << endl;
	test02() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值
	cout << "ret2= " << ret2 << endl;
	cout << "test02()= " << test02() << endl;
	cout << "ret2= " << ret2 << endl;
	system("pause");
	return 0;
}

2.5引用的本质

#include <iostream>
using namespace std;

void func(int& ref)//发现是引用，转换为 int *const ref=&a;
{
	ref = 1000;//ref是引用，转换为*ref=100
}
int main5()
{
	//本质： 引用的本质在C++内部实现是一个指针常量
	int a = 10;

	int& ref = a;//自动转换为int *const ref=&a;指针常量是指针指向不可改，也说明为什么引用不可更改
	ref = 20;//内部发现ref是引用，自动帮我们转换为: *ref=20
	cout << "a= " << a << endl;
	cout << "ref= " << ref << endl;
	
	func(a);

	system("pause");
	return 0;
}

2.6常量引用

#include <iostream>
using namespace std;

//打印数据的函数
void showValue(const int& val)//修饰形参，防止误操作
{
	//val = 1000;
	cout << "val= " << val << endl;
}
int main6()
{
	//作用：常量引用主要用来修饰形参，防止误操作
	//在函数形参列表中，可以放const修饰形参，防止形参改变实参
	int b = 10;
	//int& f = 10;//引用必须引一块合法的内存空间
	const int& ref = 10;//加上const之后 编译器将代码修改为：int temp = 10;const int & ref =temp;
	//ref = 20;//加入const之后变为只读，不可以修改

	int a = 100;
	showValue(a);
	cout << "a= " << a << endl;
	system("pause");
	return 0;
}

3.函数提高

3.1函数默认参数

#include <iostream>
using namespace std;
//函数默认参数
//如果我们自己传入数据，就用自己的数据，如果没有，那么用默认值
//语法： 返回值类型 函数名(形参=默认值) {}
int func(int a, int b=20, int c=30)
{
	return a + b + c;
}
//注意事项：
//1、如果某个位置已经有了默认参数，那么这个位置往后，从左到右都必须有默认值
//int func2(int a, int b=10, int c,int d=10)
//{
//	return a + b + c + d;
//}
//int func3(int a, int b, int c, int d = 10)
//{
//	return a + b + c + d;
//}

//2、如果函数声明有默认参数，函数实现就不能有默认参数
//函数的声明和实现两个里只能有一个有默认参数
int func3(int a = 10, int b = 10);
int func3(int a, int b)
{
	return a + b;
}
int main1()
{
	// cout << func(10, 20, 30) << endl;
	cout << func(10) << endl;
	cout << func(10, 30) << endl << endl;

	cout << func3(10, 20) << endl;
	system("pause");
	return 0;
}

3.2函数占位参数

#include <iostream>
using namespace std;

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

//目前阶段的占位参数 我们还用不到，后面课程中会用到
//占位参数还可以有默认参数
void func(int a,int=20)
{
	cout << "this is func	" << endl;
}
int main2()
{
	func(10);
	system("pause");
	return 0;
}

3.3.1函数重载概述

#include <iostream>
using namespace std;

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

//函数重载的满足条件
/*
1、同一个作用域下
2、函数名称相同
3、函数的参数类型不同，或个数不同，或顺序不同
*/
void func()
{
	cout << "this is func" << endl;
}
void func(int a)
{
	cout << "this is func(int a)" << endl;
}
void func(double a)
{
	cout << "this is func(double a)" << endl;
}
void func(int a, double b)
{
	cout << "this is func(int a,double b)" << endl;
}
void func(double b,int a)
{
	cout << "this is func(double b,int a)" << endl;
}
//注意事项
//函数的返回值不可以作为函数重载的条件
//int func(int a, double b)
//{
//	cout << "this is int func(int a,double b)" << endl;
//}
int main3()
{
	func();
	func(1);
	func(1.0);
	//func(1, 1);//报错
	func(1, 1.0);
	func(1.0, 1);
	system("pause");
	return 0;
}

3.3.2函数重载注意事项

#include <iostream>
using namespace std;
//1、引用作为重载的条件
void func(int& a)//int& a= 10;不合法的
{
	cout << "func(int& a)调用" << endl;
}
void func(const int& b)//const int& b = 10;合法的
{
	cout << "func(const int& b)调用" << endl;
}
//2、函数重载碰到默认参数
void func2(int a,int b=10)
{
	cout << "func2(int a,int b = 10)调用" << endl;
}
void func2(int a)
{
	cout << "func2(int a)调用" << endl;
}

int main4()
{
	//1、引用作为重载的条件
	int a = 10;
	const int b = 20;
	func(a);
	func(b);
	func(10);

	//2、函数重载碰到默认参数
	//func2(10);//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况
	system("pause");
	return 0;
}

4.类和对象(1)

4.1封装

/*
意义：将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制
*/

4.1.1(1)封装的意义

#include <iostream>
using namespace std;
//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长
//圆求周长的公式： 2*PI*半径

//class 代表设计一个类，类后面紧跟着的就是类名称
class Circle
{
	//访问权限
	//公共权限
public:
	//属性
	double m_r;//半径

	//行为
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI * m_r;
	}
};
int main1()
{
	//通过圆类创建具体的圆（对象）
	//实例化：通过一个类，来创建一个对象的过程
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;
	cout << "圆的周长为： " << c1.calculateZC() << endl;
	system("pause");
	return 0;
}

4.1.1(2)封装案例

#include <iostream>
using namespace std;
#include <string>
//设计一个学生类，属性有姓名和学号
//可以给姓名和学号赋值，可以显示学生的姓名和学号

//设计学生类
class Student
{
public://公共权限
	//类中的属性和行为 我们统一称为成员
	//属性 又叫：成员属性、成员变量
	string m_Name;//姓名
	int m_Id;//学号

	//行为 又叫：成员函数、成员方法
	//显示姓名和学号
	void showStudent()
	{
		cout << "姓名： " << m_Name << " 学号： " << m_Id << endl;
	}
	//给姓名赋值
	void setName(string name)
	{
		m_Name = name;
	}
	//给学号赋值
	void setId(int id)
	{
		m_Id = id;
	}
};
int main2()
{
	//创建一个具体学生 实例化对象
	Student s1;
	//给s1对象进行属性赋值操作
	//s1.m_Name = "张三";
	s1.setName("张三");
	//s1.m_Id = 1;
	s1.setId(1);
	//显示学生信息
	s1.showStudent();

	system("pause");
	return 0;
}

4.1.1(3)封装的权限控制

#include <iostream>
using namespace std;
/*
访问权限
公共权限 public    成员 类内可以访问 类外可以访问
保护权限 protected 成员 类内可以访问 类外不可以访问 对于继承：儿子可以访问父亲中的内容
私有权限 private   成员 类内可以访问 类外不可以访问 对于继承：儿子不可以访问父亲的私有内容
*/
class Person
{
public:
	//公共权限
	string m_Name;//姓名

protected:
	//保护权限
	string m_Car;//汽车
	
private:
	//私有权限
	int m_Password;//银行卡密码

private:
	void func()
	{
		m_Name = "张三";
		m_Car = "奥迪";
		m_Password = 124453;
	}
};
int main3()
{
	//实例化具体对象
	Person p1;

	p1.m_Name = "李四";
	//p1.m_Car = "奔驰";//保护权限内容，在类外访问不到
	//p1.m_Password = 131211;//私有权限内容，在类外访问不到
	//p1.func();//私有权限内容，在类外访问不到
	system("pause");
	return 0;
}

4.1.2struct和class的区别

#include <iostream>
using namespace std;

//区别
//在C++中struct和class唯一的区别在于默认的访问权限不同
//struct 默认权限是 公共 public
//class  默认权限是 私有 private
class C1
{
	int m_A;//默认权限是 私有
};
struct C2
{
	int m_A;//默认权限是 公共
};
int main4()
{
	C1 c1;
	//c1.m_A = 100;//报错，私有的，不可访问
	C2 c2;
	c2.m_A = 100;//没报错，公共的，可访问
	system("pause");
	return 0;
}

4.1.3成员属性设置为私有

#include <iostream>
using namespace std;
#include <string>
/*
好处：
可以自己控制读写权限
对于写，可以检测数据的有效性
*/

//设计人类
class Person
{
public:
	//写(设置)姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//读(获取)姓名
	string getName()
	{
		return m_Name;
	}

	//获取年龄 可读可写 如果想修改，年龄的范围必须是0~150之间
	int getAge()
	{
		//m_Age = 0;//初始化为0岁
		return m_Age;
	}
	//设置年龄
	void setAge(int age)
	{
		if(age<0||age>150)
		{
			m_Age = 0;
			cout << "您这个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}
	//设置情人 只写
	void setLover(string lover)
	{
		m_Lover = lover;
	}
private:
	//姓名 可读可写
	string m_Name=" ";
	//年龄 只读
	int m_Age=0;
	//情人 只写
	string m_Lover=" ";
};
int main5()
{
	Person p;
	p.setName("张三");
	cout << "姓名为： " << p.getName() << endl;

	//p.m_Age = 18;
	p.setAge(18);
	p.setAge(1000);
	cout << "年龄为： " << p.getAge() << endl;
	system("pause");

	p.setLover("高木");
	//cout << "情人为： " << p.setLover() << endl;//只写，不可访问
	return 0;
}

4.1.4设计案例1-立方体类

#include <iostream>
using namespace std;
//立方体类设计
//1、创建立方体类
//2、设计属性
//3、设计行为 获取立方体面积和体积
//4、分别利用全局函数和成员函数 判断两个立方体是否相等
class Cube
{
public:
	//设置长
	void setL(int l)
	{
		m_L = l;
	}
	//获取长
	int getL()
	{
		return m_L;
	}
	//设置宽
	void setW(int w)
	{
		m_W = w;
	}
	//获取宽
	int getW()
	{
		return m_W;
	}
	//设置高
	void setH(int h)
	{
		m_H = h;
	}
	//获取高
	int getH()
	{
		return m_H;
	}
	//获取立方体面积
	int calculateS()
	{
		return 2 * m_L * m_W + 2 * m_W * m_H + 2 * m_H * m_L;
	}
	//获取立方体体积
	int calculateV()
	{
		return m_L * m_W * m_H;
	}
	//利用成员函数判断两个立方体是否相等
	bool isSameByClass(Cube &c)
	{
		if (c.getL() == getL() && c.getW() == m_W && c.getH() == getH())
		{
			return true;
		}
		return false;
	}
private:
	int m_L, m_W, m_H;//设置长宽高
};

//利用全局函数判断两个立方体是否相等
bool isSame(Cube& c1, Cube& c2)
{
	if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH())
	{
		return true;
	}
	return false;
}
int main6()
{
	//创建立方体对象
	Cube c1;
	c1.setL(10);
	c1.setW(10);
	c1.setH(10);

	cout << "c1的面积为： " << c1.calculateS() << endl;
	cout << "c1的体积为： " << c1.calculateV() << endl;

	//创建第二个立方体
	Cube c2;
	c2.setL(10);
	c2.setW(1);
	c2.setH(10);
	
	//全局函数判断
	bool ret = isSame(c1, c2);
	if (ret)
	{
		cout << "c1和c2相等" << endl;
	}
	else
	{
		cout << "c1和c2不相等" << endl;
	}

	//成员函数判断
	ret = c1.isSameByClass(c2);
	if (ret)
	{
		cout << "成员函数中c1和c2相等" << endl;
	}
	else
	{
		cout << "成员函数中c1和c2不相等" << endl;
	}
	system("pause");
	return 0;
}

4.1.4设计案例2-点和圆的位置关系

Circle圆类.h

#pragma once
#include <iostream>
using namespace std;
#include "Point点类.h"

//圆类
class Circle
{
public:
	//设置半径
	void setR(int r);
	
	//获取半径
	int getR();
	
	//设置圆心
	void setCenter(Point center);
	
	//获取圆心
	Point getCenter();
	
private:
	int m_R;//半径

	//在类中可以让另一个类作为本类中的成员
	Point m_Center;//圆心
};

Point点类.h

#pragma once//防止头文件重复包含
#include <iostream>
using namespace std;

//点类
class Point
{
public:
	//设置X坐标
	void setX(int x);

	//获取X坐标
	int getX();

	//设置Y坐标
	void setY(int y);

	//获取Y坐标
	int getY();

private:
	int m_X, m_Y;
};

Circle圆类.cpp

#include <iostream>
using namespace std;
#include "Circle圆类.h"
//圆类

//设置半径
void Circle::setR(int r)//Circle::告诉它这是Circle类的成员函数
{
	m_R = r;
}
//获取半径
int Circle::getR()
{
	return m_R;
}
//设置圆心
void Circle::setCenter(Point center)
{
	m_Center = center;
}
//获取圆心
Point Circle::getCenter()
{
	return m_Center;
}

Point点类.cpp

#include "Point点类.h"

### Point点类.cpp
//设置X坐标
void Point::setX(int x)//Point::告诉它这是Point类的成员函数
{
	m_X = x;
}
//获取X坐标
int Point::getX()
{
	return m_X;
}
//设置Y坐标
void Point::setY(int y)
{
	m_Y = y;
}
//获取Y坐标
int Point::getY()
{
	return m_Y;
}
//shift+tap键是整体缩进
//ctrl+k+c是全部注释化

点和圆的位置关系.cpp

#include <iostream>
using namespace std;
#include "Circle圆类.h"
#include "Point点类.h"
//点类
/*
class Point
{
public:
	//设置X坐标
	void setX(int x)
	{
		m_X = x;
	}
	//获取X坐标
	int getX()
	{
		return m_X;
	}
	//设置Y坐标
	void setY(int y)
	{
		m_Y = y;
	}
	//获取Y坐标
	int getY()
	{
		return m_Y;
	}
private:
	int m_X, m_Y;
};
*/
//圆类
/*
class Circle
{
public:
	//设置半径
	void setR(int r)
	{
		m_R = r;
	}
	//获取半径
	int getR()
	{
		return m_R;
	}
	//设置圆心
	void setCenter(Point center)
	{
		m_Center = center;
	}
	//获取圆心
	Point getCenter()
	{
		return m_Center;
	}
private:
	int m_R;//半径

	//在类中可以让另一个类作为本类中的成员
	Point m_Center;//圆心
};
*/
//判断点和圆的关系
void isInCircle(Circle& c, Point& p)
{
	//计算两点之间距离的平方
	int distance =
		((c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) + (p.getY() - c.getCenter().getY()) * (p.getY() - c.getCenter().getY()));
	//计算半径的平方
	int rDistance = c.getR() * c.getR();
	//判断关系
	if (distance == rDistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点在园外" << endl;
	}
	else
	{
		cout << "点在园内" << endl;
	}
}
int main7()
{
	//创建点
	Point p1; 
	p1.setX(9);
	p1.setY(0);
	//创建圆
	Circle c1;
	c1.setR(10);
	Point center;
	center.setX(0);
	center.setY(0);
	c1.setCenter(center);
	//判断点和圆的位置关系
	isInCircle(c1, p1);
	system("pause");
	return 0;
}

4.2对象的初始化和清理

/*
1、C++中的面向对象来源于生活，每个对象也都会有初始设置，以及对象销毁前的清理数据的设置
2、对象的初始化和清理也是两个非常重要的安全问题：
一个对象或者变量没有初始状态，对其使用后果是未知的
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
3、C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
4.对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供。
5.编译器提供的构造函数和析构函数是空实现
/
/
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}
1.构造函数没有返回值，也不写void。
2.函数名称与类名相同。
3.构造函数可以有参数，因此可以发生重载。
4.程序在调用对象时，会自动调用构造函数，无需手动调用，而且只会调用一次。

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

4.2.1构造函数和析构函数

#include <iostream>
using namespace std;
//对象的初始化和清理
//1、构造函数 进行初始化操作
class Person
{
public:
	//1.构造函数
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}

	//2.析构函数
	~Person()
	{
		cout << "~Person析构函数的调用" << endl;
	}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
	Person p;//在栈上的数据，test01执行完毕后，释放这个对象
}
int main8()
{
	test01();
	Person p;

	system("pause");
	return 0;
}

4.2.2构造函数的分类及调用

#include <iostream>
using namespace std;
/*
两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造

三种调用方式：
括号法、显式法、隐式转换法
*/
class Person1
{
public:
	//普通构造函数
	Person1()//无参构造函数或叫默认构造函数
	{
		cout << "Person的无参构造函数调用" << endl;
	}
	Person1(int a)//有参构造函数
	{
		age = a;
		cout << "Person的有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person1(const Person1& p)//const Person& p说白了就是保证你拷贝的类是完全一样的，不能改变量也不能改指针方向
	{
		//将传入的人身上的所有属性拷贝到我身上
		age = p.age;
		cout << "Person的拷贝构造函数调用" << endl;
	}
	
	~Person1()
	{
		cout << "~Person的析构函数调用" << endl;
	}
	int age;
};

void test02()
{
	//1.括号法
	Person1 p;//默认构造函数调用
	Person1 p2(10);//有参构造函数
	Person1 p3(p); Person1 p4(p2);//拷贝构造函数

	//注意事项1：调用默认构造函数时候，不要加()
	//不创建对象了，原因：下面的Person p5()的这行代码，编译器会认为是一个函数的声明
	Person1 p5();
	void func();//与Person p5()形成对照
	//拷贝构造函数的作用:
	cout << "p2的年龄为： " << p2.age << endl;
	cout << "p4的年龄为： " << p4.age << endl;
	cout << "以上为括号法" << endl << endl;

	//2.显式法
	Person1 p6;//无参构造
	Person1 p7 = Person1(10);//有参构造 给匿名对象Person1(10)起名叫p7
	Person1 p8 = Person1(p7);//拷贝构造
	cout << endl;
	Person1(11);//匿名对象  特点：当前执行结束后，系统会立即回收掉匿名对象
	cout << endl;

	//注意事项2：不要利用拷贝构造函数来初始化匿名对象
	//Person1(p8);//编译器会认为Person(p8)==Person p8  编译器自动就把前面Person1(p8)的括号给去掉了，编译器会认为这是个对象的声明
	cout << "以上为显式法" << endl << endl;

	//3.隐式转换法
	Person1 p9 = 10;//相当于写了 Person1 p9=Person1(10) ；有参构造
	Person1 p10 = p9;//拷贝构造
	cout << "以上为隐式转换法" << endl << endl;
}
int main9()
{
	test02();
	system("pause");
	return 0;
}

4.2.3拷贝构造函数调用时机

#include <iostream>
using namespace std;
//C++中拷贝构造函数调用时机通常有三种情况
//1、使用一个已经创建完毕的对象来初始化一个新对象
//2、值传递的方式给函数参数传值
//3、值方式返回局部对象
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 test03()
{
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为： " << p2.m_Age << endl;
}
//2、值传递的方式给函数参数传值
void doWork(Person p)
{

}
void test04()
{
	Person p;
	doWork(p);
}
//3、值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;
}
void test05()
{
	Person p = doWork2();
	cout << (int*) & p << endl;
}
int main10()
{
	cout << "1、使用一个已经创建完毕的对象来初始化一个新对象" << endl;
	test03();
	cout << endl;
	cout << "2、值传递的方式给函数参数传值" << endl;
	test04();
	cout << endl;
	cout << "3、值方式返回局部对象" << endl;
	test05();
	system("pause");
	return 0;
}

4.2.4构造函数调用规则

#include <iostream>
using namespace std;

//1、创建一个类，C++编译器会给每个类都添加至少3个函数
//默认构造(空实现)
//析构函数(空实现)
//拷贝构造(值拷贝)

//2、如果我们写了有参构造函数，编译器就不再提供默认构造，但依然提供默认拷贝构造函数
//3、如果我们写了拷贝构造函数，编译器就不再提供其他的构造函数（默认和有参构造函数)了

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;
};

void test06()
{
	Person p;
	p.m_Age = 18;

	Person p2(p);
	cout << "p2的年龄为： " << p2.m_Age << endl;
}

void test07()
{
	Person p1(22);
	Person p2(p1);
}
int main11111()
{
	cout << "1、的证明" << endl;
	/*test06();*/
	cout << "2、的证明" << endl;
	/*test07();*///报错，不提供默认构造函数了
	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;
	}
	//默认的拷贝构造函数复制信息时是逐行复制的，以至于m_Height指针所指向的内存地址它都复制的是一样的，使得p1和p2的m_Height是相同的地址，这导致了内存地址的重复释放，会报错
	//自己实现一个拷贝构造函数 解决浅拷贝带来的问题
	Person(const Person& p)
	{
		cout << "Person拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
		//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 test08()
{
	Person p1(18,180);
	cout << "p1的年龄为： " << p1.m_Age << " 身高为： " << *p1.m_Height << endl;
	Person p2(p1);
	cout << "p2的年龄为： " << p2.m_Age << " 身高为： " << *p2.m_Height << endl;
	//先进后出：p1先进，则它的析构函数后调用，p2在p1之后被创造，但是析构函数的调用比p1早
}
int main11()
{
	test08();
	system("pause");
	return 0;
}

4.2.6初始化列表

#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(int a,int b,int c) :m_A(a), m_B(b), m_C(c)
	{

	}
	int m_A, m_B, m_C;
};

void test09()
{
	//Person p(10, 20, 30);
	Person p(30,20,10);
	cout << "m_A= " << p.m_A << endl; cout << "m_B= " << p.m_B << endl; cout << "m_C= " << p.m_C << endl;
}
int main12()
{
	test09();
	

	system("pause");

	return 0;
}

4.2.7类对象作为成员

#include <iostream>
using namespace std;
#include <string>

//手机类
class Phone
{
public:
	Phone(string pName)
	{
		m_PName = pName;
		cout << "Phone的构造函数调用" << endl;
	}
	//手机品牌名称 
	string m_PName;
	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}
};
//人类
class Person
{
public:
	//Phone m_Phone = pName;隐式转化法
	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 test10()
{
	Person p("张三", "华为");
	cout << p.m_Name << "拿着： " << p.m_Phone.m_PName << "的手机" << endl;
}
int main13()
{
	test10();
	system("pause");
	return 0;
}

4.2.8静态成员变量

#include <iostream>
using namespace std;

//静态成员就是在成员变量和成员函数前加上关键字static，成为静态成员
/*
静态成员分为：
静态成员变量
  所有对象共享同一份数据
  在编译阶段分配内存
  类内声明，类外初始化
静态成员函数
  所有对象共享同一个函数
  静态成员函数只能访问静态成员变量
*/

//静态成员变量
class Person
{
public:
	//所有对象都共享同一份数据
	//编译阶段分配内存
    //类内声明，类外初始化操作
	static int m_A;
private:
	static int m_B;//静态成员变量有访问权限
};
//类外初始化
int Person::m_A = 100;
int Person::m_B = 99;
void test11()
{
	//所有对象都共享同一份数据
	Person p;
	cout << p.m_A << endl;//输出100
	Person p2;
	p2.m_A = 200;
	cout << p2.m_A << endl;//输出200
	cout << p.m_A << endl;//输出200
}
void test12()
{
	//静态成员变量不属于某个对象上，所有对象都共享同一份数据
	//因此静态成员变量有两种访问方式
	//1、通过对象进行访问
	Person p;
	cout << p.m_A << endl;
	//2、通过类名进行访问
	cout << Person::m_A << endl;

	//cout << Person::m_B << endl;//私有权限，即便是静态变量，在类外也不可访问
}
int main14()
{
	cout << "静态成员变量： " << endl;
	test11();
	test12();
	system("pause");
	return 0;
}

4.2.9静态成员函数

#include <iostream>
using namespace std;
//静态成员就是在成员变量和成员函数前加上关键字static，成为静态成员
/*
静态成员分为：
静态成员变量
  所有对象共享同一份数据
  在编译阶段分配内存
  类内声明，类外初始化
静态成员函数
  所有对象共享同一个函数
  静态成员函数只能访问静态成员变量
*/

class Person
{
public:
	//静态成员函数
	static void func()
	{
		m_A = 100;//静态成员函数可以访问静态成员变量
		//m_B = 1;//静态成员函数不可以访问非静态成员变量,无法区分到底是哪个对象的m_B属性
		cout << "stacit void func()调用" << endl;
	}
	static int m_A;//静态成员变量
	int m_B;

	//静态成员函数也有访问权限
private:
	static void func2()
	{

	}
};
void test13()
{
	//1、通过对象访问
	Person p;
	p.func();
	Person p2, p3, p4;
	p2.func(); p3.func(); p4.func();
	//2、通过类名访问
	Person::func();

	//Person::func2();//私有权限，类外访问不到私有的静态成员函数
}
int main15()
{
	test13();
	system("pause");
	return 0;
	 
}

４.类和对象(2)

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

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

//this指针概念
通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的

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

那么问题是：这一块代码是如何区分那个对象调用自己的呢？

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

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

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

this指针的用途：

当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this

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

#include <iostream>
using namespace std;

//只有非静态成员变量属于类的对象上
class Person
{
public:
	int m_A;//非静态成员变量 属于类的对象上

	static int m_B;//静态成员变量 不属于类的对象上

	void func() {};//非静态成员函数 不属于类的对象上

	static void func2() {};//静态成员函数 不属于类的对象上
};
void test01()
{
	Person p;
	//空对象占用内存为：1
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无二的内存地址
	cout << "size of p1 = " << sizeof(p) << endl;
}
void test02()
{
	Person p;
	//不是空对象，有int的话就按int占的字节来分配
	cout << "size of p2 = " << sizeof(p) << endl;
	cout << "size of p3 = " << sizeof(p.m_B) << endl;
}
int main1()
{
	test01();
	test02();
	system("pause");
	return 0;
}

4.3.2this指针概念

#include <iostream>
using namespace std;
/*
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可
*/
class Person
{
public:
	Person(int age)//当形参和成员变量同名时，可用this指针来区分
	{
		//this指针指向的是被调用的成员函数（这里是被p1调用）所属的对象
		this->age = age;
	}
	Person& PersonAddAge(Person& p)//如果是Person PersonAddAge的话，是值方式返回，而且返回的是编译器生产的拷贝构造函数的对象，而非p2对象本身
	{
		this->age += p.age;
		//this指向的是p2的指针，而*this指向的就是p2这个对象本体
		return *this;//在类的非静态成员函数中返回对象本身，可以使用return *this
	}
	int age;
};
//1、解决名称冲突
void test03()
{
	Person p(18);
	Person p1(11);
	cout << "p的年龄为： " <<  p.age << endl;
	cout << "p1的年龄为： " << p1.age << endl;
}
//2、返回对象本身 用*this
void test04()
{
	Person p1(10);
	Person p2(10);
	
	//链式编程
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为： " << p2.age << endl;
}
int main2()
{
	test03();
	test04();
	system("pause");
	return 0;
}

4.3.3空指针访问成员函数

#include <iostream>
using namespace std;
//C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
//如果用到this指针，需要加以判断保证代码的健壮性
class Person
{
public:
	void showClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		//报错原因是因为传入的指针是NULL

		if (this == NULL)//保护程序,预防传入空指针
		{
			return;
		}
		
		cout << "age = " << m_Age << endl;
	}

	int m_Age;
};
void test05()
{
	Person* p = NULL;
	p->showClassName();//访问成员函数没问题
	//p->showPersonAge();//属性前面都默认加了一个"this->",这里this指针指向的p的指针是一个空指针，this是空的，不确定的，还要访问一个确定的属性数据，是不行的
}
int main3()
{
	test05();
	system("pause");
	return 0;
}

4.3.4const修饰成员函数

#include <iostream>
using namespace std;

//常函数
class Person
{
public:
	//this指针的本质是指针常量，指针的指向是不可以修改的，在这里的this指针指向的是test07()里的对象p
	//此时意味着：const Person *const this; 第一个const等于void showPerso() const的const
	//在成员函数后面加const，修饰的是this指针指向的变量，让指针指向的变量也不可以修改
	void showPerson() const//后面加const，变为常函数
	{
		this->m_B = 100;
		//this->m_A = 100;//常函数内不可以修改成员属性
		//this = NULL;//this指针不可以修改指针的指向
	}
	void func()
	{

	}
	int m_A; 
	mutable int m_B;//特殊变量，即使在常含数中，也可以修改这个值，加关键字mutable
};
void test07()
{
	Person p;
	p.showPerson();
}
//常对象
void test08()
{
	const Person p;//在对象前加const,变为常对象
	//p.m_A = 100;//常对象不能修改普通的成员变量,即不能修改属性
	p.m_B = 100;//m_B是特殊值，在常对象条件下也可以修改

	//常对象只能调用常函数
	p.showPerson();
	//p.func();//func()作为普通成员函数能修改属性，但是常对象不能修改属性，因此不能调用普通成员函数
}
int main4()
{
	test07;
	test08;
	system("pause");
	return 0;
}

4.4友元

/*
在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

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

4.4.1全局函数做友元

#include <iostream>
using namespace std;
#include <string>
//房类
class Building
{
	//friend void goodGay(Building& building);的函数声明写在类里面就行
	friend void goodGay(Building& building);//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;
	cout << "好基友的全局函数 正在访问： " << building.m_BedRoom << endl;
}

int main5()
{
	//test01
	Building building;
	goodGay(building);
	system("pause");
	return 0;
}

4.4.2类做友元

#include <iostream>
using namespace std;
#include <string>

class Building;//类的声明

class GoodGay
{
public:
	GoodGay();
	void visit();//参观函数 访问Building中的属性
	Building* building;
};
class Building
{
	//GoodGay类是本类的好朋友，可以访问本类中私有成员
	friend class GoodGay;
public:
	Building();
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};
//类外写成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	//创建建筑物对象
	building = new Building;//在堆区创建
}
void GoodGay::visit()
{
	cout << "好基友类正在访问： " << building->m_SittingRoom << endl;
	cout << "好基友类正在访问： " << building->m_BedRoom << endl;
}
int main6()
{
	//test01
	GoodGay gg;
	gg.visit();
	system("pause");
	return 0;
}

4.4.3成员函数做友元

#include <iostream>
using namespace std;
#include <string>

class Building;
class GoodGay
{
public:
	GoodGay();
	void visit();//让visit函数可以访问Building中私有成员
	void visit2();//让visit2函数不可以访问Building中私有成员
	Building* building;
};
class Building
{
	//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友，可以访问私有成员
	friend void GoodGay::visit();
public:
	Building();
	string m_SittingRoom;
private:
	string m_BedRoom;
};
//类外实现成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	building = new Building;
}
void GoodGay::visit()
{
	cout << "visit函数正在访问： " << building->m_SittingRoom << endl;
	cout << "visit函数正在访问： " << building->m_BedRoom << endl;//可以访问私有权限
}
void GoodGay::visit2()
{
	cout << "visit2函数正在访问： " << building->m_SittingRoom << endl;
	//cout << "visit2函数正在访问： " << building->m_BedRoom << endl;//不可访问私有权限
}

int main7()
{
	GoodGay gg;
	gg.visit();
	gg.visit2();
	system("pause");
	return 0;
}

4.5运算符重载

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

4.5.1加号运算符重载

#include <iostream>
using namespace std;
/*
对于内置的数据类型的表达式的运算符是不可能改变的
不要滥用运算符重载
*/
//1、成员函数重载+号
class Person
{
public:
	//成员函数重载+号
  /*
  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;
  
};
/*
void test10()
{
	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;

	cout << "p3.m_A= " << p3.m_A << endl;
	cout << "p3.m_B= " << p3.m_B << endl;

}
*/
//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_B;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
void test11()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//全局函数本质调用：Person p3=operator+(p1,p2)
	Person p3 = p1 + p2;

	cout << "p3.m_A= " << p3.m_A << endl;
	cout << "p3.m_B= " << p3.m_B << endl;

}
//函数重载的版本
//运算符重载也可以发生函数重载
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 test12()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	int num = 10;
	//全局函数本质调用：Person p3=operator+(p1,num)
	Person p3 = p1 + num;

	cout << "p4.m_A= " << p3.m_A << endl;
	cout << "p4.m_B= " << p3.m_B << endl;

}
int main8()
{
	cout << "成员函数重载+号" << endl;
	//test10();
	cout << "全局函数重载+号" << endl;
	test11();
	cout << "运算符重载也可发生函数重载" << endl;
	test12();
	system("pause");
	return 0;
}

4.5.2左移运算符重载

#include <iostream>
using namespace std;

class Person
{
	friend ostream& operator<<(ostream& out, Person& p);//重载左移运算符配合友元可以实现输出自定义数据类型
public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:
	//利用成员函数重载左移运算符 p.operator<<(cout)简化为：p<<cout
	//通常不会利用成员函数来重载左移运算符，因为无法实现cout在左侧
	/*void operator<<(Person& p)
	{

	}*/
	int m_A;
	int m_B;
};
//只能利用全局函数来重载左移运算符
//ostream为一个叫做标准输出流的类，cout就是其类内的一个标准输出流对象，而且该对象全局只能有一个，因此要用引用&的方式传递进来，不能创建一个新的出来
ostream& operator<<(ostream& out, Person& p)//本质 operator<<(out,p)简化为：out<<p
{
	out << "m_A =" << p.m_A << " m_B =" << p.m_B ;
	return out;
}
void test13()
{
	Person p(10,10);

	//cout就是其类内的一个标准输出流对象，而且该对象全局只能有一个，因此要用引用&的方式传递进来，不能创建一个新的出来
	operator<<(cout, p) << " Hello World" << endl;
	cout << p << " Hello World " << endl;//operator<<(cout, p)等同于cout << p
}
int main9()
{
	test13();
	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的就是前置递增，有int的就是后置递增,编译器就是这么规定和识别的
	MyInteger operator++(int)//int代表的是一个占位参数，可以用于区分前置和后置递增。
	{
		//先 记录当时结果`
		MyInteger temp = *this;
		//后 递增
		m_Num++;
		//最后将记录的结果做返回
		return temp;
	}
private:
	int m_Num;
};

//重载左移运算符 目的是为了让cout能输出类
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}

//前置递增
void test14()
{
	MyInteger myint;
	cout << ++(++(++myint)) << endl;
	cout << myint << endl;
}
//后置递增
void test15()
{
	MyInteger myint;
	cout << (myint++)++ << endl;
	cout << myint << endl;//本来类是不能cout输出的，但是通过左移运算符的重载，我们就可以让cout来输出类了，即实现输出自定义数据类型
}

int main10()
{
	cout << "重载前置递增运算符： " << endl;
	test14();
	cout << "重载后置递增运算符： " << endl;
	test15();
	system("pause");
	return 0;
}

4.5.4赋值运算符重载

#include <iostream>
using namespace std;
/*
C++编译器至少给一个类提供四个函数
1.默认构造函数（无参，函数体为空）
2.默认析构函数（无参，函数体为空）
3.默认拷贝构造函数，对属性进行值拷贝
4.赋值运算符operator=，对属性进行值拷贝
*/

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)//解决堆区内存重复释放
	{
		//编译器是提供浅拷贝:m_Age = p.m_Age;
		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		//连等时返回本身
		return *this;
	}

	int* m_Age;
};

void test16()
{
	Person p1(18), p2(20);
	p2 = p1;//赋值操作
	//p2.operator=(p1);
	cout << "p1的年龄为： " << *p1.m_Age << endl;
	cout << "p2的年龄为： " << *p2.m_Age << endl;

	Person p3(11),p4(14),p5(32);
	p3 = p5 = p4;
	//p3.operator=(p5.operator=(p4));
	cout << "p3的年龄为： " << *p3.m_Age << endl;

}
int main11()
{
	test16();

	system("pause");
	return 0;
}

4.5.5关系运算符重载

#include <iostream>
using namespace std;
#include <string>
//作用：重载关系运算符，可以让两个自定义类型对象进行对比操作
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;
	}
	//重载不等号
	bool operator!=(Person& p)
	{
		if (this->m_Name != p.m_Name && this->m_Age != p.m_Age)
		{
			return false;
		}
		return true;
	}
	string m_Name;
	int m_Age;
};
void test17()
{
	Person p1("Tom", 18), p2("Jarry", 18);
	if (p1 == p2)
	{
		cout << "p1和p2是相等的" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的" << endl;
	}

	if (p1 != p2)
	{
		cout << "p1和p2是不相等的" << endl;
	}
	else
	{
		cout << "p1和p2是相等的" << endl;
	}

}
int main12()
{
	test17();
	system("pause");
	return 0;
}

4.5.6函数调用运算符重载

#include <iostream>
using namespace std;
#include <string>
/*
函数调用运算符()也可以重载
由于重载后使用的方式非常像函数的调用，因此成为仿函数
仿函数没有固定写法，非常灵活
*/
//打印输出类
class MyPrint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};
void MyPrint02(string test)
{
	cout << test << endl;
}
void test18()
{
	MyPrint myprint;
	myprint("hello world");
	MyPrint02("hello world");//由于重载后使用的方式非常像函数的调用，因此成为仿函数
}
//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};
void test19()
{
	MyAdd myadd;
	int ret = myadd(100, 100);
	cout << "ret = " << ret << endl;

	//匿名函数对象 意思：首先它是匿名对象，然后它又重载了()，即仿函数，因此称为匿名函数对象
	cout << MyAdd()(100, 100) << endl;
}

int main13()//13
{
	test18();
	test19();
	system("pause");
	return 0;
}

4.6继承

//继承的好处：较少重复代码
// 语法： class 子类: 继承方式父类
// 子类也称为派生类，父类也称为基类

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

4.6.1继承的基本语法

#include <iostream>
using namespace std;

//普通实现页面
/*
//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;
	}
};//全部注释是ctrl+k+c，解开注释是ctrl+k+u
*/

//继承实现页面
//公共页面类
class BasePage
{
public:
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;
	}

};
//C++页面
class Cpp :public BasePage
{
public:
	void content()
	{
		cout << "Cpp学科视频" << endl;
	}

};
int main14()
{
	cout << "test01: " << endl << endl;
	cout << "Java下载视频页面如下： " << endl << endl;;
	Java ja; ja.header(); ja.footer(); ja.left(); ja.content();
	cout << "Python下载视频页面如下： " << endl << endl;
	Cpp cpp; cpp.header(); cpp.footer(); cpp.left(); cpp.content();
	cout << "Java下载视频页面如下： " << endl << endl;
	Python p; p.header(); p.footer(); p.left(); p.content();
	system("pause");
	return 0;
}

4.6.2继承方式

#include <iostream>
using namespace std;

//继承方式共有三种：
//公共继承、保护继承、私有继承

//公共继承
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 = 10; //父类中的保护权限成员 到子类中依然是保护权限成员
		//m_C = 10; //父类中的私有权限成员 子类访问不到
	}
};
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 100;//父类中的公共权限成员 到子类中变为保护权限成员
		m_B = 100;//父类中的保护权限成员 到子类中变为保护权限成员
		//m_C = 100;//父类中私有成员 子类访问不到
	}
};
//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 100;//父类中的公共权限成员 到子类中变为私有权限成员
		m_B = 100;//父类中的保护权限成员 到子类中变为私有权限成员
		//m_C = 100;//父类中私有成员 子类访问不到
	}
};
class Grand3 :public Son3
{
public:
	void func()
	{
		//m_A = 100;//子类中的私有权限成员 到孙类中访问不到
		//m_B = 100;//子类中的私有权限成员 到孙类中访问不到
		//m_C = 100;//子类中私有成员 孙类访问不到
	}
};
int main15()
{
	cout << "test01: " << endl;
	Son1 s1; 
	s1.m_A = 100; cout << endl;
	//s1.m_B = 100;//到Son1中 m_B是保护权限，类外访问不到
	cout << "test02: " << endl;
	Son2 s2;
	//s2.m_A = 100;//在Son2中 m_A变为保护权限，因此类外访问不到
	//s2.m_B = 100;//在Son2中 m_B为保护权限，类外访问不到
	cout << "test03: " << endl;
	Son2 s3;
	//s3.m_A = 100;//在Son2中 m_A变为私有权限，因此类外访问不到
	//s3.m_B = 100;//在Son2中 m_B为私有权限，类外访问不到
	system("pause");
	return 0;
}

4.6.3继承中的对象模型

#include <iostream>
using namespace std;

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son :public Base
{
public:
	int m_D;
};
//利用开发人员命令提示工具查看对象模型
//跳转盘符 D:
//跳转文件路径 cd 具体路径下
//查看命名
// cl /dl reportSingleClassLayout类名 "文件名"（打几个字然后按Tab键补齐）
int main16()
{
	cout << "test01: " << endl;
	//父类中私有成员属性是被编译器隐藏了，因此访问不到，但是确实被继承下去了
	cout << "size of Son = " << sizeof(Son) << endl;//4*4=16，父类中所有的非静态成员都被子类继承了下来，并且加上子类自己特有的成员
	system("pause");
	return 0;
}

4.6.3继承中的对象模型(1).jpg

4.6.3继承中的对象模型(1)

4.6.3继承中的对象模型(2).jpg

在这里插入图片描述

4.6.4继承中的构造和析构顺序

#include <iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "Base构造函数" << endl;
	}
	~Base()
	{
		cout << "Base析构函数" << endl;
	}
};

class Son :public Base
{
public:
	Son()
	{
		cout << "Son构造函数" << endl;
	}
	~Son()
	{
		cout << "Son析构函数" << endl;
	}
};
int main17()
{
	cout << "test01： " << endl;
	Base b;
	Son s;
	//继承中的构造和析构顺序如下：
	//先构造父类，再构造子类，析构的顺序与构造的顺序相反
	system("pause");
	return 0;
}

4.6.5继承同名成员处理方式

#include <iostream>
using namespace std;

//当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据？
//访问子类同名成员 直接访问即可
//访问父类同名成员 需要加作用域
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;
};
int main18()
{
	cout << "test01成员属性调用： " << endl;
	Son s;
	cout << "Son下 m_A = " << s.m_A << endl;//通过子类对象访问子类同名成员 直接访问即可
	cout << "Base下 m_A = " << s.Base::m_A << endl;//通过子类对象访问父类同名成员 需要加作用域
	cout << endl;

	cout << "test02成员函数调用： " << endl;
	Son s2;
	cout << "Son下 func()调用: " ;
	s2.func(); cout << endl;//通过子类对象访问子类同名成员 直接访问即可
	cout << "Base下 func()调用: " ;
	s2.Base::func();cout << endl;//通过子类对象访问父类同名成员 需要加作用域
	cout << endl;

	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名的成员函数
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	s.Base::func(100);
	system("pause");
	return 0;
}

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

#include <iostream>
using namespace std;

//问题：继承中同名的静态成员在子类对象上如何进行访问
//静态成员和非静态成员出现同名，处理方式一致
//访问子类同名成员 直接访问即可
//访问父类同名成员 需要加作用域

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;

int main19()
{
	//1、通过对象访问
	cout << "test01 通过对象访问同名静态成员属性： " << endl;
	Son s;
	cout << "Son下 m_A = " << s.m_A << endl;
	cout << "Base下 m_A = " << s.Base::m_A << endl;
	//2、通过类名访问
	cout << "test01 通过类名访问同名静态成员属性： " << endl;
	cout << "Son下 m_A = " << Son::m_A << endl;
	//第一个::代表通过类名方式访问，第二个::代表访问父类作用域下
	cout << "通过Son类 来访问Base类下 m_A = " << Son::Base::m_A << endl;//Base::m_A是直接通过父类访问父类的m_A
	cout << endl;

	//1、通过对象访问
	cout << "test02 通过对象访问同名静态成员函数： " << endl;
	Son s2;
	cout << "Son下 static func(): "; s2.func();cout << endl;
	cout << "Base下 static func(): "; s2.Base::func();cout << endl;
	//2、通过类名访问
	cout << "test02 通过类名访问同名静态成员函数：  " << endl;
	cout << "Son下 static func():  "; Son::func();cout << endl;
	//第一个::代表通过类名方式访问，第二个::代表访问父类作用域下
	cout << "Base下 static func(): "; Son::Base::func();cout << endl;//Base::m_A是直接通过父类访问父类的m_A

	//如果子类中出现和父类同名的静态成员函数，子类的同名成员会隐藏掉父类中所有同名的静态成员函数
	//如果想访问到父类中被隐藏的同名静态成员函数，需要加作用域
	s2.Base::func(100);
	Son::Base::func(200);
	system("pause");
	return 0;
}

4.6.7多继承语法

#include <iostream>
using namespace std;
/*
C++允许一个类继承多个类
语法： class 子类: 继承方式 父类1 , 继承方式 父类2...
多继承可能会引发父类中有同名成员出现，需要加作用域区分

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

class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};
class Base2
{
public:
	Base2()
	{
		m_A = 300;
	
	}
	int m_A;
};
//子类 需要继承Base1和Base2
//语法： class 子类 : 继承方式 父类1, 继承方式 父类2...
class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 500;
		m_D = 900;
	}
	int m_C, m_D;
};
int main20()
{
	cout << "test01: " << endl;
	Son s;
	cout << "size of Son = " << sizeof(Son) << endl;//(1+1+2)*4=16
	//当父类中出现同名成员，需要加作用域区分
	cout << "Base1下 m_A = " << s.Base1::m_A << endl;
	cout << "Base2下 m_A = " << s.Base2::m_A << endl; 
	system("pause");
	return 0;
}

4.6.8菱形(钻石)继承

#include <iostream>
using namespace std;

/*
概念：
两个派生类继承同一个基类，又有某个类同时继承两个派生类
这种继承被称为菱形继承，或者钻石继承
*/
/*
菱形继承的问题：（子类继承两份相同的数据，导致资源浪费以及毫无意义）
羊继承了动物的数据，驼继承了动物的数据，当草泥马使用数据时，就会产生二义性
草泥马继承动物的数据继承了两份，其实我们应该清除，这份数据我们只需要一份就可以
*/
//动物类
class Animal
{
public:
	int m_Age;
};
/*
利用虚继承 解决菱形继承的问题
继承之前 加上关键字virtual 变为虚继承
Animal类成为虚基类
*/
//羊类
class Sheep:  virtual public Animal
{

};
//驼类
class Tuo :  virtual public Animal
{

};
//羊驼类
class SheepTuo :public Sheep, public Tuo
{

};
int main21()
{
	cout << "test01: " << endl;
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;

	cout << "st.m_Age = " << st.m_Age << endl;//加了virtual后，st都不需要加作用域来区分了
	//这份数据我们知道 只有一份就可以，菱形继承导致数据有两份，资源浪费

	system("pause");
	return 0;
}

4.6.8菱形(钻石)继承.jpg

在这里插入图片描述

４.类和对象(3)

4.7多态

/*
多态分为两类
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区分：
静态多态的函数地址早绑定-编译阶段确定函数地址
动态多态的函数地址晚绑定-运行阶段确定函数地址

动态多态满足条件：1、有继承关系2、子类要重写父类中的虚函数
动态多态使用：父类的指针或者引用指向或执行子类对象
*/

4.7.1(1)多态的基本概念

#include <iostream>
using namespace std;

//动物类
class Animal
{
public:
	virtual void speak()//加virtual后，该函数变为虚函数
	{
		cout << "动物在说话" << endl;
	}
};
//猫类
class Cat :public Animal
{
public:
	void speak()//加virtual后，该函数变为虚函数
	{
		cout << "小猫在说话" << endl;
	}
};
//狗类
class Dog :public Animal
{
public:
	//重写： 函数返回值类型 函数名 参数列表 完全相同才叫重写
	virtual void speak()//这里的virtual可写可不写
	{
		cout << "小狗在说话" << endl;
	}
};
//执行说话的函数
//动态多态使用：父类的指针或者引用 指向或执行子类对象
void doSpeak(Animal& animal)//Animal& animal = cat 父类的引用可以直接指向子类对象，这是很隐蔽的一个步骤，这个步骤也使我们实现了动态多态，实现了地址晚绑定
{
	animal.speak();
}

int main1()
{
	
	cout << "test01: " << endl;
	Cat cat;
	//地址早绑定-编译阶段确定函数地址
	//doSpeak(cat);//未写virtual前， 想让猫说话，但这里却是动物在说话

	//地址晚绑定-运行阶段确定函数地址
	//如果想执行狗说话，那么这个函数地址就不能提前绑定，在狗说话函数前面加上virtual

	//动态多态满足条件：1、有继承关系2、子类要重写父类中的虚函数
	
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
	

	system("pause");
	return 0;
}

4.7.1(2)多态的原理剖析

#include <iostream>
using namespace std;

//动物类
class Animal
{
public:
	virtual void speak()//加virtual后，该函数变为虚函数
	{
		cout << "动物在说话" << endl;
	}
};
//猫类
class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
//狗类
class Dog :public Animal
{
public:
	//重写： 函数返回值类型 函数名 参数列表 完全相同才叫重写
	virtual void speak()//这里的virtual可写可不写
	{
		cout << "小狗在说话" << endl;
	}
};
//执行说话的函数
//动态多态使用：父类的指针或者引用 指向或执行子类对象
void doSpeak(Animal& animal)//Animal& animal = cat 父类的引用可以直接指向子类对象，这是很隐蔽的一个步骤，这个步骤也使我们实现了动态多态，实现了地址晚绑定
{
	animal.speak();
}


int main2()
{
	
	cout << "test01: " << endl;
	Cat cat;
	//地址早绑定-编译阶段确定函数地址
	//doSpeak(cat);//未写virtual前， 想让猫说话，但这里却是动物在说话

	//地址晚绑定-运行阶段确定函数地址
	//如果想执行狗说话，那么这个函数地址就不能提前绑定，在狗说话函数前面加上virtual
	
	//动态多态满足条件：1、有继承关系2、子类要重写父类中的虚函数
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
	
	cout << "test02: " << endl;
	//cout << "加virtual前：sizeof(Animal) = " << sizeof(Animal) << endl;
	cout << "加virtual后：sizeof(Animal) = " << sizeof(Animal) << endl;//所占的4个内存是指针的内存

	system("pause");
	return 0;
}

4.7.1(2)01多态的原理刨析.jpg

在这里插入图片描述

4.7.1(2)02多态的原理刨析.jpg

在这里插入图片描述

4.7.1(2)03多态的原理刨析.jpg

在这里插入图片描述

4.7.2多态案例-计算器类

#include <iostream>
using namespace std;
#include <string>
//分别利用普通写法和多态技术实现计算器

//普通写法
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
};

//利用多态实现计算器
//多态好处：1、组织结构清晰 2、可读性强 3、对于前后期的扩展以及维护性高

//实现计算器抽象类
class AbstractCalculator
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
//加法计算器类
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 MultifyCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};
int main3()
{
	cout << "test01: " << endl;
	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;

	cout << "test02: " << endl;
	//多态使用条件：父类指针或者引用指向子类对象
	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;

	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;

	//乘法运算
	abc = new MultifyCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;

	system("pause");
	return 0;
}

4.7.3纯虚函数和抽象类

#include <iostream>
using namespace std;
//在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
//因此可以将虚函数改为纯虚函数
//语法： virtual 返回值类型 函数名 (参数列表) = 0;

//当类中有了纯虚函数，这个类也成为 抽象类
//抽象类特点：1、无法实例化对象 2、子类必须重写抽象类中的纯虚函数，否则也属于抽象类

//纯虚函数和抽象类：
class Base
{
public:
	virtual void func() = 0;
};
class Son :public Base
{
	void func()
	{
		cout << "func函数的调用" << endl;
	}
};
int main4()
{
	cout << "test01: " << endl;
	//1、纯虚函数无法实例化对象
	//Base b;
	//new Base;
	
	//2、抽象类的子类必须重写父类中的纯虚函数，否则也属于抽象类
	//Son s;
	//new Son;
	Son s;//仅仅加了个大括号{}就可以说是改写父类的纯虚函数了

	Base* base = new Son;
	base->func();

	system("pause");
	return 0;
}

4.7.4多态案例-制作饮品

#include <iostream>
using namespace std;
/*
制作饮品的大致流程为：煮水、冲泡、倒入杯中、加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
*/

class AbstractDrinking//抽象类
{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//加入辅料
	virtual void PutSomething() = 0;

	//制作饮品
	void makeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
};
//泡咖啡
class Coffee :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}
	//制作饮品

};

//泡茶叶
class Tea :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入枸杞" << endl;
	}
	//制作饮品

};
void doWork(AbstractDrinking * abs)
{
	abs->makeDrink();
	delete abs;//防止堆区数据有内存泄漏，进行手动释放
}
int main5()
{
	cout << "test01: " << endl;
	//泡咖啡
	doWork(new Coffee);
	cout << "---------------------------------------" << endl;
	//泡茶叶
	doWork(new Tea);
	system("pause");
	return 0;
}

4.7.5虚析构和纯虚析构

#include <iostream>
using namespace std;
#include <string>
/*
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：
可以解决父类指针释放子类对象
都需要有具体的函数实现

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

虚析构语法：virtual ~类名(){}
纯虚析构语法： virtual ~类名() = 0;
               类名::类名(){}

*/
class Animal
{
public:
	Animal()
	{
		cout << "Animal构造函数调用" << endl;
	}
	//纯虚函数
	virtual void speak() = 0;

	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	/*virtual ~Animal()
	{
		cout << "Animal析构函数调用" << endl;
	}*/

	//纯虚析构 需要声明也需要实现
	//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 0;
};
Animal::~Animal()
{
	cout << "Animal纯虚析构函数调用" << endl;
}

class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	void speak()
	{
		cout << *m_Name << "小猫在说话" << endl;
	}

	~Cat()
	{
		if (m_Name != NULL)
		{
			cout << "Cat析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string *m_Name;//创建指针，让小猫的名称具体地创建在堆区
	//如果子类中没有堆区数据，父类可以不写为虚析构或纯虚析构
};
int main6()
{
	cout << "test01: " << endl;
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候，不会调用子类中析构函数，导致子类如果有堆区属性，就会出现内存泄漏
	delete animal;
	system("pause");
	return 0;
}

4.7.6多态案例-电脑组装

#include <iostream>
using namespace std;
/*
电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
*/

//抽象不同零件类
//抽象CPU类
class CPU
{
public:
	//抽象计算函数
	virtual void calculate() = 0;
};
//抽象显卡类
class GPU
{
public:
	//抽象显示函数
	virtual void display() = 0;
};
//抽象内存条类类
class Storage
{
public:
	//抽象存储函数
	virtual void memory() = 0;
};

//电脑类
class Computer
{
public:
	Computer(CPU* cpu, GPU* gpu, Storage* storage)
	{
		m_cpu = cpu;
		m_gpu = gpu;
		m_storage = storage;
	}
	//提供工作的函数
	void work()
	{
		//让零件工作起来，调用接口
		m_cpu->calculate();
		m_gpu->display();
		m_storage->memory();
	}
	//提供析构函数释放3个电脑零件
	~Computer()
	{
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}

		if (m_gpu != NULL)
		{
			delete m_gpu;
			m_gpu = NULL;
		}

		if (m_storage != NULL)
		{
			delete m_storage;
			m_storage = NULL;
		}
	}
private:
	CPU* m_cpu;//CPU的零件指针
	GPU* m_gpu;//GPU的零件指针
	Storage* m_storage;//内存条零件指针
};

//具体厂商
//Intel厂商
class IntelCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Inter的CPU开始计算" << endl;
	}
};
class IntelGPU :public GPU
{
public:
	virtual void display()
	{
		cout << "Inter的显卡开始显示" << endl;
	}
};
class IntelStorage :public Storage
{
public:
	virtual void memory()
	{
		cout << "Inter的内存条开始存储" << endl;
	}
};
//Lenovo厂商
class LenovoCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Lenovo的CPU开始计算" << endl;
	}
};
class LenovoGPU :public GPU
{
public:
	virtual void display()
	{
		cout << "Lenovo的显卡开始显示" << endl;
	}
};
class LenovoStorage :public Storage
{
public:
	virtual void memory()
	{
		cout << "Lenovo的内存条开始存储" << endl;
	}
};

int main7()
{
	cout << "test01: " << endl;
	//第一台电脑零件
	CPU* intelCPU = new IntelCPU;
	GPU* intelGPU = new IntelGPU;
	Storage* intelStorage = new IntelStorage;
	//创建第一台电脑
	Computer* computer1 = new Computer(intelCPU, intelGPU, intelStorage);
	computer1->work();
	delete computer1;
	cout << "-------------------------------------------------" << endl;
	//创建第二台电脑
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoGPU, new LenovoStorage);
	computer2->work();
	delete computer2;
	system("pause");
	return 0;
}

５.文件操作

5.1文本文件

/*
程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放
通过文件，可以将数据持久化
C++中对文件操作需要包含头文件（文件流）

文件类型分为两种：
1、文本文件 - 文件以文本的ASCII码形式存储在计算机中
2、二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

操作文件的三大类：
1.ofstream - 写操作
2.ifstream - 读操作
3.fstream - 读写操作
*/

5.1.0文件打开方式.jpg

在这里插入图片描述

5.1.1写文件

#include <iostream>
using namespace std;
/*
步骤：
1、包含头文件 #include<fstream>
2、创建流对象 ofstream ofs;
3、打开文件 ofs.open("文件路径(可以写：相对路径，绝对路径或文件名)",打开方式);
4、写数据 ofs<<"写入的数据";
5、关闭文件 ofs.close();
*/
/*
注意：文件打开方式可以同时一起来使用，利用“|”操作符
例如：用二进制方式写文件 ios::binary | ios::out
*/
#include <fstream>
//文本文件 写文件
void test01()
{
	//创建流对象
	ofstream ofs;
	//指定打开方式
	ofs.open("5.1.1写文件-test.txt", ios::out);
	//写内容
	ofs << "姓名：张三" << endl;
	ofs << "性别：男" << endl;
	ofs << "年龄：18" << endl;
	//关闭文件
	ofs.close();
}
int main1()
{
	test01();
	system("pause");
	return 0;
	/*
    文件操作必须包含头文件fstream
    读文件可以利用ofstream，或者fstream
    打开文件时需要指定操作文件的路径，以及打开方式
    利用<<可以向文件中写数据
    操作完毕，要关闭文件
    */
}

5.1.1写文件-test.txt

在这里插入图片描述

5.1.2读文件

#include <iostream>
using namespace std;
/*
读文件与写文件步骤相似，但是读取方式相对比较多
步骤：
1、包含头文件 <fstream>
2、创建流对象 ifsteam ifs;
3、打开文件并判断文件是否打开成功 ifs.open("文件路径",打开方式);
4、读数据 四种方式读取
5、关闭文件 ifs.close();
*/
#include <fstream>
#include <string>
void test02()
{
	ifstream ifs;
	ifs.open("5.1.1写文件-test.txt", ios::in);
	//判断是否带成功
	if (!ifs.is_open())//利用is_open函数可以判断文件是否打开成功
	{
		cout << "文件打开失败" << endl;
		return;
	}
	else
	{
		cout << "文件打开成功" << endl;
	}
	//4、读数据
	//第一种
	char buf[1024] = { 0 };
	while (ifs >> buf)
	{
		cout << buf << endl;
	}
	//第二种
	char buf1[1024] = { 0 };
	while (ifs.getline(buf1, sizeof(buf1)))
	{
		cout << buf1 << endl;
	}
	//第三种
	string buf2;
	while (getline(ifs, buf2))
	{
		cout << buf2 << endl;
	}
	//第四种 不太推荐用
	char c;
	while ((c = ifs.get()) != EOF)//EOF - end of file
	{
		cout << c;
	}

	ifs.close();

}
int main2()
{
	test02();
	system("pause");
	return 0;
}

5.2二进制文件

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

5.2.1写文件

#include <iostream>
using namespace std;
/*
二进制方式写文件主要利用流对象调用成员函数write
函数原型：ostream& write(const char * buffer, int len);
参数解释：字符指针buffer指向内存中一段存储空间，len时读写的字节数
*/
#include <string>
#include <fstream>
class Person
{
public:
	char m_Name[64];//在写字符串的时候最好用c语言的char字符，用C++的string字符写的话会出一些问题
	int m_Age;
};
int main3()
{
	cout << "test01: " << endl;

	ofstream ofs("5.2.1写文件.txt", ios::out | ios::binary);
	//两步合成了一步： ofstream ofs; ofs.open("5.2.1写文件.txt", ios::out | ios::binary );

	Person p = { "张三",18 };
	//写文件
	ofs.write((const char*)&p, sizeof(Person));

	ofs.close();
	system("pause");
	return 0;
}

5.2.1写文件.txt

在这里插入图片描述

5.2.2读文件

#include <iostream>
using namespace std;
/*
二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(char * buffer, int len);
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数
*/
#include <fstream>
class Person
{
public:
	char m_Name[64];//在写字符串的时候最好用c语言的char字符，用C++的string字符写的话会出一些问题
	int m_Age;
};

void test04()
{
	cout << "test01: " << endl;

	ifstream ifs("5.2.1写文件.txt", ios::in | ios::binary);

	//判断文件是否打开成功
	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
		return;
	}
	else
	{
		cout << "文件打开成功" << endl;
	}
	//读文件
	Person p;
	ifs.read((char*)&p, sizeof(Person));
	cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;

	ifs.close();
}
int main4()
{
	test04();

	system("pause");
	return 0;
}

６.职工管理系统

boss.h

#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();
};

employee.h

//普通员工文件
#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 string getDeptName();
};

manager.h

#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 string getDeptName();
};

worker.h

#pragma once
#include <iostream>
using namespace std;
#include <string>

//职工抽象类
class Worker
{
public:
	//显示个人信息
	virtual void showInfo()= 0;
	//获取岗位名称
	virtual string getDeptName() = 0;
	//职工编号
	int m_Id;
	//职工姓名
	string m_Name;
	//部门编号
	int m_DeptId;
};

workerManager.h

#pragma once//防止头文件重复包含
#include <iostream>//包含输入输出流头文件
using namespace std;//使用标准命名空间
#include "worker.h"
#include "employee.h"
#include "boss.h"
#include "manager.h"

#include <fstream>
#define FILENAME "empfile.txt"

class WorkerManager
{
public:

	//构造函数
	WorkerManager();

	//展示菜单函数
	void Show_Menu();

	//退出系统
	void ExitSystem();

	//记录职工人数
	int m_EmpNum;

	//职工数组指针
	Worker** m_EmpArray;

	//添加职工
	void Add_Emp();

	//保存文件
	void save();

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

	//统计文件中人数
	int get_EmpNum();

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

	//显示职工
	void show_Emp();

	//删除职工
	void del_Emp();

	//判断职工是否存在 如果存在返回职工所在数组中的位置，不存在返回-1
	int IsExist(int id);

	//修改职工
	void Mod_Emp();

	//查找职工
	void Find_Emp();

	//按照职工编号排序
	void Sort_Emp();

	//清空文件
	void Clean_Emp();

	//析构函数
	~WorkerManager();  
};

boss.cpp

#include "boss.h"

//构造函数
Boss::Boss(int id, string name, int dId)
{
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptId = dId;
}
//显示个人信息
void Boss::showInfo()
{
	cout << "职工编号： " << this->m_Id
		<< "\t职工姓名： " << this->m_Name
		<< "\t岗位： " << this->getDeptName()
		<< "\t岗位职责： 管理公司所有事务" << endl;
}

//获取岗位名称
string Boss::getDeptName()
{
	return string("老板");
}

employee.cpp

#include "employee.h"
using namespace std;


//构造函数
Employee::Employee(int id,string name,int dId)
{
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptId = dId;
}
//显示个人信息
void Employee::showInfo()
{
	cout << "职工编号： " << this->m_Id
		<< "\t职工姓名： " << this->m_Name
		<< "\t岗位： " << this->getDeptName()
		<< "\t岗位职责： 完成经理交给的任务" << endl;
}
//获取岗位名称
string Employee::getDeptName()
{
	return string("员工");
}

manager.cpp

#include "manager.h"

//构造函数
Manager::Manager(int id, string name, int dId)
{
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptId = dId;
}
//显示个人信息
void Manager::showInfo()
{
	cout << "职工编号： " << this->m_Id
		<< "\t职工姓名： " << this->m_Name
		<< "\t岗位： " << this->getDeptName()
		<< "\t岗位职责： 完成老板交给的任务,并分配给员工任务" << endl;
}

//获取岗位名称
string Manager::getDeptName()
{
	return string("经理");
}

workerManager.cpp

#include "workerManager.h"

WorkerManager::WorkerManager()
{
	//初始化属性
	this->m_EmpNum = 0;
	this->m_EmpArray = NULL;

	//文件不存在
	ifstream ifs;
	ifs.open(FILENAME, ios::in);//读文件
	if (!ifs.is_open())
	{
		cout << "文件不存在" << endl;
		//初始化属性
		//初始化记录人数
		this->m_EmpNum = 0;
		//初始化数组指针
		this->m_EmpArray = NULL;
		//初始化文件是否为空
		this->m_FileIsEmpty = true;
		ifs.close();
		return;
	}

	//文件存在 数据为空
	char ch;
	ifs >> ch;
	if (ifs.eof())
	{
		//文件为空
		cout << "文件为空" << endl;
		//初始化属性
		//初始化记录人数
		this->m_EmpNum = 0;
		//初始化数组指针
		this->m_EmpArray = NULL;
		//初始化文件是否为空
		this->m_FileIsEmpty = true;
		ifs.close();
		return;
	}

	//文件存在，并且记录数据
	int num = this->get_EmpNum();
	cout << "职工人数为： " << num << endl;
	this->m_EmpNum = num;
	//开辟空间
	this->m_EmpArray = new Worker * [this->m_EmpNum];
	//将文件中的数据存到数组中
	this->init_Emp();
	测试代码
	//for (int i = 0; i < this->m_EmpNum; i++)
	//{
	//	cout << "职工编号" << this->m_EmpArray[i]->m_Id << " "
	//		<< "姓名" << this->m_EmpArray[i]->m_Name << " "
	//		<< "部门编号" << this->m_EmpArray[i]->m_DeptId << " " << endl;
	//}
	
}

//展示菜单
void WorkerManager::Show_Menu()
{
	cout << "**********************************************************" << endl;
	cout << "****************** 欢迎使用职工管理系统 ******************" << endl;
	cout << "******************    0.退出管理程序    ******************" << endl;
	cout << "******************    1.增加职工信息    ******************" << endl;
	cout << "******************    2.显示职工系统    ******************" << endl;
	cout << "******************    3.删除离职职工    ******************" << endl;
	cout << "******************    4.修改职工信息    ******************" << endl;
	cout << "******************    5.查找职工信息    ******************" << endl;
	cout << "******************    6.按照编号排序   ******************" << endl;
	cout << "******************    7.清空所有文档    ******************" << endl;
	cout << "**********************************************************" << endl;
	cout << endl;
}

//退出系统
void WorkerManager::ExitSystem()
{
	cout << "欢迎下次使用" << endl;
	system("pause");
	exit(0);//退出程序
}

//添加职工
void WorkerManager::Add_Emp()
{
	cout << "请输入添加职工数量： " << endl;
	int addNum = 0;//保存用户的输入数量
	cin >> addNum;
	if (addNum > 0)
	{
		//添加
		//计算添加新空间大小
		int newSize = this->m_EmpNum + addNum;//新空间人数=原来记录人数+新增人数

		//开辟新空间
		Worker** newSpace =new Worker*[newSize];

		//将原来的空间数据拷贝到新空间下
		if (this->m_EmpArray != NULL)
		{
			for (int i = 0; i < this->m_EmpNum; i++)
			{
				newSpace[i] = this->m_EmpArray[i];
			}
		}

		//批量添加新数据
		for (int i = 0; i < addNum; i++)
		{
			int id;//职工编号
			string name;//职工姓名
			int dSelect;//部门选择
			cout << "请输入第" << i + 1 << "个新职工编号： " << endl;
			cin >> id;
			cout << "请输入第" << i + 1 << "个新职工姓名： " << endl;
			cin >> name;
			cout << "请选择该职工的岗位： " << endl;
			cout << "1、普通职工" << endl;
			cout << "2、经理" << endl;
			cout << "3、老板" << endl;
			cin >> dSelect;

			Worker* worker = NULL;
			switch(dSelect)
			{
			case 1:
				worker = new Employee(id, name, 1);
				break;
			case 2:
				worker = new Manager(id, name, 2);
				break;
			case 3:
				worker = new Boss(id, name, 3);
				break;
			default:
				break;
			}

			//将创建职工职责，保存到数组中
			newSpace[this->m_EmpNum + i] = worker;

		}
		//释放原有空间
		delete[] this->m_EmpArray;

		//更改新空间的指向
		this->m_EmpArray = newSpace;

		//更新新的职工人数
		this->m_EmpNum = newSize;

		//更新职工不为空的标志
		this->m_FileIsEmpty = false;

		//提示添加成功
		cout << "成功添加" << addNum << "名新职工！" << endl;

		//保存数据到文件中
		this->save();
	}
	else
	{
		cout << "输入数据有误" << endl;
	}

	//按任意键后 清屏回到上级目录
	system("pause");
	system("cls");
}

//保存文件
void WorkerManager::save()
{
	ofstream ofs;
	ofs.open(FILENAME, ios::out);//用输出的方式打开文件--写文件
	//将每个人数据写入到文件中
	for (int i = 0; i < this->m_EmpNum; i++)
	{
		ofs << this->m_EmpArray[i]->m_Id << " "
			<< this->m_EmpArray[i]->m_Name << " "
			<< this->m_EmpArray[i]->m_DeptId << endl;
	}
	
	//关闭文件
	ofs.close();
}

//统计文件中人数
int WorkerManager::get_EmpNum()
{
	ifstream ifs;
	ifs.open(FILENAME, ios::in);//打开文件，读取

	int id;
	string name;
	int dId;

	int num = 0;
	while (ifs >> id && ifs >> name && ifs >> dId)
	{
		num++;
	}

	return num;
}

//初始化员工
void WorkerManager::init_Emp()
{
	ifstream ifs;
	ifs.open(FILENAME, ios::in);

	int id;
	string name;
	int dId;

	int index = 0;
	while (ifs >> id && ifs >> name && ifs >> dId)
	{
		Worker* worker = NULL;
		if (dId == 1)//普通职工
		{
			worker = new Employee(id, name, dId);
		}
		else if (dId == 2)//经理
		{
			worker = new Manager(id, name, dId);
		}
		else//老板
		{
			worker = new Boss(id, name, dId);
		}
		this->m_EmpArray[index] = worker;
		index++;
	}

	//关闭文件
	ifs.close();
}

//显示职工
void WorkerManager::show_Emp() 
{
	//判断文件是否为空
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空" << endl;
	}
	else
	{
		for (int i = 0; i < this->m_EmpNum; i++)
		{
			//利用多态调整程序接口
			this->m_EmpArray[i]->showInfo();
		}

	}
	//按任意键后清屏
	system("pause");
	system("cls");
}

//删除职工
void WorkerManager::del_Emp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空！" << endl;
	}
	else
	{
		cout << "输入想要删除的职工编号" << endl;
		int id = 0;
		cin >> id;

		int index = this->IsExist(id);
		if (index != -1)//说明职工存在，并且要删除掉index位置上的职工
		{
			//数据前移
			for (int i = index; i < this->m_EmpNum; i++)
			{
				//数据前移
				this->m_EmpArray[i] = this->m_EmpArray[i + 1];
			}
			//更新数组中记录人员个数
			this->m_EmpNum--;
			//数据同步更新到文件中
			this->save();

			cout << "删除成功" << endl;
		}
		else
		{
			cout << "删除失败，未找到该职工" << endl;
		}
	}

	//按任意键 清屏
	system("pause");
	system("cls");
}

//判断职工是否存在 如果存在返回职工所在数组中的位置，不存在返回-1
int WorkerManager::IsExist(int id)
{
	int index = -1;
	for (int i = 0; i < this->m_EmpNum; i++)
	{
		if (this->m_EmpArray[i]->m_Id == id)
		{
			//找到职工
			index = i;

			break;
		}
	}
	return index;
}

//修改职工
void WorkerManager::Mod_Emp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空" << endl;
	}
	else
	{
		cout << "请输入修改职工的编号： " << endl;
		int id;
		cin >> id;
		int ret = this->IsExist(id);
		if (ret != -1)
		{
			//查找到编号的职工
			delete this->m_EmpArray[ret];
			
			int newId = 0;
			string newName = " ";
			int dSelect = 0;

			cout << "查到： " << id << "号职工，请输入新职工号： " << endl;
			cin >> newId;
			cout << "请输入新姓名： " << endl;
			cin >> newName;
			cout << "请输入新岗位： " << endl;
			cout << "1、普通职工" << endl;
			cout << "2、经理" << endl;
			cout << "3、老板" << endl;
			cin >> dSelect;

			Worker* worker = NULL;
			switch (dSelect)
			{
			case 1:
				worker = new Employee(newId, newName, dSelect);
				break;
			case 2:
				worker = new Manager(newId, newName, dSelect);
				break;
			case 3:
				worker = new Boss(newId, newName, dSelect);
				break;
			default:
				break;
			}

			//更新数据 到数组中
			this->m_EmpArray[ret] = worker;
			cout << "修改成功" << endl;

			//保存到文件中
			this->save();
		}
		else
		{
			cout << "修改失败，查无此人" << endl;
		}
	}

	system("pause");
	system("cls");
}

//查找职工
void WorkerManager::Find_Emp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空" << endl;
	}
	else
	{
		cout << "请输入查找的方式： " << endl;
		cout << "1、按职位编号查找" << endl;
		cout << "2、按职工姓名查找" << endl;
		
		int select = 0;
		cin >> select;
		if (select == 1)
		{
			//按编号查
			int id;
			cout << "请输入查找的职工编号" << endl;
			cin >> id;
			int ret = this->IsExist(id);
			if (ret != -1)
			{
				//找到职工
				cout << "查找成功！该职工信息如下： " << endl;
				this->m_EmpArray[ret]->showInfo();
			}
			else
			{
				cout << "查找失败，查无此人" << endl;
			}
		}
		else if(select==2)
		{
			//按姓名查
			string name;
			cout << "请输入查找的姓名" << endl;
			cin >> name;

			//加入判断是否查到的标志
			bool flag = false;

			for (int i = 0; i < this->m_EmpNum; i++)
			{
				if (this->m_EmpArray[i]->m_Name == name)
				{
					cout << "查找成功，职工编号为" << this->m_EmpArray[i]->m_Id
						<< "号职工信息如下：	" << endl;

					//调用显示信息的接口
					this->m_EmpArray[i]->showInfo();

					flag = true;
				}
			}

			if (flag == false)
			{
				cout << "查找失败，查无此人" << endl;
			}
		}
		else
		{
			cout << "输入有误" << endl;
		}
	}

	system("pause");
	system("cls");
}

//按照职工编号排序
void WorkerManager::Sort_Emp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空！" << endl;

		//在这里敲一下
		system("pause");
		system("cls");
	}
	else
	{
		cout << "请选择排序方式： " << endl;
		cout << "1、按职工号进行升序" << endl;
		cout << "2、按职工号进行降序" << endl;

		int select = 0;
		cin >> select;

		//选择排序
		for (int i = 0; i < this->m_EmpNum; i++)
		{
			int minOrMax = i;//声明最小值或最大值的下标
			
			for (int j = i + 1; j < this->m_EmpNum; j++)
			{
				if (select == 1)//升序
				{
					//选最小的排在第一个位置，再选第二小的排在第二个位置，以此类推
					if (this->m_EmpArray[minOrMax]->m_Id > this->m_EmpArray[j]->m_Id)
					{
						//如果最小值的下标不是我声明的数字i，那么就换成真正的最小值的下标数字j
						minOrMax = j;
					}
				}
				else//降序
				{
					//选最大的排在第一个位置，再选第二大的排在第二个位置，以此类推
					if (this->m_EmpArray[minOrMax]->m_Id < this->m_EmpArray[j]->m_Id)
					{
						//如果最大值的下标不是我声明的数字i，那么就换成真正的最大值的下标数字j
						minOrMax = j;
					}
				}
			}
			//判断最初认定的最小值或最大值的下标是不是真正的最小值或最大值的下标，如果不是则交换数据
			//也就是实现数组里面数据位置的互换，来实现升序或降序
			if (i != minOrMax)
			{
				Worker* temp = this->m_EmpArray[i];
				this->m_EmpArray[i] = this->m_EmpArray[minOrMax];
				this->m_EmpArray[minOrMax] = temp;
			}
		}
		//排序后的结果保存到文件中（想保存就保存，不保存也罢）
		this->save();

		cout << "排序成功！排序后的结果为： " << endl;
		this->show_Emp();
	}
	//show_Emp()里面有system("pause");system("cls")因此不用在这里重新敲了
}

//清空文件
void WorkerManager::Clean_Emp()
{
	cout << "确认是否清空？" << endl;
	cout << "1、确定" << endl;
	cout << "2、取消" << endl;

	int select = 0;
	cin >> select;

	if (select == 1)
	{
		//清空文件
		ofstream ofs(FILENAME, ios::trunc);//ios::trunc 删除文件后再重新创建
		ofs.close();

		if (this->m_EmpArray != NULL)
		{
			//删除堆区的每个职工对象
			for (int i = 0; i < this->m_EmpNum; i++)
			{
				delete this->m_EmpArray[i];
				this->m_EmpArray[i] = NULL;
			}

			//删除堆区的数组指针
			delete[] this->m_EmpArray;
			this->m_EmpArray = NULL;
			this->m_EmpNum = 0;
			this->m_FileIsEmpty = true;
		}

		cout << "清空成功" << endl;
	}

	system("pause");
	system("cls");
}

WorkerManager::~WorkerManager()
{
	if (this->m_EmpArray != NULL)
	{
		for(int i =0;i<this->m_EmpNum;i++)
		{
			if (this->m_EmpArray[i] != NULL)
			{
				delete this->m_EmpArray[i];
			}
		}
		delete[] this->m_EmpArray;
		this->m_EmpArray = NULL;
	}
}

职工管理系统.cpp

#include <iostream>
using namespace std;
#include "workerManager.h"
#include "worker.h"
#include "employee.h"
#include "boss.h"
#include "manager.h"

void test01()
{
	//测试代码：
	Worker* worker = NULL;
	worker = new Employee(1, "张三", 1);
	worker->showInfo();
	delete worker;

	worker = new Manager(2, "李四", 2);
	worker->showInfo();
	delete worker;

	worker = new Boss(3, "王五", 3);
	worker->showInfo();
	delete worker;
}
//ctrl+k+u 还原注释
int main()
{

	//实例化管理者对象
	WorkerManager wm;

	int choice = 0;//用来存储用户的选项
	while (true)
	{
		//调用展示菜单成员函数
		wm.Show_Menu();

		cout << "请输入您的选择" << endl;
		cin >> choice;//接受用户的选择

		switch (choice)
		{
		case 0://退出系统
			wm.ExitSystem();
			break;
		case 1://增加职工
			wm.Add_Emp();
			break;
		case 2://显示职工
			wm.show_Emp();
			break;
		case 3://删除职工
		{
			//测试
			/*int ret = wm.IsExist(2);
			if (ret != -1)
			{
				cout << "职工存在" << endl;
			}
			else
			{
				cout << "职工不存在" << endl;
			}
			break;*/
			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_Emp();
			break;
		default:
			system("cls");
			break;
		}
	}


	system("pause");

	return 0;
}

littleCodeLearner

关注

33
点赞
踩
34

收藏

觉得还不错? 一键收藏
0
评论
Visual Studio 2022版本 B站黑马程序员C++自学分享－第二阶段（主要包括：自己敲的代码、通过注释来备注上自己对代码的理解）

黑马的课程里面分为了三大阶段一、第一阶段 C++基础语法入门对C++有初步了解，能够有基础编程能力二、第二阶段 C++核心编程介绍C++面向对象编程，为大型项目做铺垫三、第三阶段 C++提高编程介绍C++泛型编程思想，以及STL的基本使用※※※我会一个阶段发一个文章，一共发布三个文章来把学习的代码还有自己在代码旁边标注的对于这些代码的理解和心得体会一起分享给大家！！！
复制链接

扫一扫