类与对象（二）——超详细代码讲解

本文链接：https://blog.csdn.net/qq_59702185/article/details/126143858

5. 运算符重载

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

5.1 加法运算符重载

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

class Person
{
public:
	int m_A;
	int m_B;
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 运算符重载
	//Person operator+(const Person& p)
	//{
	//	Person temp;
	//	temp.m_A = this->m_A + p.m_A;
	//	temp.m_B = this->m_B + p.m_B;
	//	return temp;
	//}
};

//全局函数实现 + 运算符重载
Person operator+(const Person& p1, const Person& p2)
{
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

//运算符重载也可以发生函数重载
Person operator+(const Person& p, int val)
{
	Person temp;
	temp.m_A = p.m_A + val;
	temp.m_B = p.m_B + val;
	return temp;
}

void test01()
{
	Person p1(10, 10);
	Person p2(20, 20);
	//成员函数方式
	Person p3 = p2 + p1;//相当于 p2.operator+(p1)
	cout << "mA: " << p3.m_A << " mB: " << p3.m_B << endl;

	Person p4 = p3 + 10;//相当于 operator+（p3,10）
	cout << "mA: " << p4.m_A << " mB: " << p4.m_B << endl;
}

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

总结①：对于内置的数据类型的表达式的运算符是不可以改变的
总结②：不要滥用运算符重载

5.2 左移运算符重载

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

class Person
{
	friend ostream& operator<<(ostream& cout, Person& p);
private:
	int m_A;
	int m_B;
public:
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现不了 p << cout 不是我们想要的结果
	//void operator<<(Person& p)
	//{

	//}
};
//全局函数实现 << 运算符
//ostream 对象只能有一个
ostream& operator<<(ostream& cout, Person& p)
{
	cout << "a: " << p.m_A << " b: " << p.m_B;
	return cout;
}

void test01()
{
	Person p1(10, 20);
	cout << p1 << endl;
}

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

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

5.3 递增运算符重载

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

class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
private:
	int m_Num;
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//前置++ 
	MyInteger& operator++()
	{
		//先++
		m_Num++;
		//再返回
		return *this;
	}
	//后置++
	MyInteger operator++( int )//占位参数 防止报错
	{
		//先返回
		MyInteger temp = *this;//记录当前本身的值，然后让本身的值+1，返回的是以前的值
		m_Num++;
		return temp;//返回局部引用 非法操作
	}
};

ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}
//前置++ 先++ 再返回
void test01()
{
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02()
{
	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

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

5.4 赋值运算符重载

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

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

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

示例：

class Person
{
public:
	int* m_Age;//年龄的指针
public:
	Person(int age)
	{
		m_Age = new int(age);//将年龄的数据开辟到堆区
	}
	//重载赋值运算符
	Person& operator=(Person& p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);
		//返回自身
		return *this;
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
};

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(25);
	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.5 关系运算符重载

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

class Person
{
public:
	string m_Name;
	int m_Age;
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	bool operator==(Person& p)
	{
		if (this->m_Age == p.m_Age && this->m_Name == p.m_Name)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};

void test01()
{
	Person a("yxc", 18);
	Person b("yxc", 18);
	if (a == b)
	{
		cout << "a与b相等" << endl;
	}
	else
	{
		cout << "a与b不相等" << endl;
	}
}

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

5.6 函数调用运算符重载

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

示例：

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}
};

class MyAdd
{
public:
	int operator()(int val1, int val2)
	{
		return val1 + val2;
	}
};

void test01()
{
	MyPrint my;
	my("hello world");

	MyAdd my1;
	int ret = my1(10, 10);
	cout << "ret = " << ret << endl;
}

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

6. 继承

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

有些类与类之间存在特殊的关系，我们在定义某些类时，下级别的成员出了拥有上一级的共性，还有自己的特性。
这时候，我们就可以考虑利用继承的技术，减少重复的代码。

6.1 继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，公共的左侧列表，只有中心内容不同。
如果，我们没有学过继承的语法，那么我们就可能把每个类都加上头部、底部、左侧列表和中心内容，而我们要是学过继承的语法后，就可以在每个类中只写中心部分就可以了。

在这里插入图片描述

继承实现：

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册……（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图……（公共尾部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++……（公共分类列表）" << endl;
	}
};

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

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

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

void test01()
{
	//Java页面
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "----------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "----------------------" << endl;

	//CPP页面
	cout << "CPP下载视频页面如下：" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
	cout << "----------------------" << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

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

class A : public B;

A称为子类或派生类

B称为父类或基类

派生类中的成员，包含两部分：一类是自己增加的成员，一类是从基类继承过来的。

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

6.2 继承方式

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

继承方式一共有三种：

公共继承
保护继承
私有继承

在这里插入图片描述

示例：

class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
//公共继承
class Son1 : public Base1
{
public:
	void func()
	{
		m_A;//可访问public权限
		m_B;//可访问protected权限
		//m_C;//不可访问
	}
};
void myClass1()
{
	Son1 s1;
	s1.m_A;//其他类只能访问到公共权限
}

//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 : protected Base2
{
	void func()
	{
		m_A;//可访问public权限
		m_B;//可访问protected权限
		//m_C;//不可访问
	}
};
void myClass2()
{
	Son2 s2;
	//s1.m_A;//不可以访问
}
//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 : private Base3
{
	void func()
	{
		m_A;//可访问public权限
		m_B;//可访问protected权限
		//m_C;//不可访问
	}
};
class GrandSon3 : public Son3
{
	void func()
	{
		//Son是私有继承，所以Son3的属性在GrandSon3中无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};

6.3 继承中的对象模型

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

从父类继承过来的，public、protected、private都属于子类对象

示例：

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son : public Base
{
public:
	int m_D;
};
void test01()
{
	cout << "sizeof(Son): " << sizeof(Son) << endl;//16
}
int main()
{
	test01();
	system("pause");
	return 0;
}

6.4 继承中构造和析构顺序

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

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

示例：

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

总结：继承中，先调用父类构造函数，再调用子类构造函数，析构函数和构造函数相反

6.5 继承同名成员处理方式

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

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

示例：

class Base
{
public:
	int m_A;
public:
	Base()
	{
		m_A = 20;
	}
	void func()
	{
		cout << "Base-func()调用" << endl;
	}
	void func(int a)
	{
		cout << "Base-func(int a)调用" << endl;
	}
};
class Son : public Base
{
public:
	int m_A;
public:
	Son()
	{
		m_A = 100;
	}
	//当子类与父类拥有同名的成员函数，子类会隐藏父类所以版本的同名成员函数
	//如果想访问父类中隐藏的同名成员函数，需要加父类的作用域
	void func()
	{
		cout << "Son-func()调用" << endl;
	}
};
void test01()
{
	Son s;
	cout << "Base下的m_A: " << s.Base::m_A << endl;
	cout << "Son下的m_A: " << s.m_A << endl;

	s.func();
	s.Base::func();
	s.Base::func(10);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

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

6.6 继承同名静态成员函数处理方式

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

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

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

示例：

class Base
{
public:
	static int m_A;
public:
	static void func()
	{
		cout << "Base-static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base-static void fun(int a)" << endl;
	}
};
int Base::m_A = 10;
class Son : public Base
{
public:
	static int m_A;
public:
	static void func()
	{
		cout << "Son-static void func()" << endl;
	}
};
int Son::m_A = 100;
//同名成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	cout << "Son下m_A: " << s.m_A << endl;
	cout << "Base下m_A: " << s.Base::m_A << endl;
	//通过类名访问
	cout << "通过类名访问" << endl;
	cout << "Son下m_A: " << Son::m_A << endl;
	cout << "Base下m_A: " << Base::m_A << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问方式（通过对象和通过类名）

6.7 多继承语法

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

语法：class 子类：继承方式父类1，继承方式父类2……

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

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

示例：

class Base1
{
public:
	int m_A;
public:
	Base1()
	{
		m_A = 100;
	}
};
class Base2
{
public:
	int m_A;
public:
	Base2()
	{
		m_A = 200;
	}
};
class Son : public Base2, public Base1
{
public:
	int m_C;
	int m_D;
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
};
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

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

6.8 菱形继承

菱形继承概念：

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

在这里插入图片描述

菱形继承问题：

B继承了A的数据，C也继承了A的数据，当D使用数据时，就会产生二义性
D继承A的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以了

示例：

class A
{
public:
	int m_A;
};
//继承前加入关键字 virtual 后，边成虚基类
//此时，公共的父类A称为虚基类
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};
void test01()
{
	D d;
	d.B::m_A = 100;
	d.C::m_A = 200;

	cout << "d.B::m_A: " << d.B::m_A << endl;
	cout << "d.C::m_A: " << d.C::m_A << endl;
	cout << "d.m_A: " << d.m_A << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

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

7. 多态

7.1 多态的基本概念

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

多态分为两类：

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

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

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

示例：

#include <iostream>
using namespace std;

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

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

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

//我们希望传入什么对象，就调用对应对象的函数
//如果函数地址在编译阶段就能确定，那么就是静态联遍
//如果函数地址在运行阶段就能确定，那么就是动态联遍
void doSpeak(Animal& animal)
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);
}

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

在这里插入图片描述
总结：

多态需要满足的条件：

有继承关系
子类复用父类中的虚函数

多态使用条件：

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

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

7.2 多态的案例一：计算机类

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

多态的优点：

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

普通写法：

class Calculator
{
public:
	int m_num1;
	int m_num2;
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;
		}
		//如果还要提供其他的运算，需要修改源代码
	}
};

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

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

多态实现：

//多态实现抽象计算机类
class AbstractCalculator
{
public:
	int m_num1;
	int m_num2;
public:
	virtual int getResult()
	{
		return 0;
	}
};

//加法计算器
class AddCalculator : public AbstractCalculator
{
public:
	int getResult()
	{
		return m_num1 + m_num2;
	}
};

//减法计算器
class SubCalculator : public AbstractCalculator
{
public:
	int getResult()
	{
		return m_num1 - m_num2;
	}
};

//乘法计算器
class MulCalculator : public AbstractCalculator
{
public:
	int getResult()
	{
		return m_num1 * m_num2;
	}
};

void test01()
{
	//创建加法计算器
	AbstractCalculator* a = new AddCalculator;
	a->m_num1 = 10;
	a->m_num2 = 20;
	cout << a->m_num1 << "+" << a->m_num2 << "=" << a->getResult() << endl;
	delete a;//用完记得销毁

	//创建减法计算器
	a = new SubCalculator;
	a->m_num1 = 10;
	a->m_num2 = 20;
	cout << a->m_num1 << "-" << a->m_num2 << "=" << a->getResult() << endl;
	delete a;//用完记得销毁
}

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

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

7.3 纯虚函数和抽象类

在多态中，通常父类中希虚函数是没有任何意义的，主要都是调用子类重写的内容
因此可以将虚函数改写成纯虚函数

纯虚函数语法：virtual 返回值类型函数名（参数列表）= 0；

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

抽象类特点：

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

示例：

class Base
{
public:
	//纯虚函数，类中只要有一个纯虚函数就成为抽象类
	virtual void func() = 0;
};

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

void test01()
{
	Base* base = NULL;
	base = new Son;
	base->func();
	delete base;//记得销毁
}

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

7.4 多态案例二：制作饮品

案例描述：制作饮品的大致流程为：煮水-冲泡-倒入杯中-加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

示例：

//抽象制作饮品
class AbstractDrinking
{
public:
	//烧水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//加入辅料
	virtual void AddSomething() = 0;
	//制作流程
	void MakeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		AddSomething();
	}
};

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

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

//业务函数
void DoWork(AbstractDrinking* drink)
{
	drink->MakeDrink();
	delete drink;
}

void test01()
{
	DoWork(new Coffee);
	cout << "----------------" << endl;
	DoWork(new Tea);
}

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

7.5 虚析构和纯虚析构

在多态的使用中，如果子类中有属性是在堆区开辟的，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改写为虚析构或纯虚析构

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

虚析构语法：virtual ~类名（） {}；

纯虚析构语法：virtual ~类名（）= 0；类名：：~类名（）{}；

示例：

class Animal
{
public:
	Animal()
	{
		cout << "Animal构造函数调用" << endl;
	}
	virtual void speak() = 0;
	//析构函数前加上关键字virtual，变成虚析构函数
	/*virtual ~Animal()
	{
		cout << "Anima虚析构函数调用" << endl;
	}*/
	virtual ~Animal() = 0;
};

Animal::~Animal()
{
	cout << "Animal纯虚析构函数调用" << endl;
}

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

void test01()
{
	Animal* animal = new Cat("Tom");
	animal->speak();
	//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
	//给基类增加一个虚析构函数
	//虚析构函数就是用来解决父类指针释放子类对象
	delete animal;
}

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

总结：

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

7.6 多态案例三：组装电脑

案例描述：电脑主要的组成部件为：CPU（用于计算）、显卡（用于显示）、内存条（用于存储）
将每个零件封装成抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作

示例：

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

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

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

//电脑类
class Computer
{
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	//提供工作的函数
	void work()
	{
		//调用接口，让零件工作起来
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	}
	//提供析构函数，释放三个电脑零件
	~Computer()
	{
		//释放CPU零件
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}
		//释放显卡零件
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}
		//释放内存条零件
		if (m_mem != NULL)
		{
			delete m_mem;
			m_mem = NULL;
		}
	}
private:
	CPU* m_cpu;//CPU的零件指针
	VideoCard* m_vc;//显卡的零件指针
	Memory* m_mem;//内存条的零件指针
};

//具体厂商
//Intel厂商
class IntelCPU : public CPU
{
public:
	void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};

class IntelVideoCard : public VideoCard
{
public:
	void display()
	{
		cout << "Intel的显卡开始显示了" << endl;
	}
};

class IntelMemory : public Memory
{
public:
	void storage()
	{
		cout << "Intel的内存条开始存储了" << endl;
	}
};

//Lenovo厂商
class LenovoCPU : public CPU
{
public:
	void calculate()
	{
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};

class LenovoVideoCard : public VideoCard
{
public:
	void display()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};

class LenovoMemory : public Memory
{
public:
	void storage()
	{
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};

void test01()
{
	//第一台电脑零件
	CPU* intelCpu = new IntelCPU;
	VideoCard* intelVideo = new IntelVideoCard;
	Memory* intelMem = new IntelMemory;
	cout << "第一台电脑开始工作：" << endl;
	//创建第一台电脑
	Computer* computer1 = new Computer(intelCpu, intelVideo, intelMem);
	computer1->work();
	delete computer1;
}

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