C++ 核心编程

第一章 内存分区模型

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

• 代码区：存在函数体的二进制代码，由操作系统进行管理的
• 全局区：存放在全局变量和静态变量以及常量
• 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
• 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存四区意义：不同区域存放不同的数据，赋予不同的生命周期，给我们更大的灵活编程

一、程序运行前

在程序编译后，生成 exe 可执行程序，未执行该程序前分为两个区域

1、代码区

• 存放 CPU 执行的机器指令
• 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
• 代码区是只读的，使其只读的原因是防止程序意外的修改了它的指令

2、全局区

• 全局变量和静态变量存放在此

• 全局区还包含了常量区，字符串常量和其它常量也存放在此

• 该区域的数据在程序执行结束后由操作系统释放。

• 代码示例

  #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 main() 
  {
  	// 全局区
  	// 全局变量、静态变量、常量
  
  	// 创建普通局部变量
  	int a = 10;
  	int b = 10;
  
  	// 创建静态变量
  	static int s_a = 10;
  	static int s_b = 10;
  
  	// 创建 const 修饰的局部变量, 局部常量
  	const int c_l_a = 10;
  	const int c_l_b = 10;
  
  	
  	cout << "局部变量 a 的地址为：" << (int)&a << endl;
  	cout << "局部变量 b 的地址为：" << (int)&b << endl;
  	cout << endl;
  
  	cout << "全局变量 a 的地址为：" << (int)&g_a << endl;
  	cout << "全局变量 b 的地址为：" << (int)&g_b << endl;
  	cout << endl;
  
  	cout << "静态变量 a 的地址为：" << (int)&s_a << endl;
  	cout << "静态变量 b 的地址为：" << (int)&s_b << endl;
  	cout << endl;
  
  	cout << "字符串常量的地址为: " << (int)&"Hello World" << endl;
  	cout << endl;
  	
  	cout << "全局常量 a 的地址为：" << (int)&c_g_a << endl;
  	cout << "全局常量 b 的地址为：" << (int)&c_g_b << endl;
  	cout << endl;
  
  	cout << "局部常量 a 的地址为：" << (int)&c_l_a << endl;
  	cout << "局部常量 b 的地址为：" << (int)&c_l_b << endl;
  	cout << endl;
  
  	system("pause");
  	return 0;
  }
  

结论：

• C++ 中在程序运行前分为全局区和代码区
• 代码区特点是共享和只读
• 全局区中存放全局变量、静态变量、常量
• 常量区中存放 const 修饰的全局常量 和字符串常量

二、程序运行后

1、栈区

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

示例：

#include <iostream>
using namespace std;

// 栈区数据注意事项
// 栈区的数据由编译器管理开辟和释放
// 形参数据也会放在栈区
int* func(int input)
{
	input = 100;
	int a = 10;	 // 局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;	// 返回局部地址
}

int main()
{
	// 接收 func 函数的返回值
	int* p = func(10);

	cout << *p << endl; // 第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl; // 第二次这个数据就不再保留了

	system("pause");
	return 0;
}

2、堆区

• 有程序员分配释放，若程序员不释放，程序结束时由操作系统回收
• 在 C++ 中主要利用 new 在堆区开辟内存

示例：

#include <iostream>
using namespace std;

// 在堆区开辟数据
int* func()
{
	// 利用 new 关键字 可以将数据开辟到堆区
	// 指针本质上也是局部变量，放在栈上，指针保存的数据是放在堆区
	int* a = new int(10);
	return a;
}

int main()
{
	// 接收 func 函数的返回值
	int* p = func();

	cout << *p << endl;
	cout << *p << endl;

	system("pause");
	return 0;
}

总结：

• 堆区数据由程序员开辟和释放
• 堆区数据利用 new 关键字进行开辟内存

三、new 操作符

C++ 中利用 new 操作符在堆区开辟数据

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

语法：new 数据类型;

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

示例：

#include <iostream>
using namespace std;

// 1、new 的基本语法
int* func()
{
	// 在堆区创建一个整型数据
	// new 返回的是，该数据类型的指针
	int* p = new int(10);
	return p;
}


void test01()
{
	int* p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	// 堆区的数据 由程序员管理开辟，程序员管理释放
	// 如果想释放堆区的数据，利用关键字 delete
	delete p;
	// cout << *p << endl; // 内存已经被释放，再次访问就是非法操作，会报错

}

// 2、在堆区利用 new 开辟数组
void test02()
{
	// 创建 10 个整型的数组
	int* arr = new int[10]; // 10 代表数组有是个元素
	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 main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

第二章 引用

一、引用的基本使用

作用：给变量起别名

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

示例：

#include <iostream>
using namespace std;

int main()
{
	// 引用的基本语法
	// 数据类型 &别名 = 原名;
	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;
}

二、引用的注意事项

• 引用必须初始化

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

示例：

#include <iostream>
using namespace std;

int main()
{
	// 引用的注意事项
	int a = 10;
	int b = 20;
	// int &c; // 错误，引用必须初始化 
	int& c = a; // 一旦初始化后，就不可以更改
	c = b; // 这是赋值操作，不是更改引用

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	system("pause");
	return 0;
}

三、引用做函数参数

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

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

示例：

#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* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	// cout << "swap02 a = " << a << endl;
	// cout << "swap02 b = " << b << endl;
}


// 3、引用传递
void mySwap03(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
	// cout << "swap03 a = " << a << endl;
	// cout << "swap03 b = " << b << endl;
}


int main()
{

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

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

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

	system("pause");
	return 0;
}

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

四、引用做函数返回值

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

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

用法：函数调用作为左值

示例：

#include <iostream>
using namespace std;

// 返回局部变量引用 不要返回局部变量引用 因为局部变量存放在四区中的栈区 当函数执行完之后局部变量会自动销毁
int& test01()
{
	int a = 10;
	return a;
}

// 返回静态变量引用 函数调用作为左值 静态变量，存放在全局区，全局区上的数据在整个程序结束后系统进行释放
int& test02()
{
	static int a = 20;
	return a;
}

int main()
{
	// int& ref = test01();
	// cout << "ref = " << ref << endl; // 第一次可以打印正确的数字，是因为编译器做了保留
	// cout << "ref = " << ref << endl; // 第二次这个数据就不再保留了

	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	test02() = 1000; // 如果函数的返回值是引用，这个函数调用可以作为左值 a = 1000;
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;

	system("pause");
	return 0;
}

五、引用的本质

本质：引用的本质在 C++ 内部实现是一个指针常量

示例：

#include <iostream>
using namespace std;

void func(int& ref)
{
	ref = 100; // ref 是引用，转换为 *ref = 100;
}

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

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

	func(a);
	cout << "a = " << a << endl;
	cout << "ref = " << ref << endl;

	system("pause");
	return 0;
}

结论：C++ 推荐使用引用技术，因为语法方便，引用本质是 指针常量，但是所有的指针操作编译器都帮我们做了

六、常量引用

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

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

示例：

#include <iostream>
using namespace std;


// 引用使用场景，通常用来修饰形参
void showValue(const int& ref)
{
	// ref = 100;
	cout << ref << endl;
}


int main()
{
	int a = 10;
	// int& ref = 10; // 引用本身需要一个合法的内存空间，因此这行错误
	// const int& ref = 10; // 加入const 就可以了，编译器优化代码 `int temp = 10; const int& ref = temp;` 

	showValue(a);

	system("pause");
	return 0;
}

第三章 函数进阶

一、函数默认参数

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

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

示例：

#include <iostream>
using namespace std;

// 如果我们自己传入数据，就用自己的数据，如果没有那么就用默认值
int func(int a, int b = 10, int c = 10)
{
	return a + b + c;
}

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

int main()
{
	int a = 10;
	cout << "func(a); " << func(a) << endl;
	cout << "func(a, 20); " << func(a, 20) << endl;
	cout << "func(a, 20, 30); " << func(a, 20, 30) << endl;

	cout << "func2(); " << func2() << endl;
	cout << "func2(a); " << func2(a) << endl;
	cout << "func2(a, 20); " << func2(a, 20) << endl;

	system("pause");
	return 0;
}

二、函数占位参数

C++ 中函数的形参列表中可以有占位参数

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

现阶段函数占位符存在的意义不大，但是后面的课程中会用大该技术

示例：

#include <iostream>
using namespace std;

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


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

	system("pause");
	return 0;
}

三、函数重载

1、函数重载概述

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

函数重载满足条件：

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

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

示例：

#include <iostream>
using namespace std;

// 函数重载需要函数都在同一作用域下
// 1、个数不同
void func()
{
	cout << "func 的调用! " << endl;
}

// 2、类型不同
void func(int a)
{
	cout << "func(int a) 的调用! " << endl;
}

void func(double a)
{
	cout << "func(double a) 的调用! " << endl;
}

// 3、顺序不同
void func(int a, double b)
{
	cout << "func(int a, double b) 的调用! " << endl;
}

void func(double a, int b)
{
	cout << "func(double a, int b) 的调用! " << endl;
}

// 注意事项：函数的返回值不能作为函数重载的条件
//double func(double a, int b)
//{
//	cout << "func(double a, int b) 的调用! " << endl;
//	return a * b;
//}

int main()
{
	func();
	func(10);
	func(3.14);
	func(10, 3.14);
	func(3.14, 10);

	system("pause");
	return 0;
}

3、函数重载注意事项

• 引用作为重载条件
• 函数重载碰到函数默认参数

示例：

#include <iostream>
using namespace std;

// 函数重载注意事项
// 1、引用作为重载条件
void func(int& a) // int& a = 10; 不合法
{
	cout << "func(int& a) 的调用! " << endl;
}

void func(const int& a) // const int& a = 10; 合法
{
	cout << "func(const int& a) 的调用! " << endl;
}

// 2、函数重载碰到函数默认参数
void func2(int a, int b = 10)
{
	cout << "func2(int a) 的调用! " << endl;
}

void func2(int a)
{
	cout << "func2(int a) 的调用! " << endl;
}

int main()
{
	int a = 10;
	func(a);
	func(10);

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

第四章 类和对象

C++ 面向对象的三大特性为：封装、继承、多态

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

例如：

• 人可以作为对象，属性名有姓名、年龄、身高、体重...，行为有、走、跑、跳、吃饭、唱歌...
• 车也可以作为对象，属性有轮胎、方向盘、车灯...，行为有载人、放音乐、开空调...
• 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

一、封装

1、封装的意义

封装是 C++ 面向对象三大特征之一

封装的意义：

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

(1) 封装的意义一

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

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

示例：设计一个圆类，求圆的周长

#include <iostream>
using namespace std;

// 圆周率
const double PI = 3.14;

// 1、设计一个圆类，求圆的周长: 公式: 2 * PI * 半径
class Circle
{
	// 2、定义访问权限 - 公共权限
public:

	// 3、定义属性
	// 半径
	int radius;

	// 4、定义行为
	// 获取圆的周长
	double calculatePerimeter() 
	{
		return 2 * PI * radius;
	}
};

int main()
{
	// 5、通过圆类创建一个具体的对象(实例化 通过一个类，创建一个对象的过程)
	Circle circle_obj;
	// 6、给圆对象 的属性进行赋值操作
	circle_obj.radius = 20;
	// 7、调用计算函数获取周长
	cout << "半径为: " << circle_obj.radius << " 的圆的周长为: " << circle_obj.calculatePerimeter() << endl;

	system("pause");
	return 0;
}

练习：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

#include <iostream>
using namespace std;


// 1、设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
class Student
{
	// 2、定义访问权限 - 公共权限
public:

	// 3、定义属性 属性又称为 成员属性 成员变量
	// 姓名
	string name;
	// 学号
	string studentNumber;

	// 4、定义行为 行为又称为 成员函数 成员方法
	// 设置姓名
	void setName(string val) 
	{
		name = val;
	}
	// 设置学号
	void setStudentNumber(string val)
	{
		studentNumber = val;
	}
	// 打印学生信息
	void showStudentInfo() 
	{
		cout << "学生: " << name << " 的学号为: " << studentNumber << endl;
	}
};

int main()
{

	// 5、实例化学生对象
	Student student_obj1;
	// 6、给对象的属性进行赋值操作
	student_obj1.name = "桥本有菜";
	student_obj1.studentNumber = "X-00000000";
	// 7、调用对象方法打印学生信息
	student_obj1.showStudentInfo();

	// 5、实例化学生对象
	Student student_obj;
	// 6、调用对象方法给属性设置值
	student_obj.setName("三上悠亚");
	student_obj.setStudentNumber("X-00000001");
	// 7、调用对象方法打印学生信息
	student_obj.showStudentInfo();

	system("pause");
	return 0;
}

(2) 封装的意义二

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

访问权限有三种：

• public 公共权限 类内可以访问 类外可以访问
• protected 保护权限 类内可以访问 类外不可以访问
• private 私有权限 类内可以访问 类外不可以访问

示例：

#include <iostream>
using namespace std;


// 三种权限
// public		公共权限    类内可以访问    类外可以访问		子类可以访问父类中的内容
// protected	保护权限    类内可以访问    类外不可以访问		子类可以访问父类中保护的内容
// private		私有权限    类内可以访问    类外不可以访问		子类不可以访问父类中的内容

class Person
{
	
public:
	// 公共权限
	// 姓名
	string name;
protected:
	// 保护权限
	// 汽车
	string car;
private:
	// 私有权限
	// 银行卡
	string bankCard;
	// 密码
	string password;

public:
	// 公共权限
	// 获取成员变量
	void getVariable()
	{
		cout << "姓名: " << name << " 车: " << car << " 银行卡: " << bankCard << " 密码: " << password << endl;
	}

protected:
	// 保护权限
	// 设置成员变量
	void setVariable()
	{
		name = "三上悠亚";
		car = "卡迪拉克";
		bankCard = "B-00000000";
		password = "P-00000000";
	}
};

int main()
{

	// 实例化对象
	Person p1;
	p1.name = "桥本有菜";
	// p1.car = "奔驰";					// 保护权限内容，在类外访问不到
	// p1.bankCard = "B-00000001";		// 私有权限内容，在类外访问不到
	p1.getVariable();
	// p1.setVariable();				// 保护权限内容，在类外访问不到

	system("pause");
	return 0;
}

2、struct 和 class 的区别

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

区别：

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

示例：

#include <iostream>
using namespace std;

class C1
{
	int a; // 默认是私有权限
};

struct C2
{
	int a; // 默认是公共权限
};

int main()
{

	C1 c1;
	// 私有属性 类外不可访问
	// c1.a = 10;
	// cout << "c1.a = " << c1.a << endl;

	C2 c2;
	c2.a = 10;
	cout << "c2.a = " << c2.a << endl;

	system("pause");
	return 0;
}

3、成员属性设置为私有

优点：

• 将所有成员属性设置为私有，可以控制读写权限
• 对于写权限，我们可以检测数据的有效性

示例：

#include <iostream>
using namespace std;

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

	// 年龄只读权限
	int getAge()
	{
		m_Age = 0;
		return m_Age;
	}

	// 偶像只写权限
	void setIdol(string idol)
	{
		m_Idol = idol;
	}
private:
	// 姓名 可读可写
	string m_Name;
	// 年龄 只读
	int m_Age;
	// 偶像	只写
	string m_Idol;
};


int main()
{
	Person person_obj;
	// 设置姓名
	person_obj.setName("刘安冰");
	// 获取姓名
	cout << "姓名为: " << person_obj.getName() << endl;
	// 获取年龄
	// person_obj.m_Age = 10;
	// person_obj.setAge(10);
	cout << "年龄为: " << person_obj.getAge() << endl;
	// 设置偶像
	person_obj.setIdol("三上悠亚");
	// cout << "偶像为: " << person_obj.getIdol() << endl;

	system("pause");
	return 0;
}

示例：

#include <iostream>
using namespace std;

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

	// 年龄可读可写 如果想要修改（年龄范围必须是 0 ~ 150 之间）
	void setAge(int age)
	{
		if (age > 0 && age < 150)
		{
			m_Age = age;
		}
		else
		{
			m_Age = 0;
			cout << "年龄范围必须是 0 ~ 150 之间!!!" << endl;
		}
	}
	int getAge()
	{
		return m_Age;
	}

	// 偶像只写权限
	void setIdol(string idol)
	{
		m_Idol = idol;
	}
private:
	// 姓名 可读可写
	string m_Name;
	// 年龄 只读
	int m_Age;
	// 偶像	只写
	string m_Idol;
};


int main()
{
	Person person_obj;
	// 设置姓名
	person_obj.setName("刘安冰");
	// 获取姓名
	cout << "姓名为: " << person_obj.getName() << endl;
	// 设置年龄
	person_obj.setAge(18);
	// 获取年龄
	cout << "年龄为: " << person_obj.getAge() << endl;
	// 设置偶像
	person_obj.setIdol("三上悠亚");

	system("pause");
	return 0;
}

4、练习

(1) 立方体类

设计立方体类（Cube）

求出立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等

#include <iostream>
using namespace std;

class Cube
{
public:
	// 设置长宽高
	void setLength(int length)
	{
		m_Length = length;
	}
	void setWidth(int width)
	{
		m_Width = width;
	}
	void setHeight(int height)
	{
		m_Height = height;
	}

	// 获取长宽高
	int getLength()
	{
		return m_Length;
	}
	int getWidth()
	{
		return m_Width;
	}
	int getHeight()
	{
		return m_Height;
	}

	// 计算面积
	int calculateArea()
	{
		// 长方体表面积公式：S =（长×宽＋长×高＋宽×高）×2
		return (m_Length * m_Width + m_Length * m_Height + m_Width * m_Height) * 2;
	}

	// 计算体积
	int calculateVolume()
	{
		// 长方体体积公式：S = 长×宽×高
		return m_Length * m_Width * m_Length;
	}

	bool isSameByClass(Cube& c)
	{
		if (m_Length == c.getLength() && m_Width == c.getWidth() && m_Height == c.getHeight())
		{
			return true;
		}
		return false;
	}
private:
	// 长
	int m_Length;
	// 宽
	int m_Width;
	// 高
	int m_Height;
};


// 利用全局函数判断两个立方体是否相等
bool isSame(Cube& c1, Cube& c2)
{
	if (c1.getLength() == c2.getLength() && c1.getWidth() == c2.getWidth() && c1.getHeight() == c2.getHeight())
	{
		return true;
	}
	return false;
}

int main()
{
	Cube cube_obj;
	// 设置长宽高
	cube_obj.setLength(10);
	cube_obj.setWidth(10);
	cube_obj.setHeight(10);
	// 获取长方体面积
	cout << "长方体面积为: " << cube_obj.calculateArea() << endl;
	// 获取长方体体积
	cout << "长方体体积为: " << cube_obj.calculateVolume() << endl;

	// 判断两个立方体是否相等
	Cube c1;
	c1.setLength(10);
	c1.setWidth(10);
	c1.setHeight(10);

	Cube c2;
	c2.setLength(10);
	c2.setWidth(10);
	c2.setHeight(10);

	bool ret = isSame(c1, c2);
	if (ret)
	{
		cout << "全局函数判断 c1 和 c2 是相等的" << endl;
	}
	else
	{
		cout << "全局函数判断 c1 和 c2 是不相等的" << endl;
	}

	bool ret2 = c2.isSameByClass(c1);
	if (ret)
	{
		cout << "成员函数判断 c1 和 c2 是相等的" << endl;
	}
	else
	{
		cout << "成员函数判断 c1 和 c2 是不相等的" << endl;
	}

	system("pause");
	return 0;
}

(2) 点和圆的关系

设计一个原型类型（Circle），和一个点类（Point），计算点和圆的关系

• 点到圆心的距离 == 半径 点在圆上
• 点到圆心的距离 > 半径 点在圆外
• 点到圆心的距离 < 半径 点在圆内
• 点到圆心的距离 == 0 点在圆心

点到圆心的距离：
$$
\sqrt{(x1 - x2) ^ 2 + ( y1-y2 ) ^ 2}
$$
简化：

(x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) 对比 m_R * m_R

示例：

#include <iostream>
using namespace std;

// 点类
class Point
{
public:
	// 设置点坐标
	void setX(int x)
	{
		m_X = x;
	}
	void setY(int y)
	{
		m_Y = y;
	}

	// 获取点坐标
	int getX()
	{
		return m_X;
	}
	int getY()
	{
		return m_Y;
	}

private:
	// 点坐标 x
	int m_X;
	// 点坐标 y
	int m_Y;
};

// 圆类
class Circle
{
public:
	// 设置圆心坐标和半径
	void setCenter(Point& center)
	{
		m_Center = center;
	}
	void setR(int r)
	{
		m_R = r;
	}
	
	// 获取圆心坐标和半径
	Point getCenter()
	{
		return m_Center;
	}
	int getR()
	{
		return m_R;
	}

	// 判断点在圆的位置
	void isInCircle(Point& p)
	{
		// 计算两点之间的距离 平方
		int distance =
			(m_Center.getX() - p.getX()) * (m_Center.getX() - p.getX()) +
			(m_Center.getY() - p.getY()) * (m_Center.getY() - p.getY());
		// 计算半径平方
		int rDistance = m_R * m_R;
		// 判断关系
		if (distance == rDistance)
		{
			cout << "点在圆上" << endl;
		}
		else if (distance > rDistance)
		{
			cout << "点在圆外" << endl;
		}
		else if (distance < rDistance)
		{
			cout << "点在圆内" << endl;
		}
		else
		{
			cout << "点在圆心" << endl;
		}
	}

private:
	// 圆心坐标 x,y 在类中可以让另一个类作为本类中的成员
	Point m_Center;
	// 圆的半径
	int m_R;
};

// 判断点和圆的关系
void isInCircle(Circle c, Point p)
{
	int distance = 
		(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
	// 计算半径平方
	int rDistance = c.getR() * c.getR();
	// 判断关系
	if (distance == rDistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点在圆外" << endl;
	}
	else if (distance < rDistance)
	{
		cout << "点在圆内" << endl;
	}
	else
	{
		cout << "点在圆心" << endl;
	}
}

// 程序入口函数
int main()
{
	// 创建圆
	Circle circle_obj;
	Point center;
	center.setX(10);
	center.setY(0);
	circle_obj.setCenter(center);
	circle_obj.setR(10);

	// 实例化对象 并 设置点坐标
	Point point_obj;
	point_obj.setX(10);
	point_obj.setY(10);
	
	// 判断点和圆的关系
	isInCircle(circle_obj, point_obj);
	circle_obj.isInCircle(point_obj);

	system("pause");
	return 0;
}

优化 - 分文件编写

• 点 - 头文件 point.h

  #pragma once
  #include <iostream>
  using namespace std;
  
  
  class Point
  {
  public:
  	// 设置点坐标
  	void setX(int x);
  	void setY(int y);
  	// 获取点坐标
  	int getX();
  	int getY();
  
  private:
  	// 点坐标 x
  	int m_X;
  	// 点坐标 y
  	int m_Y;
  };
  

• 点 - 源文件 point.cpp

  #include "point.h"
  
  // 设置点坐标
  void Point::setX(int x)
  {
  	m_X = x;
  }
  void Point::setY(int y)
  {
  	m_Y = y;
  }
  
  // 获取点坐标
  int Point::getX()
  {
  	return m_X;
  }
  int Point::getY()
  {
  	return m_Y;
  }
  

• 圆 - 头文件 circle.h

  #pragma once
  #include <iostream>
  using namespace std;
  #include "point.h"
  
  class Circle
  {
  public:
  	// 设置圆心坐标和半径
  	void setCenter(Point& center);
  	void setR(int r);
  	// 获取圆心坐标和半径
  	Point getCenter();
  	int getR();
  	// 判断点在圆的位置
  	void isInCircle(Point& p);
  
  private:
  	// 圆心坐标 x,y 在类中可以让另一个类作为本类中的成员
  	Point m_Center;
  	// 圆的半径
  	int m_R;
  };
  

• 圆 - 源文件 circle.cpp

  #include "circle.h"
  
  // 设置圆心坐标和半径
  void Circle::setCenter(Point& center)
  {
  	m_Center = center;
  }
  void Circle::setR(int r)
  {
  	m_R = r;
  }
  
  // 获取圆心坐标和半径
  Point Circle::getCenter()
  {
  	return m_Center;
  }
  int Circle::getR()
  {
  	return m_R;
  }
  
  // 判断点在圆的位置
  void Circle::isInCircle(Point& p)
  {
  	// 计算两点之间的距离 平方
  	int distance =
  		(m_Center.getX() - p.getX()) * (m_Center.getX() - p.getX()) +
  		(m_Center.getY() - p.getY()) * (m_Center.getY() - p.getY());
  	// 计算半径平方
  	int rDistance = m_R * m_R;
  	// 判断关系
  	if (distance == rDistance)
  	{
  		cout << "点在圆上" << endl;
  	}
  	else if (distance > rDistance)
  	{
  		cout << "点在圆外" << endl;
  	}
  	else if (distance < rDistance)
  	{
  		cout << "点在圆内" << endl;
  	}
  	else
  	{
  		cout << "点在圆心" << endl;
  	}
  }
  

• 入口文件 main.cpp

  #include <iostream>
  using namespace std;
  #include "point.h"
  #include "circle.h"
  
  // 判断点和圆的关系
  void isInCircle(Circle c, Point p)
  {
  	int distance = 
  		(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
  		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
  	// 计算半径平方
  	int rDistance = c.getR() * c.getR();
  	// 判断关系
  	if (distance == rDistance)
  	{
  		cout << "点在圆上" << endl;
  	}
  	else if (distance > rDistance)
  	{
  		cout << "点在圆外" << endl;
  	}
  	else if (distance < rDistance)
  	{
  		cout << "点在圆内" << endl;
  	}
  	else
  	{
  		cout << "点在圆心" << endl;
  	}
  }
  
  int main()
  {
  	// 创建圆
  	Circle circle_obj;
  	Point center;
  	center.setX(10);
  	center.setY(0);
  	circle_obj.setCenter(center);
  	circle_obj.setR(10);
  
  	// 实例化对象 并 设置点坐标
  	Point point_obj;
  	point_obj.setX(10);
  	point_obj.setY(10);
  	
  	// 判断点和圆的关系
  	isInCircle(circle_obj, point_obj);
  	circle_obj.isInCircle(point_obj);
  
  	system("pause");
  	return 0;
  }
  

二、对象的初始化和清理

• 生活中我们买的电子产品基本都会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
• C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的数据清理的设置

1、构造函数和析构函数

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

• 一个对象或者变量没有初识状态，对其使用后果是未知的
• 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

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

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

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

(1) 构造函数

语法：类型() {}

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

(2) 析构函数

语法：~类名() {}

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

(3) 示例

#include <iostream>
using namespace std;

// 对象的初始化和清理

class Person
{
public:
	/*
		1、构造函数 进行初始化操作
			- 没有返回值 不用写void
			- 函数名与类名相同
			- 构造函数可以有参数，可以发生重载
			- 创建对象的时候，构造函数会自动调用，而且只调用一次
	*/
	Person()
	{
		cout << "Person 构造函数的调用" << endl;
	}

	/*
		2、析构函数 进行清理的操作
			- 没有返回值 不用写void
			- 函数名称与类名相同，在名称前面加上符号 ~
			- 析构函数不可以有参数，因此不可以发生重载
			- 程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
	*/
	~Person()
	{
		cout << "Person 析构函数的调用" << endl;
	}

};

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

int main()
{
	test01();

	// Person p; 

	system("pause");
	return 0;
}

2、构造函数的分类及调用

两种分类方式：

• 按参数分为：有参构造和无参构造
• 按类型分为：普通构造和拷贝构造

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

示例：

#include <iostream>
using namespace std;

/*
	1、构造函数分类
		- 按照参数分类分为：有参和无参构造 无参又称为默认构造函数
		- 按照类型分类分为：普通构造和拷贝构造
*/

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

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

	// 获取年龄
	int getAge()
	{
		return age;
	}


private:
	int age;
};

void test01()
{
	// 1、括号法
	Person p1; // 默认构造函数调用
	Person p2(10); // 有参构造函数调用
	Person p3(p2); // 拷贝构造函数调用
	// 注意事项： 调用默认构造函数的时候，不要加 ()； 原因  Person p1(); 这句代码，编译器会认为是一个函数的声明，不会认为在创建对象
	cout << "p2 的年龄为：" << p2.getAge() << endl;
	cout << "p3 的年龄为：" << p3.getAge() << endl;
	
	// 2、显示法
	Person p4 = Person(10); // 有参构造函数调用
	Person p5 = Person(p2); // 拷贝构造函数调用
	// Person(10); // 匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
	// 注意事项：不要利用拷贝构造函数，初始化匿名对象 Person(p2); 编译器会认为 Person(p2); === Person p2; 对象声明
	
	// 3、隐式转换法
	Person p6 = 10; // 相当于 Person p6 = Person(10); 有参构造函数调用
	Person p7 = p2; // 相当于 Person p7 = Person(p2); 有参构造函数调用
}
 

int main()
{
	test01(); 

	system("pause");
	return 0;
}

3、拷贝构造函数调用时机

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

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

示例：

#include <iostream>
using namespace std;

/*
	拷贝构造函数调用时机
		- 使用一个已经创建完毕的对象来初始化一个新对象
		- 值传递的方式给函数参数传值
		- 以值方式返回局部对象
*/

class Person
{
public:
	Person()
	{
		m_Age = 0;
		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 getAge()
	{
		return m_Age;
	}

private:
	int m_Age;
};

// 1、使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20); // 有参构造函数调用
	Person p2(p1); // 拷贝构造函数调用
	cout << "p2 的年龄为：" << p2.getAge() << endl;
}

// 2、值传递的方式给函数参数传值
void doWork(Person p)
{
	
}
void test02()
{
	Person p; // 默认构造函数调用
	doWork(p); // 拷贝构造函数调用
}

// 3、以值方式返回局部对象
Person doWork2()
{
	Person p; // 默认构造函数调用
	cout << (int*)& p << endl;
	return p; // 拷贝构造函数调用
}
void test03()
{
	Person p = doWork2();
	cout << (int*)&p << endl;
}


int main()
{
	// test01(); 
	// test02();
	test03();
	system("pause");
	return 0;
}

4、构造函数调用规则

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

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数主体为空）
3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 用户定义有参构造函数，C++ 不再提供默认无参构造，但是会提供默认拷贝构造
• 如果定义拷贝构造函数，C++ 不再提供其他构造函数

示例：

#include <iostream>
using namespace std;

/*
	构造函数调用规则
		- 默认构造函数（无参，函数体为空）
		- 默认析构函数（无参，函数主体为空）
		- 默认拷贝构造函数，对属性进行值拷贝
*/

class Person
{
public:
	// 无参（默认）构造函数
	Person()
	{
		m_Age = 0;
		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 getAge()
	{
		return m_Age;
	}
	// 设置年龄
	void setAge(int age)
	{
		m_Age = age;
	}

private:
	int m_Age;
};

void test01()
{
	Person p;
	p.setAge(18);
	Person p1(p);
	cout << "p2 的年龄为：" << p1.getAge() << endl;
}

int main()
{
	test01(); 
	system("pause");
	return 0;
}

5、深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

• 浅拷贝：简单的复制拷贝操作
• 深拷贝：在堆区重新申请空间，进行拷贝操作

示例：

#include <iostream>
using namespace std;

/*
	深拷贝与浅拷贝
*/

class Person
{
public:
	Person()
	{
		cout << "Person 的无参构造函数的调用" << endl;
		m_Age = 0;
	}
	Person(int age, int height)
	{
		cout << "Person 的有参构造函数的调用" << endl;
		m_Age = age;
		m_Height = new int(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()
	{
		// 浅拷贝带来的问题就是，堆区内存重复释放
		// 浅拷贝的问题 要利用深拷贝来进行解决
		cout << "Person 析构函数的调用" << endl;
		// 析构代码，将堆区开辟的数据做释放操作
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
	}

	int m_Age; // 年龄
	int* m_Height; // 身高
};

void test01()
{
	Person p1(18, 180);
	Person p2(p1);
	cout << "p1 的年龄为：" << p1.m_Age << " p1 的身高为：" << *p1.m_Height << endl;
	cout << "p2 的年龄为：" << p2.m_Age << " p2 的身高为：" << *p1.m_Height << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

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

6、初始化列表

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

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

示例：

#include <iostream>
using namespace std;

class Person
{
public:
	// 传统初始化操作
	/*Person(int a, int b, int c)
	{
		m_A = a;
		m_B = b;
		m_C = c;
	}*/

	// 初始化列表初始化属性
	Person(int a, int b, int c) : m_A(a), m_B(b), m_C(c)
	{

	}
	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	// Person p(10, 20, 30);
	Person p(10, 20, 30);
	cout << "p 的m_A：" << p.m_A << " m_B：" << p.m_B << " m_C：" << p.m_C << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

7、类对象作为类成员

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

例如：

class A {}
class B
{
    A a;
}

B类中有对象A作为成员，A对象为对象成员

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

示例：

#include <iostream>
using namespace std;

class Phone
{
public:
	// 构造函数
	Phone(string pName)
	{
		cout << "Phone 的有参构造函数的调用" << endl;
		m_PName = pName;
	}
	// 析构函数
	~Phone()
	{
		cout << "Phone 析构函数的调用" << endl;
	}
	string m_PName;
};


class Person
{
public:
	// 构造函数
	// m_Phone(pName) == 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 test01()
{
	Person p("三上悠亚", "iPhone 13 Pro Max");
	cout  << p.m_Name << " 拿着 " << p.m_Phone.m_PName << " 在拍电影!!!" << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

总结：当其他类对象作为本类成员，构造时先构造类对象，在构造本身，析构的顺序与构造相反

8、静态成员

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

静态成员分为：

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

(1) 静态成员变量

示例：

#include <iostream>
using namespace std;

// 静态成员变量
// 1. 所有对象都共享一份数据
// 2. 在编译阶段分配内存
// 3. 类内声明，类外初始化
class Person
{
public:
	static int m_A;
private:
	static int m_B; // 静态成员变量也是有访问权限的
};
int Person::m_A = 100;
int Person::m_B = 200;

void test01()
{
	Person p1;
	cout  << p1.m_A << endl; // 100

	Person p2;
	p2.m_A = 200;

	cout << p1.m_A << endl;	// 200
}

void test02()
{
	// 静态成员变量，不属于某个对象上，所有对象都共享同一份数据
	// 因此静态成员变量有两种访问方式
	// 1、通过对象进行访问
	Person p;
	cout << p.m_A << endl; // 100
	// 2、通过类名进行访问
	cout << Person::m_A << endl; // 100
	// cout << Person::m_B << endl; // 类外访问不到私有静态成员变量
}
int main()
{
	// test01();
	test02();
	system("pause");
	return 0;
}

(2) 静态成员函数

示例：

#include <iostream>
using namespace std;

// 静态成员函数
// 1. 所有对象共享同一个函数
// 2. 静态成员函数只能访问静态成员变量
class Person
{
public:
	// 静态成员函数
	static void func()
	{
        cout << "static void func 的调用" << endl;
		// 静态成员函数 可以访问 静态成员变量
		m_A = 100;
		// 静态成员函数 不可以访问 非静态成员变量, 无法区分到底是哪个对象的 m_B
		// m_B = 200; 
	}
	// 静态成员变量
	static int m_A;
	int m_B;
private:
	// 静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "static void func2 的调用" << endl;
	}
};

int Person::m_A = 0;

void test01()
{
	// 通过对象进行访问
	Person p;
	p.func();
	// 通过类名进行访问
	Person::func();
	// 类外访问不到私有静态成员函数
	// Person::func2();

}
int main()
{
	test01();
	system("pause");
	return 0;
}

三、C++ 对象模型和 this 指针

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

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

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

示例：

#include <iostream>
using namespace std;

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

class Person
{
public:
	// 构造函数
	Person()
	{
		m_A = 0;
	}
	// 非静态成员变量占对象空间
	int m_A;
	// 静态成员变量不占对象空间
	static int m_B;
	// 函数也不占对象空间，所有函数共享一个函数实例
	void func()
	{
		cout << "m_A: " << this->m_A << endl;
		cout << "m_B: " << this->m_B << endl;
	}
	static void func2()
	{
		
	}
};

int Person::m_B = 0;

void test01()
{
	/*
		class Person
		{
		public:
	
		};
	*/
	Person p;
	// 空对象占用内存空间为: 1
	// 因为 C++ 编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	// 每个空对象也应该有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl; // 1
}

void test02()
{
	/*
		class Person
		{
		public:
			// 非静态成员变量占对象空间
			int m_A;
		};
	*/
	Person p;
	cout << "size of p = " << sizeof(p) << endl; // 4
}

void test03()
{
	/*
		class Person
		{
		public:
			// 非静态成员变量占对象空间
			int m_A;
			// 静态成员变量不占对象空间
			static int m_B;
		};
		int Person::m_B = 0;
	*/
	Person p;
	cout << "size of p = " << sizeof(p) << endl; // 4
}

void test04()
{
	/*
		class Person
		{
		public:
			// 非静态成员变量占对象空间
			int m_A;
			// 静态成员变量不占对象空间
			static int m_B;
			// 函数也不占对象空间，所有函数共享一个函数实例
			void func()
			{
				cout << "m_A: " << this->m_A << endl;
				cout << "m_B: " << this->m_B << endl;
			}
		};
		int Person::m_B = 0;
	*/
	Person p;
	cout << "size of p = " << sizeof(p) << endl; // 4
}

void test05()
{
	/*
		class Person
		{
		public:
			// 非静态成员变量占对象空间
			int m_A;
			// 静态成员变量不占对象空间
			static int m_B;
			// 函数也不占对象空间，所有函数共享一个函数实例
			void func() { }
			static void func2() { }
		};
		int Person::m_B = 0;
	*/
	Person p;
	cout << "size of p = " << sizeof(p) << endl; // 4
}

int main()
{
	// test01();
	test02();
	system("pause");
	return 0;
}

2、this 指针的概念

通过上边的案例 我们知道 C++ 中成员变量和成员函数是分开存储的

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

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

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

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

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

this 指针的用途：

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

示例：

#include <iostream>
using namespace std;

class Person
{
public:
	// 构造函数
	Person(int age)
	{
		// this 指针指向的是： this 指针指向被调用的成员函数所属的对象
		this->age = age;
	}
	// 必须以引用的方式返回 引用不会创建新的对象 返回值会创建新的对象
	Person& PersonAddAge(Person& p)
	{
		// this 指针指向p2的指针： 而 *this 指针指向的就是 p2 这个对象本体
		this->age += p.age;
		return *this;
	}
	int age;

};
// 1、解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1 的年龄为：" << p1.age << endl;
}

// 2、返回对象本身 return *this
void test02()
{
	Person p1(10);
	Person p2(10);
	// 链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2 的年龄为：" << p2.age << endl;
}

int main()
{
	// test01();
	test02();
	system("pause");
	return 0;
}

3、空指针访问成员函数

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

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

示例：

#include <iostream>
using namespace std;

// 空指针访问成员函数
class Person
{
public:
	void showClassName() 
	{
		cout << "我是 Person 类" << endl;
	}

	void showPerson() 
	{
		// cout << "age = " << m_Age << endl; // 报错原因是因为传入的指针为 NULL 
		if (this == NULL) 
		{
			return;
		}
		cout << "age = " << m_Age << endl;
	}
	int m_Age;
};

void test01()
{
	// 创建一个空指针
	Person* p = NULL;
	p->showClassName();
	p->showPerson();
}

int main()
{
	test01();
	system("pause");
	return 0;
}

4、const 修饰成员函数

常函数：

• 成员函数后加 const 后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字 mutable 后，在常函数中依然可以修改

常对象：

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

示例：

#include <iostream>
using namespace std;

// 常函数
class Person
{
public:
	// this指针的本质是指针常量，指针的指向是不可以修改的
	// const Person* const this;
	// 在成员函数后面加上 const，修饰的是this指向，让指针指向的值也不可能修改
	void showPerson() const
	{
		// this = NULL; // this 指针不可以修改指针的指向的
		// this->m_A = 100;
		this->m_B = 100;
	}

	void func()
	{
	}
	int m_A;
	mutable int m_B; // 特殊变量，即使在常函数中，也可以修改这个值，加关键字 mutable
};

void test01()
{
	Person p;
	p.showPerson();
}

// 常对象
void test02()
{
	const Person p;
	// p.m_A = 100;
	p.m_B = 100; // m_B是特殊值，在常对象下也可以修改
	// 常对象只能调用常函数
	p.showPerson();
	// p.func(); // 常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
}

int main()
{
	// test01()
	test02();
	system("pause");
	return 0;
}

四、友元

生活中你的家有客厅(Public)，有你的卧室(Private)

客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去

但是呢，你也可以允许你的好闺蜜好基友进去

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

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

友元的关键字：friend

友元的三种实现方式

• 全局函数做友元
• 类做友元
• 成员函数做友元

1、全局函数做友元

示例：

#include <iostream>
using namespace std;

// 房屋类
class Building
{
	// 告诉编译器 goodGay 全局函数是 Building好朋友，可以访问 Building 中的私有成员
	friend void goodGay(Building* building);
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

// 全局函数
void goodGay(Building* building)
{
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友全局函数 正在访问：" << building->m_BedRoom << endl;
}

void test01() 
{
	Building building;
	goodGay(&building);
}
int main()
{
	test01();

	system("pause");
	return 0;
}

2、类做友元

示例：

#include <iostream>
using namespace std;

// 类做友元
class Building;

class GoodGay
{
	
public:
	GoodGay();
	void visit(); // 参观函数访问 Building 中的属性
	Building* building;
};

class Building
{
	// GoodGay 类是本类的好朋友，可以访问本类中的私有成员
	friend class GoodGay;
public:
	Building();
public:
	string m_SittingRoot; // 客厅
private:
	string m_BedRoom;	// 卧室
};

//类外实现成员函数
Building::Building()
{
	m_SittingRoot = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	building = new Building;
}
void GoodGay::visit()
{
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoot << endl;
	cout << "好基友全局函数 正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
	GoodGay gg;
	gg.visit();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3、成员函数做友元

示例：

#include <iostream>
using namespace std;

// 成员函数做友元
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();
public:
	string m_SittingRoot; // 客厅
private:
	string m_BedRoom;	// 卧室
};

//类外实现成员函数
Building::Building()
{
	m_SittingRoot = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	building = new Building;
}
void GoodGay::visit()
{
	cout << "visit 函数 正在访问：" << building->m_SittingRoot << endl;
	cout << "visit 函数 正在访问：" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
	cout << "visit2 函数 正在访问：" << building->m_SittingRoot << endl;
	// cout << "visit2 函数 正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
	GoodGay gg;
	gg.visit();
	gg.visit2();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

五、运算符重载

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

1、加号运算符重载

作用：实现两个自定义数据类型相加的运算

示例：

#include <iostream>
using namespace std;

// 加号运算符重载
class Person
{
public:
	// 1、成员函数重载 + 
	/*Person operator+(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}*/
	int m_A;
	int m_B;

};

// 2、全局函数重载 +
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
// 2、全局函数重载 +
Person operator+(Person& p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;

	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	// 成员函数本质调用：Person p3 = p1.operator+(p2);
	Person p3 = p1 + p2;
	// 全局函数本质调用：Person p3 = operator+(p1, p2);
	cout << "p3.m_A = " << p3.m_A << " p3.m_B = " << p3.m_B << endl;
	// 运算符重载 也可以发生函数重载
	Person p4 = p1 + 100;
	// 全局函数本质调用：Person p3 = operator+(p1, 10);
	cout << "p4.m_A = " << p4.m_A << " p4.m_B = " << p3.m_B << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

总结

• 对于内置的数据类型的表达式的运算符是不可能改变的
• 不要滥用运算符重载

2、左移运算符重载

作用：可以输出自定义类型数据

示例：

#include <iostream>
using namespace std;

// 左移运算符重载
class Person
{
	friend ostream& operator<<(ostream& out, Person& p);
public:
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	/*
	成员函数 无法实现 p << cout 不是我们想要的效果
	void operator<<(Person& p)
	{
	}
	*/
private:
	int m_A;
	int m_B;
};

// 全局定义左移运算符重载
ostream& operator<<(ostream& out, Person& p)
{
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	return cout;
}

// 测试函数
void test01()
{
	Person p(10, 20);
	cout << p << endl;
}

// 程序入口函数
int main()
{
	test01();
	system("pause");
	return 0;
}

重载左运算符配合友元可以实现输出自定义数据类型

3、递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

示例：

#include <iostream>
using namespace std;

// 递增运算符重载
class MyInteger
{
	friend ostream& operator<<(ostream& out, MyInteger myint);
public:
	MyInteger()
	{
		this->m_Num = 0;
	}
	// 前置++
	MyInteger& operator++()
	{
		// 先++
		m_Num++;
		// 再返回
		return *this;
	}

	// 后置++ // operator++(int) int 代表占位参数可以用于区分前置和后置
	MyInteger operator++(int)
	{
		// 先记录当时的结果
		MyInteger temp = *this;
		// 再++
		m_Num++;
		// 再返回
		return temp;
	}

private:
	int m_Num;
};

// 全局定义左移运算符重载
ostream& operator<<(ostream& out,  MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}

// 测试函数
void test01()
{
	MyInteger myint;
	cout << ++myint << endl;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}

void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << (myint++)++ << endl;
	cout << myint << endl;
}
// 程序入口函数
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：前置递增返回引用，后置递增返回值

4、赋值运算符重载

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

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符 operator=，对属性值拷贝

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

示例：

#include <iostream>
using namespace std;

// 赋值运算符重载
class Person
{
public:
	Person(int age)
	{
		m_Age = new int(age);
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	Person& operator=(Person& p)
	{
		// 编译器默认提供赋值运算是浅拷贝
		// 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 test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);
	p3 = p2 = p1; // 赋值运算
	cout << "p1 的年龄为：" << *p1.m_Age << endl;
	cout << "p2 的年龄为：" << *p2.m_Age << endl;
	cout << "p3 的年龄为：" << *p3.m_Age << endl;
}

// 程序入口函数
int main()
{
	test01();
	system("pause");
	return 0;
}

5、关系运算符重载

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

示例：

#include <iostream>
using namespace std;

// 关系运算符重载
class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}
	// 1、等于 关系运算符重载
	bool operator==(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		return false;
	}
	// 2、不等于 关系运算符重载
	bool operator!=(Person& p)
	{
		if (this->m_Name != p.m_Name || this->m_Age != p.m_Age)
		{
			return true;
		}
		return false;
	}
	// 3、大于 关系运算符重载
	bool operator>(Person& p)
	{
		if (this->m_Age > p.m_Age)
		{
			return true;
		}
		return false;
	}
	// 4、小于 关系运算符重载
	bool operator<(Person& p)
	{
		if (this->m_Age < p.m_Age)
		{
			return true;
		}
		return false;
	}
	string m_Name;
	int m_Age;
};


// 测试函数
void test01()
{
	Person p1("三上悠亚", 18);
	Person p2("三上悠亚", 18);
	Person p3("桥本有菜", 22);
	
	cout << "p1 == p2：" << (p1 == p2) << endl;
	cout << "p1 != p2：" << (p1 != p2) << endl;
	cout << "p2 < p3：" << (p2 < p3) << endl;
}

// 程序入口函数
int main()
{
	test01();
	system("pause");
	return 0;
}

6、函数调用运算符重载

• 函数调用运算符() 也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为防函数
• 仿函数没有固定写法，非常灵活

示例：

#include <iostream>
using namespace std;

// 函数调用运算符重载
// 打印类
class Print
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}
};

// 打印方法
void printFunc(string text)
{
	cout << text << endl;
}

// 加法类
class Add
{
public:
	int operator()(int a, int b)
	{
		return a + b;
	}
};

// 加法函数
int addFunc(int a, int b)
{
	return a + b;
}

void test01()
{
	// 重载的 () 操作符也成为了仿函数
	Print print;
	print("Hello World"); // 由于重载后使用的方式非常像函数的调用，因此称为防函数
	printFunc("Hello World");

	// 加法类
	Add add;
	cout << "10 + 10 = " << add(10, 10) << endl;
	cout << "20 + 20 = " << addFunc(10, 10) << endl;

	// 匿名函数对象
	Print()("Hello World");
	cout << "100 + 100 = " << Add()(100, 100) << endl;
}

// 程序入口函数
int main()
{
	test01();
	system("pause");
	return 0;
}

六、继承

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

有些类与类之间存在特殊关系，例如下图

我们发现，定义这些类时，下级别的乘体验除了拥有上级的共性，还有自己的特性

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

1、继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同，接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

(1) 普通实现

#include <iostream>
using namespace std;

// 普通实现页面
// Java页面
class JavaPage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void menu()
	{
		cout << "Java、Python、C/C++...（公共导航）" << endl;
	}
	void content()
	{
		cout << "Java 学科视频" << endl;
	}
};

// Python 页面
class PythonPage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void menu()
	{
		cout << "Java、Python、C/C++...（公共导航）" << endl;
	}
	void content()
	{
		cout << "Python 学科视频" << endl;
	}
};

// C++ 页面
class CppPage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void menu()
	{
		cout << "Java、Python、C/C++...（公共导航）" << endl;
	}
	void content()
	{
		cout << "C++ 学科视频" << endl;
	}
};


void testJava() {
	cout << "Java 页面下载视频页面如下: " << endl;
	JavaPage jp;
	jp.header();
	jp.footer();
	jp.menu();
	jp.content();
}


void testPython() {
	cout << "Python 页面下载视频页面如下: " << endl;
	PythonPage pp;
	pp.header();
	pp.footer();
	pp.menu();
	pp.content();
}


void testCpp() {
	cout << "C++ 页面下载视频页面如下: " << endl;
	CppPage cp;
	cp.header();
	cp.footer();
	cp.menu();
	cp.content();
}


// 程序入口函数
int main()
{

	testJava();
	cout << "----------------------------------------" << endl;
	testPython();
	cout << "----------------------------------------" << endl;
	testCpp();

	system("pause");
	return 0;
}

(2) 继承实现

优点：减少重复代码

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

子类也称为：派生类

父类也称为：基类

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

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

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

#include <iostream>
using namespace std;

// 继承实现页面
// 公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void menu()
	{
		cout << "Java、Python、C/C++...（公共导航）" << endl;
	}
};

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

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

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


void testJava() {
	cout << "Java 页面下载视频页面如下: " << endl;
	JavaPage jp;
	jp.header();
	jp.footer();
	jp.menu();
	jp.content();
}


void testPython() {
	cout << "Python 页面下载视频页面如下: " << endl;
	PythonPage pp;
	pp.header();
	pp.footer();
	pp.menu();
	pp.content();
}


void testCpp() {
	cout << "C++ 页面下载视频页面如下: " << endl;
	CppPage cp;
	cp.header();
	cp.footer();
	cp.menu();
	cp.content();
}


// 程序入口函数
int main()
{

	testJava();
	cout << "----------------------------------------" << endl;
	testPython();
	cout << "----------------------------------------" << endl;
	testCpp();

	system("pause");
	return 0;
}

2、继承方式

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

继承的方式一共有三种：

• 公共继承

• 保护继承

• 私有继承

示例：

#include <iostream>
using namespace std;

// 继承方式
// 基类
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

// 公共继承
class Son1 :public Base
{
public:
	void func()
	{
		cout << "公共继承" << endl;
		m_A = 10; // 父类中的公共权限成员 到子类中依然是公共权限
		m_B = 10; // 父类中的保护权限成员 到子类中依然是保护权限
		// m_C = 10; // 父类中的私有权限成员 到子类中不可以访问
	}
};

// 保护继承
class Son2 : protected Base
{
public:
	void func()
	{
		cout << "保护继承" << endl;
		m_A = 10; // 父类中的公共权限成员 到子类中变为保护成员
		m_B = 10; // 父类中的保护权限成员 到子类中依然是保护权限
		// m_C = 10; // 父类中的私有权限成员 到子类中不可以访问
	}
};

// 私有继承
class Son3 : private Base
{
public:
	void content()
	{
		cout << "私有继承" << endl;
		m_A = 100; // 父类中的公共权限成员 到子类中变为私有成员
		m_B = 100; // 父类中的保护权限成员 到子类中变为私有权限
		// m_C = 10; // 父类中的私有权限成员 到子类中不可以访问
	}
};

// 孙子继承
class GrandSon3 : public Son3
{
public:
	void func()
	{
		// m_A = 1000; // 到了Son3中 m_A 变为私有权限 类外访问不到
		// m_B = 1000; // 到了Son3中 m_b 变为私有权限 类外访问不到
	}
};


void testSon1() {
	Son1 s1;
	s1.m_A = 100;
	// s1.m_B = 100; // 到了Son1中 m_B 是保护权限 类外访问不到
}

void testSon2() {
	Son2 s2;
	// s2.m_A = 100; // 到了Son2中 m_A 变为保护权限 类外访问不到
	// s1.m_B = 100; // 到了Son2中 m_B 是保护权限 类外访问不到
}

void testSon3() {
	Son3 s3;
	// s3.m_A = 100; // 到了Son3中 m_A 变为私有权限 类外访问不到
	// s3.m_B = 100; // 到了Son3中 m_B 变为私有权限 类外访问不到
}

// 程序入口函数
int main()
{

	testSon1();
	testSon2();
	testSon3();

	system("pause");
	return 0;
}

3、继承中的对象模型

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

示例：

#include <iostream>
using namespace std;


// 继承中的对象模型
// 基类
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; // 私有成员只是被隐藏了，但是还是会继承下去
};

// 公共继承
// 利用开发人员命令提示工具查看对象模型：cl /d1 reportSingleClassLayout类名 文件名
class Son :public Base
{
public:
	int m_D;
};

// 测试函数
void test01() {
	// 父类中所有非静态成员属性都会被子类继承下去
	cout << "size of Son = " << sizeof(Son) << endl;
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

查看对象模型:

• 利用开发人员命令提示工具查看对象模型：cl /d1 reportSingleClassLayout类名 文件名

结论：父类中私有成员也是被子类继承下去了，只是编译器给隐藏后访问不到

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

// 测试函数
void test01() {
    // 继承中的构造和析构顺序如下：
    // 先构造父类，在构造子类，析构的顺序与构造的顺序相反
	Son s;
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：继承中先调用父类构造函数，在调用子类构造函数，析构顺序与构造相反

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

// 测试函数
void test01() {
	Son s;
	// 1. 同名成员属性处理
	cout << "Son m_A = " << s.m_A << endl;
	// 如果通过子类对象 访问到父类中同名成员，需要加作用域
	cout << "Base m_A = " << s.Base::m_A << endl;

	// 2. 同名成员函数处理
	s.func();
	s.Base::func();
	
	// 3. 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数, 如果想访问则必须添加作用域
	// s.func(10);
	s.Base::func(10);
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

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

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

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

• 问子类同名成员直接访问即可
• 访问父类同名成员需要加作用域

示例：

#include <iostream>
using namespace std;

// 继承同名静态成员处理方式
// 基类
class Base
{
public:
	static void func()
	{
		cout << "Base - func() 调用" << endl;
	}
	static void func(int a)
	{
		cout << "Base - func(int a) 调用" << endl;
	}
	static int m_A;
};

int Base::m_A = 100;

// 公共继承
class Son :public Base
{
public:
	static void func()
	{
		cout << "Son - func() 调用" << endl;
	}
	static int m_A;
};
int Son::m_A = 200;


// 测试函数
void test01() {
	Son s;
	// 1. 同名成员静态属性处理
	// 1.1 通过对象访问
	cout << "通过对象访问静态属性: " << endl;
	cout << "Son m_A = " << s.m_A << endl;
	cout << "Base m_A = " << s.Base::m_A << endl;

	// 1.2 通过类名访问
	cout << "通过类名访问静态属性: " << endl;
	cout << "Son m_A = " << Son::m_A << endl;
	cout << "Base m_A = " << Son::Base::m_A << endl; // 第一个双冒号 代表通过类名的当时访问，第二个双冒号 代表访问父类作用域下

	// 2. 同名成员静态函数处理
	// 2.1 通过对象访问
	cout << "通过对象访问静态函数: " << endl;
	s.func();
	s.Base::func();
	s.Base::func(10); // 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数, 如果想访问则必须添加作用域

	// 2.2 通过类名访问
	cout << "通过类名访问静态函数: " << endl;
	Son::func();
	Son::Base::func();
	Son::Base::func(10); // 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数, 如果想访问则必须添加作用域
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

7、多继承语法

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

语法：c1ass 子类 ：继承方式 父类1，继承方式 父类2...

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

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

示例：

#include <iostream>
using namespace std;

// 继承同名静态成员处理方式
// 基类1
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};

// 基类2
class Base2
{
public:
	Base2()
	{
		m_A = 200;
	}
	int m_A;
};

// 公共继承
class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};


// 测试函数
void test01() {
	Son s;
	cout << "size of Son = " << sizeof(s) << endl;
	// 当父类出现同名的成员，需要加作用域区分
	cout << "Base1::m_A = " << s.Base1::m_A << endl;
	cout << "Base2::m_A = " << s.Base2::m_A << endl;
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：多继承中如果父中出现了同名情况，子类使用时候要加作用域

8、菱形继承

菱形继承概念：

• 两个派生类继承同一个基类
• 又有某个类同时继承者两个派生类
• 这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

菱形继承问题：

1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

示例：

#include <iostream>
using namespace std;

// 继承同名静态成员处理方式
// 动物类
class Animal
{
public:
	int m_Age;
};
// 利用虚继承 解决菱形继承的问题, 在继承之前加上 virtual 变成虚继承 Animal类就称为 虚基类
// 羊类
class Sheep : virtual public Animal {};

// 骆驼类
class Camel : virtual public Animal {};

// 羊驼类
class Alpaca : public Sheep, public Camel {};


// 测试函数
void test01() {
	Alpaca alpaca;
	
	// 当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	alpaca.Sheep::m_Age = 18;
	alpaca.Camel::m_Age = 28;
	cout << "alpaca.Sheep::m_Age = " << alpaca.Sheep::m_Age << endl;
	cout << "alpaca.Camel::m_Age = " << alpaca.Camel::m_Age << endl;
	cout << "alpaca.m_Age = " << alpaca.m_Age << endl;

	// 这份数据我们知道，只需要一份即可，菱形继承导致了数据有两份，导致了资源浪费

}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

• 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
• 利用虚继承可以解决菱形继承问题

七、多态

1、多态的基本概念

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

多态分为两类：

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

静态多态和动态多态区别：

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

下面通过案例进行讲解多态

#include <iostream>
using namespace std;

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

// 猫类
class Cat : public Animal {
	// 重写 函数返回值类型 函数名 参数列表 完全相同  virtual 关键字可写可不写
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

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


// 执行说话的函数
// 地址早绑定 在编译阶段确定函数地址
// 如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要再运行阶段进行绑定，地址玩绑定

// 动态多态满足条件
// 1. 有继承关系
// 2. 子类重写父类的虚函数

// 动态多态使用
// 1. 父类的指针或引用 指向子类对象
void doSpeak(Animal& animal) // Animal& animal = cat;
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

• 多态满足条件
  • 有继承关系
  • 子类重写父类中的虚函数
• 多态使用条件
  • 父类指针或引用指向子类对象
• 重写：函数 返回值 类型 函数名 参数列表 完全一致称为重写

2、多态案例一 - 计算器类

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

多态的优点：

• 代码组织结构清晰
• 可读性强
• 利于前期和后期的扩展以及维护

(1) 普通实现

#include <iostream>
using namespace std;

// 普通实现
class Calculator
{
public:
	// 虚函数
	int getResult(string oper)
	{
		if (oper == "+")
		{
			return m_Num1 + m_Num2;
		}
		else if (oper == "-")
		{
			return m_Num1 - m_Num2;
		}
		else if (oper == "*")
		{
			return m_Num1 * m_Num2;
		}
		// 如果想扩展新的功能，需要修改源码
        // 在真实开发中 提倡 开闭原则
        // 开闭原则: 对扩展进行开放，对修改进行修改
	}
	int m_Num1;
	int m_Num2;
};

void test01()
{
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;
	cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;
	cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

(2) 多态实现

#include <iostream>
using namespace std;

// 利用多态实现计算器
// 1. 实现计算器的基类(抽象类)
class AbstractCalculator 
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};

// 2. 实现加法计算器类
class AddCalculator : public AbstractCalculator
{
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
};

// 3. 实现减法计算器类
class SubCalculator : public AbstractCalculator
{
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};

// 4. 实现乘法计算器类
class MulCalculator : public AbstractCalculator
{
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};

// 5. 现实除法计算器类 ...

void test01()
{
	// 加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	// 用完后记得销毁
	delete abc;

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

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


// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

3、纯虚函数和抽象类

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

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

纯虚函数语法：virtual 返回值类型 函数名(参数列表) = 0;

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

抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

#include <iostream>
using namespace std;

// 纯虚函数和抽象类
class Base
{
public:
	/*
	纯虚函数：
	只要有一个纯虚函数，这个类称为抽象类
	抽象类特点：
		1. 无法实例化对象
		2. 抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
	*/
	virtual void func() = 0;
};

class Son : public Base
{
public:
	void func()
	{
		cout << "func 函数调用" << endl;
	}
};

void test01()
{
	// Base b; // 抽象类无法实例化对象
	// new Base; // 抽象类无法实例化对象

	// Son s; // 抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
	Base* b = new Son;
	b->func();
	delete b;
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

4、多态案例二 - 制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作加啡和茶叶

示例：

#include <iostream>
using namespace std;

// 抽象饮品基类
class AbstractDrink
{
public:
	// 煮水函数
	virtual void boilWater() = 0;
	// 冲泡函数
	virtual void brew() = 0;
	// 装杯函数
	virtual void cup() = 0;
	// 加入辅料
	virtual void putSomething() = 0;
	// 制作饮品
	void makeDrink()
	{
		boilWater();
		brew();
		cup();
		putSomething();
	}
};

// 冲咖啡
class Coffee : public AbstractDrink
{
public:
	// 煮水函数
	void boilWater()
	{
		cout << "煮水" << endl;
	}
	// 冲泡函数
	void brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	// 装杯函数
	void cup() 
	{
		cout << "倒入杯中" << endl;
	}
	// 加入辅料
	void putSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}
};

// 冲茶叶
class Tea : public AbstractDrink
{
public:
	// 煮水函数
	void boilWater()
	{
		cout << "煮水矿泉水" << endl;
	}
	// 冲泡函数
	void brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	// 装杯函数
	void cup()
	{
		cout << "倒入杯中" << endl;
	}
	// 加入辅料
	void putSomething()
	{
		cout << "加入枸杞" << endl;
	}
};


// 制作函数
void doWork(AbstractDrink* abs)
{
	abs->makeDrink();
	delete abs; // 释放
}

// 测试函数
void test01()
{
	
	// 制作咖啡
	doWork(new Coffee);
	cout << "--------------------------------------" << endl;
	// 制作茶水
	doWork(new Tea);
}


// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

5、虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

虚析构和纯虚析构区别：

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

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

示例

#include <iostream>
using namespace std;


// 虚析构和纯虚析构
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;
};

// 测试函数
void test01()
{
	Animal* animal = new Cat("憨憨");
	animal->speak();
	// 父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏
	delete animal;
}


// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类

6、多态案例三 - 电脑组装

案例描述：

电脑主要组成部件为CPU(用于计算)，显卡（用于显示），内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo.厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

示例：

#include <iostream>
using namespace std;


// 抽象的CPU类
class CPU
{
public:
	// 抽象计算函数
	virtual void calculate() = 0;
};

// 抽象的显卡类
class GPU
{
public:
	// 抽象显示函数
	virtual void display() = 0;
};

// 抽象的内存类
class Memory
{
public:
	// 抽象存储函数
	virtual void storage() = 0;
};

// 计算机类
class Computer
{
public:
	// 构造函数
	Computer(CPU* cpu, GPU* gpu, Memory* memory)
	{
		m_Cpu = cpu;
		m_Gpu = gpu;
		m_Memory = memory;
	}
	// 工作函数
	void work() 
	{
		// 调用每个零件工作的接口
		m_Cpu->calculate();
		m_Gpu->display();
		m_Memory->storage();
	}
	~Computer()
	{
		if (m_Cpu != NULL)
		{
			delete m_Cpu;
			m_Cpu = NULL;
		}
		if (m_Gpu != NULL)
		{
			delete m_Gpu;
			m_Gpu = NULL;
		}
		if (m_Memory != NULL)
		{
			delete m_Memory;
			m_Memory = NULL;
		}
	}
	CPU* m_Cpu;
	GPU* m_Gpu;
	Memory* m_Memory;
};

// Inter 厂商
class InterCPU : public CPU
{
public:
	// 计算函数
	void calculate()
	{
		cout << "Inter CPU 开始计算了..." << endl;
	}
};

class InterGPU : public GPU
{
public:
	// 显示函数
	void display()
	{
		cout << "Inter GPU 开始显示了..." << endl;
	}
};

class InterMemory : public Memory
{
public:
	// 存储函数
	void storage()
	{
		cout << "Inter 内存 开始存储了..." << endl;
	}
};

// AMD 厂商
class AmdCPU : public CPU
{
public:
	// 计算函数
	void calculate()
	{
		cout << "AMD CPU 开始计算了..." << endl;
	}
};

class AmdGPU : public GPU
{
public:
	// 显示函数
	void display()
	{
		cout << "AMD GPU 开始显示了..." << endl;
	}
};

class AmdMemory : public Memory
{
public:
	// 存储函数
	void storage()
	{
		cout << "AMD 内存 开始存储了..." << endl;
	}
};


// 测试函数
void test01()
{
	// 1. Inter 全家桶
	cout << "Inter 全家桶: " << endl;
	CPU* cpu = new InterCPU;
	GPU* gpu = new InterGPU;
	Memory* memory = new InterMemory;
	Computer* c = new Computer(cpu, gpu, memory);
	c->work();
	delete c;

	// 2. AMD 全家桶

	cout << "\nAMD 全家桶: " << endl;
	cpu = new AmdCPU;
	gpu = new AmdGPU;
	memory = new AmdMemory;
	c = new Computer(cpu, gpu, memory);
	c->work();
	delete c;

	// 2. Inter & AMD
	cout << "\nInter & AMD: " << endl;
	cpu = new InterCPU;
	gpu = new AmdGPU;
	memory = new AmdMemory;
	c = new Computer(cpu, gpu, memory);
	c->work();
	delete c;
}


// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

第五章 文件操作

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

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

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

文件类型分为两种：

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

操作文件的三大类：

1. ofstream: 写操作
2. ifstream: 读操作
3. fstream: 读写操作

一、文本文件

1、写文件

写文件步骤如下：

1. 包含头文件

   #include <fstream>
   

2. 创建流对象

   ofstream ofs;
   

3. 打开文件

   ofs.open("文件路径", 打开方式);
   

4. 写数据

   ofs << "写入的数据";
   

5. 关闭文件

   ofs.close();
   

文件打开方式：

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果创建文件存在先删除，再创建
ios::binary	二进制方式

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

例如：用二进制方式写文件 ios:binary | ios::out

示例：

#include <iostream>
using namespace std;

#include <fstream> // 头文件包含

// 文本写文件
void test01()
{
	// 1. 包含头文件 fstream

	// 2. 创建流对象
	ofstream ofs;
	// 3. 打开文件
	ofs.open("test.txt", ios::out);
	// 4. 写数据
	ofs << "姓名：三上悠亚" << endl;
	ofs << "年龄：22" << endl;
	ofs << "性别：女" << endl;
	// 5. 关闭文件
	ofs.close();
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

• 文件操作必须包含头文件 fstream
• 读文件可以利用 ofstream, 或者 fstream类
• 打开文件时候需要指定操作文件的路径，以及打开方式
• 利用 << 可以向文件中写数据
• 操作完毕，要关闭文件

2、读文件

读文件与写文件步骤相似，但是读取方式相对于比较多

读文件步如下：

1. 包含头文件

   #include <fstream>
   

2. 创建流对象

   ifstream ifs;
   

3. 打开文件并判断文件是否打开成功

   ifs.open("文件路径"打开方式)：
   

4. 读数据

   四种方式读取

5. 关闭文件

   ifs.close();
   

示例：

#include <iostream>
#include <string> // 解决 全局 getline 报错
#include <fstream> // 头文件包含
using namespace std;


// 文本读文件
void test01()
{
	// 1. 包含头文件 fstream

	// 2. 创建流对象
	ifstream ifs;
	// 3. 打开文件 并且判断文件是否打开成功
	ifs.open("test.txt", ios::in);
	// 4. 读取数据
	if (!ifs.is_open())
	{
		cout << "文件打开失败!!!" << endl;
		return;
	}
	// 方式一：
	char buf[1024] = { 0 };
	while (ifs >> buf)
	{
		cout << buf << endl;
	}

	// 方式二：
	/*
	char buf[1024] = { 0 };
	while (ifs.getline(buf, sizeof(buf)))
	{
		cout << buf << endl;
	}
	*/

	// 方式三：
	/*
	string buf;
	while (getline(ifs, buf))
	{
		cout << buf << endl;
	}
	*/

	// 方式四：
	/*
	char c;
	while ((c = ifs.get()) != EOF)
	{
		cout << c;
	}
	*/
	
	// 5. 关闭文件
	ifs.close();
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

• 读文件可以利用 ifstream, 或者 fstream类
• 利用 is_open函数 可以判断文件是否打开成功
• close关闭文件

二、二进制文件

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

打开方式要指定为 ios:binary

1、写文件

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

函数原型：ostreame& write(const char* buffer,int len);

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

示例：

#include <iostream>
// #include <string> // 解决 全局 getline 报错
#include <fstream> // 头文件包含
using namespace std;


// 二进制写文件
class Person
{
public:
	char m_Name[64];
	int m_Age;
};

void test01()
{
	// 1. 包含头文件 fstream

	// 2. 创建流对象
	ofstream ofs("person.txt", ios::out | ios::binary);
	// 3. 打开文件
	// ofs.open("test.txt", ios::out | ios::binary);
	// 4. 写文件
	Person p = { "三上悠亚", 22 };
	ofs.write((const char*)& p, sizeof(Person));
	// 5. 关闭文件
	ofs.close();
}

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

• 文件输出流对象可以通过write函数，以二进制方式写数据

2、读文件

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

函数原型：istream& read(char* buffer, int len);

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

示例：

#include <iostream>
// #include <string> // 解决 全局 getline 报错
#include <fstream> // 头文件包含
using namespace std;


// 二进制读文件
class Person
{
public:
	char m_Name[64];
	int m_Age;
};

void test01()
{
	// 1. 包含头文件 fstream

	// 2. 创建流对象
	ifstream ifs;
	// 3. 打开文件 判断文件是否打开成功
	ifs.open("person.txt", ios::in | ios::binary);
	if (!ifs.is_open())
	{
		cout << "文件打开失败!!!" << endl;
		return;
	}
	// 4. 读文件
	Person p;
	ifs.read((char*)&p, sizeof(Person));
	cout << "姓名为: " << p.m_Name << " 年龄为: " << p.m_Age << endl;

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

// 程序入口函数
int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

• 文件输入流对象可以通过read函数，以二进制方式读数据

实战案例 - 职工管理系统

一、管理系统需求

职工管理系统可以用来管理公司内所有员工的信息

本教程主要利用C++来实现一个基于多态的职工管理系统

公司中职工分为三类：普通员工、经理、老板，显示信息时，需要显示职工编号、职工姓名、职工岗位、以及职责

• 普通员工职责：完成经理交给的任务
• 经理职责：完成老板交给的任务，并下发任务给员工
• 老板职责：管理公司所有事务

管理系统中需要实现的功能款如下：

• 退出管理程序：退出当前管理系统
• 增加职工信息：实现批量添加职工功能，将信息录入到文件中，职工信息为：职工编号、姓名、部门编号
• 显示职工信息：显示公司内部所有职工的信息
• 删除离职职工：按照编号删除指定的职工
• 修改职工信息：按照编号修改职工个人信息
• 查找职工信息：按照职工的编号或者职工的姓名进行查找相关的人员信息
• 按照编号排序：按照职工编号，进行排序，排序规则由用户指定
• 清空所有文档：清空文件中记录的所有职工信息（清空前需要再次确认，防止误删）

二、创建项目

• 创建项目

  

• 添加文件

  

三、创建管理类

管理类负责的内容如下：

• 与用户的沟通菜单界面
• 对职工增删改查的操作
• 与文件的读写交互

1、创建源文件

在头文件和源字件的文件夹下分别创建 workerManager.h 和 workerManager.cpp 文件

2、头文件实现

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

// 管理类
class WorkerManager
{
public:
	// 构造函数
	WorkerManager();

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

3、源文件实现

在 workerManager.cpp 中将构造和析构函数空实现补全

#include "workerManager.h"

WorkerManager::WorkerManager()
{

}

WorkerManager::~WorkerManager()
{

}

四、菜单功能

功能描述：与用户的沟通界面

1、添加成员函数

在管理类 workerManager.h 中添加成员函数 void showMenu();

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

// 管理类
class WorkerManager
{
public:
	// 构造函数
	WorkerManager();

	// 显示菜单
	void showMenu();

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

2、菜单功能让实现

在管理类 workerManager.cpp 中实现 showMenu() 函数

#include "workerManager.h"

WorkerManager::WorkerManager()
{

}

void WorkerManager::showMenu()
{
	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 << "******************************************\n" << endl;
}

WorkerManager::~WorkerManager()
{

}

3、测试菜单功能

在 职工管理系统.cpp 中测试菜单功能

示例：

#include <iostream>
using namespace std;

#include "workerManager.h"

int main()
{
	// 实例化管理者对象
	WorkerManager wm;
	wm.showMenu();

	system("puase");
	return 0;
}

运行效果图

五、退出功能

1、提供功能接口

在main函数中提供分支选择，提供每个功能接口

示例：

#include <iostream>
using namespace std;
#include "workerManager.h"


int main()
{
	// 实例化管理者对象
	WorkerManager wm;
	// 创建变量 用户选择
	int choice;
	while (true)
	{
		// 1. 展示菜单
		wm.showMenu();
		// 2. 获取用户输入
		cin >> choice;
		// 3. 执行对应操作
		switch (choice)
		{
		case 0: // 退出系统
			break;
		case 1: // 增加职工信息
			break;
		case 2: // 显示职工信息
			break;
		case 3: // 删除职工信息
			break;
		case 4: // 修改职工信息
			break;
		case 5: // 查找职工信息
			break;
		case 6: // 按照编号排序
			break;
		case 7: // 清空所有文档
			break;
		default: // 清空屏幕
			system("cls");
			break;
		}
	}

	system("pause");
	return 0;
}

2、实现退出功能

在 workerManager.h 中提供退出系统的成员函数 void exitSystem();

在 workerManager.cpp 中提供具体的功能实现

void WorkerManager::exitSystem()
{
	cout << "欢迎下次使用" << endl;
	system("pause");
	exit(0);
}

3、测试功能

在main函数分支0选项中，调用退出程序的接口

case 0: // 退出系统
    wm.exitSystem();
    break;

运行测试效果图：

六、创建职工类

1、创建职工抽象类

职工的分类为：普通员工、经理、老板

将三种职工抽象到一个类(worker）中，利用多态管理不同职工种类

职工的属性为：职工编号、职工姓名、职工所在部门编号

职工的行为为：岗位职责信息描述，获取岗位名称

头文件文件夹下创建文件 worker.h 文件并且添加如下代码：

2、创建普通员工类

普通员工类继承职工抽象类，并重写父类中纯虚函数

在头文件和源文件的文件夹下分别创建 employee.h 和 employee.cpp 文件

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

employee.cpp 中代码如下：

#include "employee.h"

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("员工");
}

3、创建经理类

经理类继承职工抽象类，并重写父类中纯虚函数

在头文件和源文件的文件夹下分别创建 manager.h 和 manager.cpp 文件

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

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("经理");
}

4、创建老板类

老板类继承职工抽象类，并重写父类中纯虚函数

在头文件和源文件的文件夹下分别创建 boss.h 和 boss.cpp 文件

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

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("总裁");
}

5、测试多态

在 职工管理系统.cpp 中添加测试函数，并且运行能够产生多态

测试代码如下：

#include <iostream>
using namespace std;

#include "workerManager.h"
#include "worker.h"
#include "employee.h"
#include "manager.h"
#include "boss.h"

// 测试函数
void test()
{
	// 创建一个空指针
	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;
}

运行效果图

七、添加职工

功能描述：批星添加职工，并且保存到文件中

1、功能分析

用户在批量创建时，可能会创建不同种类的职工

如果想将所有不同种类的员工都放入倒一个数组中，可以将所有员工的指针维护到一个数组里

如果想在程序中维护这个不定长度的数组，可以将数组创建到堆区，并利用 Worker ** 的指针维护

2、功能实现

在 wokerManager.h 头文件中添加成员属性代码：

	// 记录文件中的人数个数
	int m_EmpNum;

	// 员工数组的指针
	Worker** m_EmpArray;

在 wokerManager.cpp 构造函数中初始化属性

WorkerManager::WorkerManager()
{
	// 初始化人数
	this->m_EmpNum = 0;
	// 初始化数组指针
	this->m_EmpArray = NULL;

}

在 wokerManager.h 中添加成员函数

	// 添加职工
	void addEmp();

在 wokerManager.cpp 中实现 addEmp 函数

void WorkerManager::addEmp()
{
	cout << "请输入增加职工数量: ";
	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 << " 个新职工编号: ";
			cin >> id;

			cout << "请输入第 " << i + 1 << " 个新职工姓名: ";
			cin >> name;

			cout << "请选择第 " << i + 1 << " 个新职工岗位\n 1、普通职工\n 2、经理\n 3、老板\n: ";
			cin >> dSelect;

			Worker* worker = NULL;
			switch (dSelect)
			{
			case 1: // 普通职工
				worker = new Employee(id, name, dSelect);
				break;
			case 2: // 经理
				worker = new Manager(id, name, dSelect);
				break;
			case 3: // 老板
				worker = new Boss(id, name, dSelect);
				break;
			default:
				break;
			}
			newSpace[this->m_EmpNum + i] = worker;
		}

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

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

		// 更新新的个数
		this->m_EmpNum = newSize;

		// 成功添加后 保存到文件中

		// 提示成功添加
		cout << "成功添加 " << addNum << " 名新员工!" << endl;
	}
	else
	{
		cout << "输入有误" << endl;;
	}
	// 按任意键后 清屏回到上级目录
	system("pause");
	system("cls");
}

WorkerManager::~WorkerManager()
{
	if (this->m_EmpArray != NULL)
	{
		delete[] this->m_EmpArray;
		this->m_EmpArray = NULL;
	}
}

八、文件交互 - 写文件

功能描述：对文件进行读写

• 在上一个添加功能中，我们只是将所有的数据添加到了内存中，一旦程序结束就无法保存了
• 因此文件管理类中需要一个与文件进行交互的功能，对于文件进行读写操作

1、设定文件路径

首先我们将文件路径，在 workerManager.h 中添加宏常量，并且包含头文件 fstream

#include <fstream> // 包含文件输入输出流头文件
#define FILENAME "empFile.txt" // 定义文件路径宏常量

2、成员函数声明

在 workerManager.h 中类中添加成员函数 void save()

void save();

3、保存文件功能实现

void WorkerManager::addEmp()
{
		// 成功添加后 保存到文件中
		this->save();
}


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

4、保存文件功能测试

九、文件交互 - 读文件

功能描述：将文件中的内容读取到程序中

虽然我们实现了添加职工后保存到文件的操作，但是每次开始运行程序，并没有将文件中数据读取到程序中

而我们的程序功能中还有清空文件的需求

因此构造函数初始化数据的情况分为三种

1. 第一次使用，文件未创建
2. 文件存在，但是数据被用户清空
3. 文件存在，并且保存职工的所有数据

1、文件为创建

在 workerManager.h 中添加新的成员属性 m_FilelsEmpty 标志文件是否为空

WorkerManager::WorkerManager()
{
	// 读取文件
	ifstream ifs;
	ifs.open(FILENAME, ios::in);
    // 1. 文件不存在情况
	if (!ifs.is_open())
	{
		cout << "文件不存在" << endl;
		// 初始化人数
		this->m_EmpNum = 0;
		// 初始化数组指针
		this->m_EmpArray = NULL;
		// 初始化文件标志
		this->m_FileIsEmpty = true;
		// 关闭文件
		ifs.close();
		return;
	}
}

删除文件后，测试文件不存在时初始化数据功能

2、文件存在且数组为空

在 workerManager.cpp 中的构造函数追加代码

WorkerManager::WorkerManager()
{
	...

	// 2. 文件存在，并且没有记录
	char ch;
	ifs >> ch;
	if (ifs.eof())
	{
		cout << "文件为空!" << endl;
		// 初始化人数
		this->m_EmpNum = 0;
		// 初始化数组指针
		this->m_EmpArray = NULL;
		// 初始化文件标志
		this->m_FileIsEmpty = true;
		// 关闭文件
		ifs.close();
		return;
	}
}

3、文件存在且保存职工信息

(1) 获取记录的职工人数

在 workerManager.h 中添加成员函数 int getEmpNum();

	// 统计人数
	int getEmpNum();

workerManager.cpp 中实现

int WorkerManager::getEmpNum()
{
	ifstream ifs;
	ifs.open(FILENAME, ios::in);
	int id;
	string name;
	int dId;
	int num = 0;
	while (ifs >> id && ifs >> name && ifs >> dId)
	{
		// 记录人数
		num++;
	}
	ifs.close();
	return num;
}

在 workerManager.cpp 构造函数中继续添加代码：

WorkerManager::WorkerManager()
{
	...

	// 3. 文件存在，并且有记录
	int num = this->getEmpNum();
	cout << "职工个数为: " << num << endl; // 测试代码
	this->m_EmpNum = num;
}

手动添加一些职工数据，测试获取职工数量函数

测试结果：

(2) 初始化数组

根据职工的数据以及职工数据，初始化 workerManager中的 Worker** m_EmpArray 指针

在 workerManager.h 中添加成员函数 void initEmp();

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

在 workerManager.cpp 中实现成员函数 void initEmp();

void WorkerManager::initEmp()
{
	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;
		// 根据不同部门ID创建不同对象
		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);
		}
		/*
		// 方式二
		switch (dId)
		{
		case 1:
			worker = new Employee(id, name, dId);
			break;
		case 2:
			worker = new Manager(id, name, dId);
			break;
		case 3:
			worker = new Boss(id, name, dId);
			break;
		default:
			break;
		}
		*/
		// 存放在数组中
		this->m_EmpArray[index] = worker;
		index++;
	}
	ifs.close();
}

在 workerManager.cpp 构造函数中追加代码

WorkerManager::WorkerManager()
{
	...
	// 根据职工数创建数组
	this->m_EmpArray = new Worker * [this->m_EmpNum];
	// 初始化员工
	this->initEmp();
	//  测试代码
	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]->getDeptName() << endl;
	}
}

运行程序，测试从文件中获取的数据

十、显示职工

功能描述：显示当前所有职工信息

1、显示职工函数声明

在 workerManager.h 中添加成员函数 void showEmp();

	// 显示职工
	void showEmp();

2、显示职工函数实现

在 workerManager.cpp 中实现成员函数 void showEmp();

void WorkerManager::showEmp()
{
	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");
}

3、测试显示员工

// 职工管理系统.cpp
case 2: // 显示职工信息
    wm.showEmp();
    break;

测试时分别测试文件为空和文件不为空两种情况

测试效果：

测试1 - 文件不存在或者为空情况

测试2 - 文件存在且有记录情况

十一、删除职工

功能描述：按照职工的编号进行删除职工操作

1、删除职工函数声明

在 workerManager.h 中添加成员函数 void delEmp();

	// 删除职工
	void delEmp();

2、职工是否存在函数声明

很多功能都需要用到根据职工是否存在来进行操作如：删除职工、修改职工、查找职工

因此添加该公告函数，以便后续调用

在 workerManager.h 中添加成员函数 int isExist(int id);

	// 按照职工编号判断职工是否存在，若存在返回职工在数组中位置，不存在返回-1
	int isExist(int id);

3、职工是否存在函数实现

在 workerManager.cpp 中实现成员函数 int isExist(int id);

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

4、删除职工函数实现

在 workerManager.cpp 中实现成员函数 void delEmp();

void WorkerManager::delEmp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空!" << endl;
	}
	else
	{
		// 按照职工编号删除
		int id = 0;
		cout << "请输入想要删除的职工编号: ";
		cin >> id;
		int index = this->isExist(id);
		if (index != -1) // 职工存在，删除掉 index 位置的职工
		{
			// 数据前移
			for (int i = index; i < this->m_EmpNum - 1; i++)
			{
				this->m_EmpArray[i] = this->m_EmpArray[i + 1];
			}
			// 更新数组中记录的人员个数
			this->m_EmpNum--;
			// 同步更新到文件中
			this->save();
			// 提示用户删除成功
			cout << "职工删除成功!" << endl;
		}
		else
		{
			cout << "删除失败，未找到该职工!" << endl;
		}
	}
	system("pause");
	system("cls");
}

5、测试删除职工

在main函数分支3选项中，调用删除职工接口

case 3: // 删除职工信息
	wm.delEmp();

十二、修改职工

功能描述：能够按照职工的编号对职工信息进行修改并保存

1、修改职工函数声明

在 workerManager.h 中添加成员函数 void modEmp();

	// 修改职工
	void modEmp();

2、修改职工函数实现

在 workerManager.cpp 中实现成员函数 void modEmp();

void WorkerManager::modEmp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空!" << endl;
	}
	else
	{
		// 按照职工编号删除
		int id = 0;
		cout << "请输入想要修改的职工编号: ";
		cin >> id;
		int index = this->isExist(id);
		if (index != -1) // 职工存在，修改职工信息
		{
			int id;
			string name;
			int dSelect;

			cout << "请输入新职工编号: ";
			cin >> id;

			cout << "请输入新职工姓名: ";
			cin >> name;

			cout << "请选择新职工岗位\n 1、普通职工\n 2、经理\n 3、老板\n: ";
			cin >> dSelect;

			Worker* worker = NULL;
			switch (dSelect)
			{
			case 1: // 普通职工
				worker = new Employee(id, name, dSelect);
				break;
			case 2: // 经理
				worker = new Manager(id, name, dSelect);
				break;
			case 3: // 老板
				worker = new Boss(id, name, dSelect);
				break;
			default:
				break;
			}
			// 修改职工信息
			this->m_EmpArray[index] = worker;
			// 同步更新到文件中
			this->save();
			// 提示用户删除成功
			cout << "职工修改成功!" << endl;
		}
		else
		{
			cout << "修改失败，未找到该职工!" << endl;
		}
	}
	system("pause");
	system("cls");
}

十三、查找职工

功能描述：提供两种查找职工方式，一种按照职工编号，一种按照职工姓名

1、查找职工函数声明

在 workerManager.h 中添加成员函数 void findEmp();

	// 查找职工
	void findEmp();

2、查找职工函数实现

在 workerManager.cpp 中实现成员函数 void findEmp();

void WorkerManager::findEmp() 
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空!" << endl;
	}
	else
	{
		cout << "请输入查找方式 \n 1、按照职工编号查找 \n 2、按照职工姓名查找 \n: ";
		int select = 0;
		cin >> select;
		if (select == 1) // 按照职工编号查找
		{
			cout << "请输入想要查找的职工编号: ";
			int id = 0;
			cin >> id;
			int index = this->isExist(id);
			if (index != -1) // 职工存在
			{
				cout << "查找成功，职工编号为: " << this->m_EmpArray[index]->m_Id << " 号的信息如下: " << endl;
				this->m_EmpArray[index]->showInfo();
			}
			else
			{
				cout << "查找失败，查无此人" << endl;
			}
		}
		else
		{
			cout << "请输入想要查找的职工姓名: ";
			string name = 0;
			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;
					flag = true;
					this->m_EmpArray[i]->showInfo();
				}
			}
			if (!flag)
			{
				cout << "查找失败，查无此人" << endl;
			}
		}
	}
	system("pause");
	system("cls");
}

3、测试查找职工函数

    case 5: // 查找职工信息
        wm.findEmp();
        break;

十四、排序

功能描述：按照职工编号进行排序，排序的顺序由用户指定

1、排序函数声明

在 workerManager.h 中添加成员函数 void sortEmp();

	// 排序职工
	void sortEmp();

2、排序函数实现

在 workerManager.cpp 中实现成员函数 void sortEmp();

void WorkerManager::sortEmp()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空!" << endl;
		system("pause");
		system("cls");
	}
	else
	{
		cout << "请选择排序方式 \n 1、按照职工号进行升序排序 \n 2、按照职工号进行降序排序 \n: ";
		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 > m_EmpArray[j]->m_Id)
					{
						minOrMax = j;
					}
				}
				else // 按照职工号进行降序排序
				{
					if (this->m_EmpArray[minOrMax]->m_Id < m_EmpArray[j]->m_Id)
					{
						minOrMax = j;
					}
				}
			}
			if (i != minOrMax)
			{
				Worker* temp = m_EmpArray[i];
				m_EmpArray[i] = m_EmpArray[minOrMax];
				m_EmpArray[minOrMax] = temp;
			}
		}
		// 排序完成
		cout << "排序成功，排序后的结果为: " << endl;
		this->save();
		this->showEmp();
	}
}

3、测试排序函数

	case 6: // 按照编号排序
        wm.sortEmp();
        break;

十五、清空文件

功能描述：将文件中记录数据清空

1、清空函数声明

在 workerManager.h 中添加成员函数 void cleanFi1e();

	// 清空文件
	void cleanFi1e();

2、清空函数实现

void WorkerManager::cleanFi1e()
{
	if (this->m_FileIsEmpty)
	{
		cout << "文件不存在或记录为空!" << endl;
	}
	else
	{
		cout << "确认清空？ \n 1、确认 \n 2、取消 \n: ";
		int select = 0;
		cin >> select;
		if (select == 1) // 确认删除
		{
			ofstream ofs(FILENAME, ios::trunc);
			ofs.close();

			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];
					}
				}
				this->m_EmpNum = 0;
				delete[] this->m_EmpArray;
				this->m_EmpArray = NULL;
				this->m_FileIsEmpty = true;
			}
			cout << "清空成功" << endl;
		}
		else
		{
			cout << "查找失败，查无此人" << endl;
		}
	}
	system("pause");
	system("cls");
}

3、测试清空函数

		case 7: // 清空所有文档
			wm.cleanFi1e();
			break;

十六、完整示例

基于多态的职工管理系统.zip