C++核心笔记-CSDN博客

内存分区模型
c++程序在执行时，将内存大方向划分为4个区域
代码区：存放函数体的二进制代码，由操作系统进行管理的
全局区：存放全局变量和静态变量以及常量
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
内存四区意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程
程序运行前：
在程序编程后，生成exe可执行程序，未执行该程序前分为两个区域
代码区：
   存放CPU执行的机器指令
   代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
   代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
   全局变量和静态变量存放在此
   全局区还包含了常量区，字符串常量和其他常量也存放在此
   该区域的数据在程序结束后由操作系统释放

1.全局区

#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;
	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，属于静态变量
	static int s_a = 10;
	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-locall(局部)
	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;
}

     不在全局区（常量区）：局部变量、const修饰的局部变量（局部常量）
   全局区：全局变量、静态变量（static关键字）、字符串常量、const修饰的全局变量（全局常量）
   代码区的特点是共享、只读

2.栈区

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

#include <iostream>
using namespace std;
int* func(int b) //int b形参数据 也会放在栈区 这里不加int b  只是为了说明形参放在栈区
{
	int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;//返回局部变量的地址
}
int main() {
	//接收func函数的返回值
	int* p = func(1);
	cout << *p << endl;//第一次可以打印正确的数字，是因为编译器做了保留，防止下一次还要用
	cout << *p << endl;//第二次这个数据就不再保留了 输出其实是乱码
	system("pause");
	return 0;
}

3.堆区

堆区由程序员管理开辟和释放
堆区数据利用new关键字进行开辟
手动释放，释放利用操作符delete
语法： new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针，说到底是地址

#include <iostream>
using namespace std;
int* func() {
	//利用new关键字 可以将数据开辟到堆区
	//new返回的是该数据类型的指针
	int* p = new int(10); //()里是个变量 []是个数组
	return p;
}

//在堆区利用new开辟数组
void test01() {
	//创建整型数据的数组，在堆区
	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] << "\t";
	}
	cout << endl;
	//释放堆区数组 要加[]才可以
	delete[]arr;
	//cout << *arr;会报异常
}
int main() {
	//在堆区开辟数据
	int* p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	delete p;//释放堆区的数据
	//cout << *p << endl;
    //能运行，但会发生异常，内存已经被释放，再次访问就是非法操作，会报错
	cout << "堆区开辟的数组：" << endl;
	test01();

	system("pause");
	return 0;
}

15C++中的引用

1.引用的基本语法

引用的基本使用
作用：给变量起别名
语法：数据类型 &别名 = 原名

#include <iostream>
using namespace std;
int main() {
	//引用基本语法
	//数据类型 &别名 = 原名
	int a = 10;
	//创建引用
	int& b = a;
	cout << "a= " << a << endl;
	b = 1000;	//也就是b跟a是同一个 只是给a起了个别名
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

2.引用注意事项

引用必须初始化
引用在出初始后，不可以改变

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

}

3.引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参

//1.值传递
using namespace std;
#include <iostream>
void mySwap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	cout << "mySwap01 a = " << a << endl;
	cout << "mySwap01 b = " << b << endl;
}
//2.地址传递
void mySwap02(int * a ,int  * b) {
	int temp = *a;
	*a = *b;
	*b = temp;
	cout << "mySwap02 a = " << a << endl;
	cout << "mySwap02 b = " << b << endl;
}
//3.引用传递
void mySwap03(int &a ,int &b) {
	int temp = a;
	a = b;
	b = temp;
	cout << "mySwap03 a = " << a << endl;
	cout << "mySwap03 b = " << b << endl;
}
int main() {
	int a = 10;
	int b = 20;
	mySwap01(a, b);
	int* p = &a;
	int* p1 = &b;
	mySwap02(p, p1);
	mySwap03(a, b);
	cout << " a = " << a << endl;
	cout << " b = " << b << endl;
	/*
	通过引用参数产生的效果同地址传递是一样的，引用的语法更清楚简单
	*/
	system("pause");
	return 0;
}

4.引用做函数返回值

引用做函数返回值
注意：不要返回局部变量引用
用法：函数调用作为左值

#include <iostream>;
using namespace std;
//1.不要返回局部变量引用
int& test01() {
	int a = 10;//局部变量
	return a;
}
//2.函数的调用可以作为左值
int& test02() {
	static int a = 10;//静态变量存放在全局区，全局区上的数据在程序结束后系统释放

	return a;
}
int main() {
	int &a = test01();
	cout << a << endl;//第一次结果正确，是因为编译器做了保留
	//cout << a << endl;//乱码，第一次结果错误，因为a的内存已经释放
	//局部变量放在栈区，会被编译器自然释放
	int b = test02();
	cout << b << endl;
	cout << b << endl;//用static修饰变成静态变量，不在栈区，在全局区
	test02() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值
	cout << b << endl;
	cout << b << endl;
	system("pause");
	return 0;
}

5.引用的本质

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

#include <iostream>
using namespace std;
//发现是引用，转换为int * const ref = &a;
void func(int &ref) {
	ref = 100;//ref是引用，转换为*ref = 100
}
int main() {
	int a = 10;
	//自动转换为 int* const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a;
	ref = 20;//内部发现ref是引用，自动帮我们转换为：*ref = 20;
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;
	func(a);
	/*
	C++推荐引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了*/
	return 0;
}

6.常量引用

作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参

//引用使用的场景，通常用来修饰形参
#include <iostream>
using namespace std;
void showValue(const int&v) {
	//v += 10;	//如果你要打印一段数据，但是你显示的跟你打印出来的不一样
	//加入const防止你误操作
	cout << v << endl;
}
int main() {
	//常量引用
	// 使用场景：用来修饰形参，防止误操作
	//int& ref = 10;引用本身需要一个合法的内存空间，因此这行错误
	//加入const就可以了，编译器优化代码：int temp = 10; const int &ref =temp;
	const int& ref = 10;//引用必须引一块合法的内存空间
	//ref = 20;//加入const之后变为只读，不可以修改
	showValue(ref);
	system("pause");
	return 0;
}

16函数高级

1.函数的默认参数

在C++，函数的形参列表中的形参是可以有默认值的
语法：返回值类型函数名（参数 = 默认值）{}

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

//2.如果函数声明有默认参数，函数实现就不能有默认参数
//声明和实现只能有一个默认参数
int func2(int a, int b);
int main() {
	cout << func(10) << endl;
	cout << func2(30, 20) << endl;
	system("pause");
	return 0;

}
int func2(int a = 10, int b = 10) {
	return a + b;
}

2.函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法：返回值类型函数名（数据类型）{}
在现阶段函数的占用参数存在意义不大，但是后面的课程中会用到该技术

#include <iostream>
using namespace std;
void func(int a, int) {
	cout << " this is func " << endl;
}
void func1(int a, int = 10) {
	cout << " this is func1 " << endl;
}
int main() {
	func(10, 10);
	func1(20);
	system("pause");
	return 0;
}

3.函数重载

函数重载概述
作用：函数名可以相同，提高复用性
函数重载满足条件：
同一作用域下
函数名称相同
函数参数类型不同或者个数不同或者顺序不同
注意：函数的返回值不可以作为函数重载的条件

#include <iostream>
using namespace std;
void func() {
	cout << "func的调用" << endl;
}
void func(int a ) {
	cout << "func(int a)的调用" << endl;
}
void func(double a,int b) {
	cout << "func(double a,int b)的调用" << endl;
}
//函数的返回值不可以作为函数重载的条件
//int func(double a ,int b) {
//	return b;
//}
int main() {
	func();
	func(1);
	func(3.14, 1);

}

4.函数重载注意事项

函数重载注意事项
引用作为重载条件
函数重载碰到函数默认参数

#include <iostream>
using namespace std;
//1.引用作为重载条件
void func(int& a) // int &a = 10;不合法 这就是为什么func(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 ) {
	cout << "func2(int a)的调用" << endl;
}
void func2(int a, int b = 10) {
	cout << "func2(int a,int b)的调用" << endl;
}
int main() {
	int a = 10;
	func(a);
	func(10);
	//func2(10);//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况
	system("pause");
	return 0;
}

17类和对象_封装

类和对象
C++面向对象的三大特征为：封装、继承、多态
C++认为万事万物皆对象，对象上有其属性和行为
例如：
人可以作为对象，属性有姓名、年龄、身高、体重..行为有走、跑、跳、吃饭..
车也可以作为对象，属性有轮胎、方向盘..行为有载人、放音乐、放空调...
具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类
封装的意义
封装是C++面向对象三大特征之一

1.封装的意义

封装的意义：
将属性和行为作为一个整体，表现生活的事务
将属性和行为加以权限控制
封装意义一:
在设计类的时候，属性和行为写在一起，表现事务
语法：class 类名{ 访问权限：属性/行为};

//设计一个圆类，求圆的周长
//圆的周长的公式：2*PI*半径
//class代表设计一个类，类后面紧跟着的就是类名称
#include <iostream>
using namespace std;
const double PI = 3.14;
class Circle 
{
	//访问权限
public://公共权限
	//属性
	//半径
	int m_r;
	//行为
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI * m_r;
	}
};
int main() {
	//通过圆类 创建具体的圆（对象)
	//实例化 （通过一个类 创建一个对象的过程）
	Circle c;
	//给圆（对象）的属性进行赋值
	c.m_r = 10;
	cout << "圆的周长为：" << c.calculateZC() << endl;
	system("pause");
	return 0;
}

2.封装的案例

/*
设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
*/
#include <string>
#include <iostream>
using namespace std;
//设计一个学术类
class Student
{
public:	//公共权限
	//属性
	string m_Name;
	int m_ID;
	//行为
	//显示姓名和学号
	void showMess() {
		cout << "姓名为：" << m_Name << " 学号为：" << m_ID << endl;
	}
	//设置名字
	void setName(string name){
		m_Name = name;
	}
	//设置学号
	void setId(int id) {
		m_ID = id;
	}
};
int main() {
	//创建一个具体学生 实例化对象
	Student s;
	//给s对象 进行属性赋值操作
	s.setName("张三");
	s.setId(1);
	Student s1;
	s1.setName("李四");
	s1.setId(2);
	//显示学生信息
	s.showMess();
	s1.showMess();
	system("pause");
	return 0;
}

3.封装的权限控制

封装意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
1.public 公共权限类内可以访问类外可以访问
2.protected 保护权限类内可以访问类外不可以访问儿子可以访问父亲中的保护内容
3.private 私有权限类内可以访问类外不可以访问儿子不可以访问父亲的私有内容

#include <string>
#include<iostream>
using namespace std;
class Person {
public:
	//公共权限
	string m_Name;//姓名
protected:
	//保护权限
	string m_Car;//汽车
private:
	//私有权限
	int m_PassWord;//银行卡密码
private:
	void func() {
		m_Name = "李四";
		m_Car = "拖拉机";
		m_PassWord = 123456;
	}
};
int main() {
	//实例化具体对象
	Person p;
	p.m_Name = "张三";
	//p.m_Car = "奔驰"; 保护权限内容，在类外访问不到
	//p,m_PassWord = 123; 私有权限内容，类外访问不到
	//p.func(): 构造方法被修饰，类外也访问不到
	system("pause");
	return 0;
}

4.struct和class区别

在c++中 struct和class唯一的区别就在于默认的访问权限不同
区别：
struct 默认权限为公有 public
class 默认权限为私有 private

class C {
	int m_A;//默认权限是私有 
};
struct C1
{
	int m_A;//默认权限是公有
};
int main() {
	C c;
	C1 c1;
	//c.m_A; class默认权限  私有 因为类外不可以访问
	c1.m_A;
}

5.成员属性设为私有

成员属性设置为私有
优点一：将所有成员属性设置为私有，可以自己控制读写权限
优点二：对于写权限，我们可以检测数据的有限性

#include <string>
#include <iostream>
using namespace std;
class Person {
public:
	//姓名设置可读可写
	void setName(string name) {
		m_Name = name;
	}
	string getName() {
		return m_Name;
	}
	//年龄设置可读可写 如果想修改(年龄范围在0-130岁之间)
	int getAge() {
		m_Age = 0;
		return m_Age;
	}
	void setAge(int age){
		if (age < 0 || age > 130) {
			cout << "年龄输入有误" << endl;
			return;
		}
		m_Age = age;
	}
	//情人设置可写
	void setLover(string lover) {
		m_Lover = lover;
	}
private:
	//姓名 可读可写
	string m_Name;
	//年龄 可读可写
	int m_Age;
	//情人 只写
	string m_Lover;
};
int main() {
	Person p;
	p.setName("张三");
	cout << "姓名为：" << p.getName() << endl;
	//p.m_Age = 18;
	p.setAge(1000); 
	cout << "年龄为：" << p.getAge() << endl;
	p.setLover("樂y");
	system("pause");
	return 0;
}

6.封装案例_立方体

设计立方体案
设计立方体类(Cube)
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等

/*
立方体类设计
1.创建立方体类
2.设计属性
3.设计行为 获取立方体面积和体积
4.分别利用全局变量和成员函数 判断两个立方体是否相等
*/
#include <iostream>
using namespace std;
class Cube {
public:
	//行为
	void setL(int l) {
		m_L = l;
	}
	void setW(int w) {
		m_W = w;
	}
	void setH(int h) {
		m_H = h;
	}
	//设置获取长宽高
	int getL() {
		return m_L;
	}
	int getW() {
		return m_W;
	}
	int getH() {
		return m_H;
	}
	//获取立方体面积
	int calculateS() {
		return 2 * m_L * m_W + 2 * m_L * m_H + 2 * m_L * m_H;
	}
	//获取立方体体积
	int calculateV() {
		return m_L * m_L * m_H;
	}
	//利用成员函数判断两个立方体是否相等
	bool isSameByClass(Cube& c) { //不用引用类型也可以，但用内存占用会变少
		if (c.getH() == m_H, c.getL() == m_L, c.getW() == m_W)
		{
			return true;
		}
		return false;
	}
private:
	//属性
	int m_L;//长
	int m_W;//宽
	int m_H;//高
};
//利用全局函数判断 两个立方体是否相等
bool isSame(Cube &c1,Cube &c2) { //不用引用类型也可以，但用内存占用会变少
	if (c1.getH() == c2.getH() && c1.getL() == c2.getL() && c1.getW() == c2.getW())
	{
		return true;
	}
	return false;
}
int main() {
	Cube c;
	c.setH(10);
	c.setL(10);
	c.setW(10);
	cout << "立方体面积为：" << c.calculateS() << endl;
	cout << "立方体体积为：" << c.calculateV() << endl;
	Cube c1;
	c1.setH(10);
	c1.setL(10);
	c1.setW(10);
	if (isSame(c,c1) == true)
	{
		cout << "两立方体一模一样" << endl;
	}
	else
	{
		cout << "两立方体不同" << endl;
	}
	if (c.isSameByClass(c1) == true)
	{
		cout << "两立方体一模一样" << endl;
	}
	else
	{
		cout << "两立方体不同" << endl;
	}
}

7.封装案例二点和圆的关系

7.1无分文件的代码

/*
点和圆的关系
设计一个圆形类Circle，和一个点类Point，计算点和圆的关系
*/
//圆类
#include <iostream>
using namespace std;
//点类
class Point { //Point类要比Circle前，否则运行不了
public:
	//设置x
	void setX(int x) {
		m_X = x;
	}
	//获取x
	int getX() {
		return m_X;
	}
	void setY(int y) {
		m_Y = y;
	}
	int getY() {
		return m_Y;
	}
private:
	int m_X;
	int m_Y;
};
class Circle {
public:
	void setR(int r) {
		m_R = r;
	}
	int getR() {
		return m_R;
	}
	void 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())
		+ (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
	int doubler = c.getR() * c.getR();
	if (distance == doubler)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance >= doubler)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}
int main() {
	//创建圆
	Circle c;
	c.setR(10);
	Point center;
	center.setX(10);
	center.setY(0);
	c.setCenter(center);
	//创建点
	Point p;
	p.setX(10);
	p.setY(10);
	//判断关系
	isInCircle(c, p);
}

7.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();
	void setY(int y);
	int getY();
private:
	int m_X;
	int m_Y;
};

//源文件下circle.cpp
#include "circle.h"
	void Circle :: setR(int r) {
		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"
	//设置x
	void Point::setX(int x) {
		m_X = x;
	}
	//获取x
	int Point:: getX() {
		return m_X;
	}
	void Point:: setY(int y) {
		m_Y = y;
	}
	int Point:: getY() {
		return m_Y;
	}

//在源文件下main.cpp
#include <iostream>
#include "circle.h"
#include "point.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 doubler = c.getR() * c.getR();
	if (distance == doubler)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance >= doubler)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}
int main() {
	//创建圆
	Circle c;
	c.setR(10);
	Point center;
	center.setX(10);
	center.setY(0);
	c.setCenter(center);
	//创建点
	Point p;
	p.setX(10);
	p.setY(10);
	//判断关系
	isInCircle(c, p);
}

18类和对象-对象特征

1.对象的初始化和清理

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

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

2.构造函数和析构函数

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

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

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

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

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

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

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

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

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

2.函数名称与类名相同

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

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

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

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

2.函数名称与类名相同,在名称前加上符号~

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

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

#include<iostream>
using namespace std;
//对象的初始化和清理
//1、构造函数 进行初始化操作
class Person {
public:
	//1、构造函数
	Person() {
		cout << "Person 构造函数的调用" << endl;
	}
	~Person() {
		//对象在销毁前  会自动调用析构函数 而且只会调用一次
		cout << "Person 析构函数的调用" << endl;
		//这也是为什么只调用Person() 析构函数也会被调用
	}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test() {
	Person p;//在栈上的数据，test执行完毕后，释放这个对象
}
int main() {
	test();
	system("pause");
	return 0;
}

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

两种分类方式：

按参数分为：有参构造和无参构造

按类型分为：普通构造和拷贝构造

三种调用方式：

括号法

显示法

隐式转换法

#include<iostream>
using namespace std;
class Person {
public:
	//1、构造函数
	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 age;
};
void test() {
	//1.括号法
	Person p;//默认构造函数调用
	Person p1(10);//有参构造函数
	Person p2(p1);//拷贝构造函数
	cout << "p1的年龄为：" << p1.age << endl;
	cout << "p2的年龄为：" << p2.age << endl;
	/*注意事项1
	* 调用默认构造函数时候，不要加()
	* 因为下面这行代码，编译器会认为是一个函数的声明
	*/
	//Person p3();//会认为像是void func();
	//2.显示法
	Person p3;
	Person p4 = Person(10);//有参构造
	Person p5 = Person(p4);//拷贝构造
	Person(10);//匿名对象（没有给它名字）
	// 特点：当前行执行结束后，系统会立刻回收掉匿名对象
	cout << "aaaa" << endl; //这一行就是来验证系统立即回收匿名对象
	//所以aaaa在Person 析构函数的调用后输出
	/*注意事项2
	不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3) == Person p3;对象声明
	*/
	//Person(p3);
	//3.隐式转换法
	Person p6 = 10;//相当于 写了 Person p6 = Person(10); 有参构造
	Person p7 = p6;//拷贝构造
}
int main() {
	test();
	system("pause");
	return 0;
}

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

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

·使用一个已经创建完毕的对象来初始化一个新对象·值传递的方式给函数参数传值

·以值方式返回局部对象

#include<iostream>
using namespace std;
class Person {
public:
	//1、构造函数
	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 age;
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test() {
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}
void doWork(Person p) {

}
void test1() {
	Person p;///会调用无参构造函数
	doWork(p);//条用拷贝构造函数
}
Person doWork2() {
	Person p3;
	cout << (int*)&p3 << endl;
	return p3;
}
void test2() {
	Person p4 = doWork2();
	cout << (int*)&p4 << endl;//p4跟p3是不一样的
}
int main() {
	test();
	test1();
	test2();
	system("pause");
	return 0;
}

4.构造函数调用规则

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

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

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

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

构造函数调用规则如下：

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

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

5.深拷贝与浅拷贝

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

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

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

#include<iostream>
using namespace std;
class Person {
public:
	//1、构造函数
	Person() {
		cout << "Person的无参构造函数的调用" << endl;
	}
	Person(int age,int height) {
		m_Age = age;
		m_Height = new int(height);//在堆中开辟这块内存
		//从堆区开辟，需要程序手动释放，那么需要用到析构函数
		cout << "Person的有参构造函数的调用" << endl;
	}

	~Person() {
		//析构代码，将堆区开辟数据做释放操作
		if (m_Height != NULL) {
			delete m_Height;
			m_Height = NULL;//预防野指针的出现
		}
		cout << "Person 析构函数的调用" << endl;
	}
	Person(const Person& p) {
		cout << "Person 拷贝函数调用" << endl;
		m_Age = p.m_Age;
		//m_Height = p.m_Height;编译器默认实现的就是这行代码
		m_Height = new int(*p.m_Height);

	}
	int m_Age;
	int* m_Height;//身高
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test() {
	Person p1(18,160);
	cout << "p1的年龄为：" << p1.m_Age << "，p1的身高为:" << *p1.m_Height << endl;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "，p2的身高为:" << *p2.m_Height << endl;
}


int main() {
	test();

	system("pause");
	return 0;
}

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

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 test() {
	Person p(10, 20, 30);//调用方式都是一样的
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}

int main() {
	test();

	system("pause");
	return 0;
}

7.类对象作为类成员

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

例如：

class A{};
class B {
	A a;
};

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

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

#include<iostream>
using namespace std;
#include <string>
//手机类
class Phone {
public:
	Phone(string pName) {
		m_PName = pName;
		cout << "Phone的构造函数调用" << endl;//先有这个
	}
	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}
	string m_PName;
};
//人类
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 test() {
	Person p("张三", "中华有为手机");
	cout << p.m_Name << "拿着：" << p.m_Phone.m_PName << endl;
}
int main() {
	test();
	system("pause");
	return 0;
}

8.静态成员

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

静态成员分为：

静态成员变量

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

在编译阶段分配内存。

类内声明，类外初始化

静态成员函数

所有对象共享同一个函数

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

#include<iostream>
using namespace std;
class Person {
public:

	//静态成员函数
	static void func() {
		m_A = 100;//静态成员函数可以访问静态成员变量
		//m_B = 10;//静态成员函数 不可以访问 非静态成员变量
		//无法区分到底是哪个对象的m_B属性
		cout << "static void func()调用" << endl;
	}
	//静态成员函数也是有访问权限的
private:
	static void func2() {
		cout << "static void func2()调用 " << endl;
	}
	static int m_A;//静态成员变量
	//int m_B;//非静态成员变量
};
int Person::m_A = 0;//一定要记得加这句，初始化，否则运行不了
//有两种访问方式
void test() {
	//1.通过对象访问
	Person p;
	p.func();
	//2.通过类名访问
	Person::func();
	//Person::func2();//类外访问不到私有静态成员函数
}
int main() {
	test();
	system("pause");
	return 0;
}

9.成员变量和成员函数分开存储

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

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

#include<iostream>
using namespace std;
class Person {

};
class Person1 {
	int m_A;//非静态成员变量 属于类的对象上
	static int m_B;//静态成员变量 不属于类对象上
	void func(){} //非静态成员函数 不属于类对象上
	static void func2(){}//静态成员函数 不属于类对象上
	//判断是否在类对象上：看字节数 int m_A肯定是占4字节的
	//结果也显示4，说明其他变量/函数没有占字节，也即不属于类对象上
};
int Person1::m_B = 0;
void test() {
	Person p;
	//空对象占用内存空间为：1
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	//每个空对象也应该有独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}
void test01() {
	Person1 p;
	cout << "size of p = " << sizeof(p) << endl;
}
int main() {
	test();
	test01();
	system("pause");
	return 0;
}

10.this指针概念

通过9.我们知道在C++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码那么问题是:这—块代码是如何区分那个对象调用自己的呢?

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

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

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

this指针的用途：

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

·在类的非静态成员函数中返回对象本身，可使用return *this

#include<iostream>
using namespace std;
class Person {
public:
	Person(int age) {
		//age = age;//这个代码的age全都是上面的age 名称的冲突
		this->age = age;
	}
	int age;
	Person& PersonAddAge(Person& p) { //返回类型如果不加& 
    //每次追加的对象都不是同一个对象，也起不了追加的作用
		//其实就相当于拷贝构造函数，每次生成的的对象都是不一样的 输出结果为30
		this->age += p.age;
		//this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}
};
//1.解决名称冲突
void test() {
	Person p(18);
	cout << "p1的年龄为：" << p.age << endl;
}
//2.返回对象本身用*this
void test01() {
	Person p1(10);
	Person p2(20);
	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;//输出结果：50 
}
int main() {
	test();
	test01();
	system("pause");
	return 0;
}

11.空指针访问成员函数

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

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

#include<iostream>
using namespace std;
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 test() {
	Person* p = NULL;
	p->showClassName();//调用这个不会报异常，因为指针没有被用到
	p->showPersonAge();

}

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

12.const修饰成员函数

常函数：

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

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

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

常对象：

声明对象前加const称该对象为常对象

常对象只能调用常函数

#include<iostream>
using namespace std;
class Person {
public:
	//this指针的本质 是指针常量 指针的指向是不可以修改的
	//const Person * const this
	//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
	void showPerson() const {
		this->m_B = 100;
		//this->m_A = 100;
		//this = NULL;//this指针不可以修改指针的指向的
	}
	void func(){
		int m_A = 10;
	}
	int m_A;
	mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值
};

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

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

19类和对象-友元

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

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

但是呢，你也可以允许你的好朋友进去。

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

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

友元的关键字为friend

友元的三种实现：

全局函数做友元

类做友元

成员函数做友元

1.全局函数做友元

#include<iostream>
using namespace std;
#include<string>
//建筑类
class Building {
	//goodFri全局函数是Building好朋友，可以访问Building中私有成员
	friend void GoodFri(Building* building);
public:
	Building() {
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};
//全局函数
void GoodFri(Building * building) {
	cout << "好朋友全局函数正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友全局函数正在访问" << building->m_BedRoom << endl;
}

void test() {
	Building building;
	GoodFri(&building);
}

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

2.类作友元

#include<iostream>
using namespace std;
#include<string>
//建筑类
class Building {
	//GoodFri类是本类的好朋友，可以访问本类中私有成员
	friend class GoodFri;
public:
	Building();
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室

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

};
//类外写成员函数
Building::Building() {
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodFri::GoodFri() {
	//创建建筑物对象
	building = new Building;

}
void GoodFri::visit() {
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友正在访问" << building->m_BedRoom << endl;
}

void test() {
	GoodFri gf;
	gf.visit();
}
int main() {
	test();
	system("pause");
	return 0;
}

3.成员函数做友元

#include<iostream>
using namespace std;
#include<string>
class Building;//这句一定要记得加 先声明 跟前面不太一样 测试的时候纠结了很久
class GoodFri {
public:
	GoodFri();
	void visit();//让visit函数可以访问Building中私有成员
	void visit2();//让visit2函数不可以访问Building中私有成员
	Building* building;

};
//建筑类
class Building {
	//告诉编译器 GoodFri类下的visit成员函数作为本类的好朋友，可以访问私有成员
	friend void GoodFri::visit();
public:
	Building();
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室

};
//类外写成员函数
Building::Building() {
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodFri::GoodFri() {
	//创建建筑物对象
	building = new Building;

}
void GoodFri::visit() {
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友正在访问" << building->m_BedRoom << endl;
}
void GoodFri::visit2() {
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	//cout << "好朋友正在访问" << building->m_BedRoom << endl;
}

void test() {
	GoodFri gf;
	gf.visit();
	gf.visit2();
}
int main() {
	test();
	system("pause");
	return 0;
}

20类和对象-C++运算符重载

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

1.加号运算符重载

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

#include<iostream>
using namespace std;
#include<string>
class Person {
public:
	//1.成员函数重载+号
	//Person operator+ (Person & p) {
	//	Person temp;
	//	temp.m_A = this->m_A + p.m_A;//this调用属性 要用指针
	//	temp.m_B = this->m_B + p.m_B;
	//	return temp;
	//}
	int m_A;
	int m_B;

};
//1.全局函数重载+号
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;
}
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 test() {
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 20;
	p2.m_B = 20;
	//1.成员函数重载本质调用
	//Person p3 = p1.operator+ (p2);
	//2.全局函数重载本质调用
	//Person p4 = operator+(p1, p2);
	Person p = p1 + p2;
	cout << "p.m_A = " << p.m_A << endl;
	cout << "p.m_B = " << p.m_B << endl;
	//运算符重载 也可以发生函数重载
	Person p3 = p1 + 100; //Person +int 
	cout << "p3.m_A = " << p3.m_A << endl;
	cout << "p3.m_B = " << p3.m_B << endl;
}
int main() {
	test();
	system("pause");
	return 0;
}

总结

1:对于内置的数据类型的表达式的的运算符是不可能改变的总结

（内置函数类型是：int double 这些）我们修改的运算都是自定义的数据类型

2:不要滥用运算符重载

eg.加法运算发重载你硬要让他1 + 1 = 0，这是不行的

2.左移运算符重载

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

#include<iostream>
using namespace std;
#include<string>
class Person {
	friend ostream& operator<<(ostream& cou, Person& p);
public:
	Person(int a ,int b) {
		m_A = a;
		m_B = b;
	}
	//利用成员函数重载 左移运算符 p.operator<<(cout) 简化为p << cout
	//不会利用成员函数重载<<运算符，因为无法实现cout在左侧
	//void operator<<(ostream cou) {
	//	

	//}
private:
	int m_A;
	int m_B;

};
ostream& operator<<(ostream &cou,Person&p) {//cou可以写cout，也只是别名而已
	//本质operator <<(cou,p) 简化为cou << p 
	cou << "p.m_A = " << p.m_A << "  m_B = " << p.m_B;
	return cou;//为了能够重复调用 如果没有void没有返回值
	//那么endl也没办法被调用，无法继续<<连结
}
void test() {
	//p1.m_A = 10;
	//p1.m_B = 10; 属性修改为private 外部访问不到 可以用set get方法
	//我们直接构造一个方法就好了
	Person p1(10, 10);
	cout << p1 << "hello world" << endl;

}

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

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

3.递增运算符重载

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

#include<iostream>
using namespace std;
#include<string>
class MyInterger {
	friend ostream& operator<<(ostream& cout, MyInterger myint);
public:
	//重载前置++运算符 返回引用为了一直对一个数据进行递增操作
	MyInterger& operator++() {
		//先进行++运算
		m_Num++;
		//再将自身做返回
		return *this;
	}
	//重载后置++运算符
	//MyInterger operator++(int) int代表占位参数，可以用于区分前置和后置递增
	MyInterger operator++(int) {
		//如果不加& 并不会发生函数重载 因为数据类型不一样 并不能发生重载		
		//先对数值进行保存 先记录当时结果
		MyInterger temp;
		temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果做返回
		return temp;

	}
	MyInterger() {
		m_Num = 0;
	}
private:
	int m_Num;
};
//重载<< 运算符
ostream& operator<<(ostream& cout,MyInterger myint) {
	cout << myint.m_Num;
	return cout;
}

void test() {
	MyInterger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}
void test02() {
	MyInterger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}

int main() {
	test();
	//cout << "__________" << endl;
	//int a = 0;
	//cout << ++(++a) << endl;
	//cout << a << endl;//操作a这个数，一直都是它，也就是为什么我们前置递增用引用
	//cout << "__________" << endl;
	test02();
	system("pause");
	return 0;
}

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

4.赋值运算符重载

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

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

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

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

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

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

#include<iostream>
using namespace std;
#include<string>
//赋值运算符重载
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);
		//返回对象本身 这样才能进行多次赋值 a = b = c ...
		return *this;
	}
	int* m_Age;
};



void test() {
	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() {
	//int a = 10;
	//int b = 20;
	//int c = 30;
	//c = b = a;
	//cout << " a = " << a << endl;
	//cout << " b = " << b << endl;
	//cout << " c = " << c << endl;
	test();
	system("pause");
	return 0;
}

5.关系运算符重载

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

#include<iostream>
using namespace std;
#include<string>
//重载关系运算符
class Person {
public:
	Person(string name,int age) {
		m_Name = name;
		m_Age = age;
	}
	string m_Name;
	int m_Age;
	bool operator==(Person p) {
		if (p.m_Age == this->m_Age && p.m_Name == this->m_Name)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator!=(Person p) {
		if (p.m_Age == this->m_Age && p.m_Name == this->m_Name)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
};



void test() {
	Person p1("Tom", 18);
	Person p2("Tom", 18);
	if (p1 == p2)
	{
		cout << "两对象相同" << endl;
	}
	else
	{
		cout << "两对象不相同" << endl;
	}
}
void test1() {
	Person p1("Tom", 18);
	Person p2("Jerry", 18);
	if (p1 != p2)
	{
		cout << "两对象不相同" << endl;
	}
	else
	{
		cout << "两对象相同" << endl;
	}
}
int main() {
	test();
	test1();
	system("pause");
	return 0;
}

6.函数调用运算符重载

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

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

仿函数没有固定写法，非常灵活

#include<iostream>
using namespace std;
#include<string>
//函数调用运算符重载

//打印输出类
class MyPrint {
public:
	//重载函数调用运算符
	void operator()(string test) {
		cout << test << endl;
	}
};
//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd {
public:
	int operator()(int num1, int num2) {
		return num1 + num2;
	}
};
void test() {
	MyPrint mp;
	mp("hello world");//由于使用起来非常类似于函数，因此成为仿函数
}
void test1() {
	MyAdd md;
	int result = md(100, 100);
	cout << "result = " << result << endl;

	//匿名函数对象
	cout << MyAdd()(50, 50) << endl;
}
int main() {
	test();
	test1();
	system("pause");
	return 0;
}

21类和对象-继承

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

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

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

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

1.继承的基本语法

#include<iostream>
using namespace std;
#include<string>
//网页
class BasePage {
public:
	void header() {
		cout << "头部" << endl;
	}
	void footer() {
		cout << "底部" << endl;
	}
	void left() {
		cout << "左侧" << endl;
	}
};
//Java页面
class Java: public BasePage {
public:
	void content() {
		cout << "Java学科视频" << endl;
	}
};
//Python页面
class Python : public BasePage {
public:
	void content() {
		cout << "Python学科视频" << endl;
	}
};
//Cpp页面
class Cpp : public BasePage {
public:
	void content() {
		cout << "Cpp学科视频" << endl;
	}
};
/*
继承的好处：减少重复代码
语法：class 子类：继承方式 父类
子类 也称为 派生类
父类 也成为 基类
*/
void test() {
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "Cpp下载视频页面如下：" << endl;
	Cpp c;
	c.header();
	c.footer();
	c.left();
	c.content();
}
int main() {
	test();
	system("pause");
	return 0;
}

总结:

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

class A : public B;

A类称为子类或派生类

B类称为父类或基类

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

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

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

2.继承方式

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

继承方式一共有三种:

公共继承

保护继承

私有继承

#include<iostream>
using namespace std;
#include<string>
//公共继承类
class Base {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son1 : public Base {
public:
	void func() {
		m_A = 100;//父类中的公共权限成员到子类中依然是公共权限
		m_B = 100; //父类中的保护权限成员到子类中依然是保护权限
		//m_C = 10;//父类中的私有权限成员子类访问不到
	}
};
void test01() {
	Son1 s1;
	s1.m_A = 100;
	// s1.m_B = 100;//到Son1中 m_B是保护权限类外访问不到
}
class Son2 : protected Base {
public:
	void func() {
		m_A = 100;//父类中的公共权限成员,到子类中变为保护权限
		m_B = 100; //父类中的保护权限成员，到子类变为保护权限
		//m_C = 10;//父类中的私有权限成员子类访问不到
	}
};
void test02() {
	Son2 s2;
	//s1.m_A = 1000;//在Son2中 m_A变为保护权限﹐因此类外访问不到
	// s1.m_B = 100;//在Son2中 m_B变为保护权限﹐因此类外访问不到
}
class Son3 : private Base {
public:
	void func() {
		m_A = 100;//父类中的公共权限成员,到子类中变为私有成员
		m_B = 100; //父类中的保护权限成员，到子类变为私有成员
		//m_C = 10;//父类中的私有权限成员子类访问不到
	}
};
class GrandSon3 : public Son3 {
	//m_A = 1000;//到了Son3中 m_A变为私有，及时是儿子，也是访问不到
	//m_B = 1000;//到了Son3中 m_B变为私有，及时是儿子，也是访问不到
};
void test03() {
	Son2 s2;
	//s1.m_A = 1000;//在Son2中 m_A变为保护权限﹐因此类外访问不到
	// s1.m_B = 100;//在Son2中 m_B变为保护权限﹐因此类外访问不到
}
int main() {
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

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

//利用开发人员命令提示工具查看对象模型
/*
（如果跟盘符不同的话）跳转盘符 C： 盘符+":"
跳转文件路径 cd具体路径下
查看命名
cl / d1 reportSingleClassLayout类型 "文件名"
注意：cl是字母L d1是数字1
*/

void test01() {
	//父类所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到的，但是确实是被继承下去了
	cout << "size of Son = " << sizeof(Son) << endl;//16
}
int main(){
	test01();
}

利用工具查看：

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

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

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

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;
	cout << "Son:m_A = " << s.m_A << endl;
	cout << "Base:m_A = " << s.Base::m_A << endl;
}
//同名成员函数处理
void test02() {
	Son s;
	s.func();//直接调用 调用是子类的同名函数

	//如何调用到父类中同名成员函数
	s.Base::func(); 

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

总结：

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

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

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

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

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

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

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

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

#include<iostream>
using namespace std;
//继承中的同名静态成员处理方式
//static单独拉出来讲是因为能用类来调用
class Base {
public:
	static int m_A;

	static void func() {
		cout << "Base-static void func()调用" << endl;
	}
	static void func(int a) {
		cout << "Base-static void func(int a )调用" << endl;
	}
};
int Base::m_A = 100;//静态变量在类内类外都能访问到
class Son :public Base {
public:
	static int m_A;

	static void func() {
		cout << "Son-static void func()调用" << endl;
	}
};
int Son::m_A = 200;

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

	//2.通过类名访问
	cout << "通过类名访问" << endl;
	cout << "Son:m_A = " << Son::m_A << endl;
	//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	cout << "Base:m_A = " << Son::Base::m_A << endl;
}
//同名静态成员函数
void test02() {
	Son s;
	//1.通过对象访问
	cout << "通过对象访问" << endl;
	s.func();
	s.Base::func(); 
	//2.通过类名访问
	cout << "通过类名访问" << endl;
	Son::func();
	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	// 如果想访问父类中被隐藏同名成员，需要加作用域
	Son::Base::func();
	Son::Base::func(100);
}
int main(){
	test01();
	test02();
	system("pause");
	return 0;
}

总结:：

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式(通过对象和通过类名)

7.多继承语法

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

语法: class 子类 : 继承方式父类1，继承方式父类2...

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

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

#include<iostream>
using namespace std;
//多继承语法
class Base1 {
public:
	Base1() {
		m_A = 100;
	}
	int m_A;
};

class Base2 {
public:
	Base2() {
		m_A = 200;
	}
	int m_A;//其实可以命名为其他的，但是为了显示出二义性，我们命名跟上面一样
};

//子类 需要继承Base1 和Base2
class Son :public Base1,public Base2 {
public:
	Son() {
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};



void test01() {
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;//16
	//当父类中出现同名成名，需要加作用域区分
	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 Tuo :virtual public Animal {};

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

void test01() {
	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;
	//虽然sheep.age = 18,但最后三个都是输出28，以最后一个修改数据为准
	//这份数据只要有一份就可以了，菱形继承导致数据有两份，资源浪费
}

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

总结：

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

●利用虚继承可以解决菱形继承问题

22类和对象-多态

1.多态的基本概念

多态分为两类

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

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

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

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

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

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

#include<iostream>
using namespace std;
//多态
/*
动态多态满足条件：
1.有继承关系
2.子类重写父类的虚函数
 
 动态多态使用
 //父类的指针或者引用 指向子类对象
*/
//动物类
class Animal{
public:
	//虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};


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

//狗类
class Dog :public Animal {
	void speak() { //这里可以加virtual 也可以不加
		cout << "小狗在说话" << endl;
	}
};
//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话 那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
void doSpeak(Animal& animal) {	//Animal &animal = cat;
	animal.speak();
}


void test01() {
	Cat cat;
	doSpeak(cat);//父类方法如果不加virtual关键字 那么输出“动物在说话”
	Dog dog;
	doSpeak(dog);
	cout << "sizeof(Animal) = " << sizeof(Animal) << endl;
	//不加virtual关键字，容量为一字节，加了virtual关键字，容量为四字节->联想到指针
}

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

总结：

多态满足条件：

1.有继承关系

2.子类重写父类中的虚函数

多态使用条件：

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

重写:函数返回值类型函数名参数列表完全—致称为重写

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

//实现计算器抽象类
class AbstractCalculator {
public:
	virtual int getResult() {
		return 0;
	}
	int m_Num1;
	int m_Num2;
};

//加法计算器类
class AddCaicular :public AbstractCalculator {
public:
	int getResult() {
		return m_Num1 + m_Num2;
		}
};
//减法计算器类
class SubCaicular :public AbstractCalculator {
public:
	int getResult() {
		return m_Num1 - m_Num2;
	}
};
//乘法计算器类
class MulCaicular :public AbstractCalculator {
public:
	int getResult() {
		return m_Num1 * m_Num2;
	}
};
void test01() {
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 20;
	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;

}

void test02() {
	//多态使用条件
	//父类指针或者引用指向其子类对象
	//加法运算
	AbstractCalculator* abc = new AddCaicular;
	abc->m_Num1 = 100;
	abc->m_Num2 = 200;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完记得销毁
	delete abc;
	//减法运算
	abc = new SubCaicular;
	abc->m_Num1 = 100;
	abc->m_Num2 = 200;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
	//乘法运算
	abc = new MulCaicular;
	abc->m_Num1 = 100;
	abc->m_Num2 = 200;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
}
int main(){
	test01();
	test02();
	system("pause");
	return 0;
}

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

3.纯虚函数和抽象类

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

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

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

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

抽象类特点:

无法实例化对象

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

#include<iostream>
using namespace std;
#include <string>
//纯虚函数和抽象类

class Base {
public:
	
	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类特点：
	//1.无法实例化对象
	virtual void func() = 0;
};

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


void test01() {
	//Base b; 抽象类是无法实例化对象
	//new Base;抽象类是无法实例化对象
	Son s;//如果不重写父类的纯虚函数 那么它也是一个抽象类 无法实例化对象
	//子类必须重写父类中的纯虚函数 否则无法实例化对象
	Base* base = new Son;
}

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

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

案例描述：

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

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

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

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) {//AbstractDrinking* abs = new Coffee
	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;
#include <string>

//虚析构和纯虚析构

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

	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
//	virtual ~Animal()//如果不加virtual的话，那么不会调用子类的析构函数
//	{
//		cout << "Animal析构函数调用" << endl;
//	}
	//纯虚析构 需要声明也需要实现
	//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 0;//纯虚析构只能有一个 所以上面那个注释掉
};
//纯虚析构还要在类外实现声明
Animal::~Animal() {
	cout << "Animal纯虚析构函数调用" << endl;
}


class Cat:public Animal {
public:
	virtual void speak() {
		cout << *m_Name <<  "小猫在说话" << endl;
	}
	Cat(string name) {
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	~Cat()
	{
		if (m_Name != NULL) {
			cout << "Cat析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string* m_Name;
};
void test01() {
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候 不会调用子类中析构函数 导致子类如果有堆区属性，出现内存泄漏
	delete animal;
}

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

总结：

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

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

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

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

案例描述：

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

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

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

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

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

//虚析构和纯虚析构

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

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

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

//电脑类
class Computer {
	//构造函数中传入三个零件指针
public:
	Computer(CPU* cpu,VideoCard* vc,Memory *mem) {
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}
	//提供析构函数 释放3个电脑零件
	~Computer()
	{
		if (m_cpu != NULL) {
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_vc != NULL) {
			delete m_vc;
			m_vc = NULL;
		}
		if (m_mem != NULL) {
			delete m_mem;
			m_mem = NULL;
		}
	}
	void Work() {
		//让零件工作起来，调用接口
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	}
private:
	CPU* m_cpu;
	VideoCard* m_vc;
	Memory* m_mem;
};

//具体零件厂商
//Inter厂商
class InterCPU :public CPU {
	void calculate() {
		cout << "Inter的厂商CPU开始计算了" << endl;
	}
};
class InterVC :public VideoCard {
	void display() {
		cout << "Inter的厂商显卡开始显示了" << endl;
	}
};
class InterMem :public Memory {
	void storage() {
		cout << "Inter的厂商存储器开始存储了" << endl;
	}
};
//Lenovo厂商
class LenovoCPU :public CPU {
	void calculate() {
		cout << "Lenovo的厂商CPU开始计算了" << endl;
	}
};
class LenovoVC :public VideoCard {
	void display() {
		cout << "Lenovo的厂商显卡开始显示了" << endl;
	}
};
class LenovoMem :public Memory {
	void storage() {
		cout << "Lenovo的厂商存储器开始存储了" << endl;
	}
};



void test01() {
	//创建第一台电脑
	cout << "第一台电脑" << endl;
	Computer* computer1 = new Computer(new LenovoCPU,new LenovoVC,new LenovoMem);
	computer1->Work();
	delete computer1;//我new出来的cpu、vc、men在堆区没有释放
	//那么我们就通过computer的析构函数来释放
	//第二台电脑"
	cout << "第二台电脑" << endl;
	CPU* cpu1 = new InterCPU();
	VideoCard* vc1 = new InterVC();
	Memory* mem1 = new InterMem();
	Computer* computer2 = new Computer(cpu1, vc1, mem1);
	computer2->Work();
	//创建第一台电脑
	cout << "第三台电脑" << endl;
	Computer* computer3 = new Computer(new LenovoCPU, new InterVC, new LenovoMem);
	computer3->Work();
}

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

23文件操作

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

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

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

文件类型分为两种：

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

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

操作文件的三大类：

1.ofstream:写操作

2. ifstream:读操作

3.fstream :读写操作

1.文本文件-写操作

写文件步骤如下：

1.包含头文件

#include <fstream>

2.创建流对象

ofstream ofs;

3.打开文件

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

4.写数据

ofs <<"写入的数据";

5.关闭文件

ofs.close();

文件打开方式：

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

例如:用二进制方式写文件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);//相对路径创建在当前目录的test.txt

	//4.写内容
	ofs << "姓名：张三" << endl;
	ofs << "性别：男" << endl;
	ofs << "年龄：18" << endl;

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

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

总结：

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

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

·打开文件时候需要指定操作文件的路径，以及打开方式·利用<<可以向文件中写数据

·操作完毕，要关闭文件

2.文本文件-读文件

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

读文件步骤如下：

1.包含头文件

#include <fstream>

2.创建流对象

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

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

4.读数据

四种方式读取

5.关闭文件

ifs.close();

#include<iostream>
using namespace std;
#include <fstream>//头文件包含
#include<string>

//文本文件 读文件

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

	//2.创建流对象
	ifstream ifs;

	//3.打开文件 并且判断是否打开成功
	ifs.open("test.txt", ios::in);

	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
		return;
	}
	//4.读数据
	//第一种
	//char buf[1024] = { 0 };
	//while (ifs >> buf)// 一行一行数据读，存到buf里，当读不到数据的时候，返回False，退出循环
	//{
	//	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)//EPF end of file
	{
		cout << c;
	}
}

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

总结：

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

利用is_open函数可以判断文件是否打开成功.

close关闭文件

3.二进制文件-写文件

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

打开方式要指定为ios::binary

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

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

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

#include<iostream>
using namespace std;
#include <fstream>//头文件包含
#include<string>

//二进制文件 写文件

class Person {
public:
	char m_Name[64];//姓名
	int m_Age;//年龄

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

	//2.创建流对象
	ofstream ofs("person.txt", ios::out | ios::binary);

	//3.打开文件
	//ofstream ofs;
	//ofs.open("person.txt", ios::out | ios::binary);
	//2.创建流对象那一步已经在创建对象的时候打开了 所以3可以省略
	
	//4.写文件
	Person p = { "张三",18 };
	ofs.write((const char*)&p, sizeof(Person));

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

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

总结：

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

4.二进制文件-读文件

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

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

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

#include<iostream>
using namespace std;
#include <fstream>//头文件包含
#include<string>

//二进制文件 读文件

class Person {
public:
	char m_Name[64];//姓名
	int m_Age;//年龄

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

	//2.创建流对象
	ifstream ifs;

	//3.打开文件 判断文件是否打开成功
	ifs.open("person.txt", ios::in | ios::binary);

	if (!ifs.is_open())//结果返回布尔类型 所以不要写==null
	{
		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函数，以二进制方式读教据