一、基本概念

多态的使用：

案例一——计算机类

多态的优点：

二、纯虚函数与抽象类

特点：

①无法实例化对象

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

案例二——制作饮品

三、虚析构与纯虚析构

因为父类指针在析构时，不会调用子类中的析构函数，从而导致堆区属性未释放

解决：将父类虚构改为虚析构

案例三——电脑组装

一、基本概念

多态是C++三大特性之一

分为、作用与区别：

	作用	区别
静态多态	函数重载和运算符重载，复用函数名	函数地址早绑定，编译阶段确定函数地址
动态多态	派生类和虚函数实现运行时多态	函数地址晚绑定，运行阶段确定函数地址

动态多态需要满足：

①有继承关系

②子类重写父类的虚函数

重写：子类的返回值函数名形参列表要与父类完全相同，但virtual可写可不写

多态的使用：

父类指针或引用子类对象

例：

创建Animal与Cat与Dog类，其中每个都有dodif函数，最后单独实现dodif函数，创建测试函数并调用dodif函数

class Animal
{
public:
	void dodif()
	{
		cout << "动物" << endl;
	}
};
class Cat : public Animal
{
public:
	void dodif()
	{
		cout << "小猫" << endl;
	}
};
class Dog : public Animal
{
public:
	void dodif()
	{
		cout << "小狗" << endl;
	}
};
void dodif(Animal &animal)// Animal &animal = 子类传来的对象; 多态的使用
{
	animal.dodif();
}
void test01()
{
	Cat cat;
	dodif(cat);
    Cat dog;
	dodif(dog);
}

可以发现，无论我传参是什么，结果总是输出动物，也就是调用父类中的函数

这是因为dodif函数是静态多态，地址早绑定，在编译阶段就确定了函数地址，因此后面我怎么传参都是访问已经确定的函数地址

因此需要改为动态多态：父类中，函数前加virtual，使其变成虚函数，地址晚绑定

class Animal
{
public:
	virtual void dodif() // 虚函数
	{
		cout << "动物" << endl;
	}
};

接下来深度分析一下上面代码的实现逻辑：

首先，没有加virtual时，我们输出一下父类的大小

结果是1，说明是个空对象

加上virtual，再次输出

变成8，其实是变成了一个指针，即 虚函数指针cfptr

接下来，画出Animal类的内部结构

使用开发人员命令提示符工具查看

然后是，继承的Cat类的内部结构，此时并无重写

虚函数表内仍然是&Animal::dodif

而当我们加上重写后

虚函数表内就改成了&Cat::dodif

因为重写后，子类中的虚函数表会被替换成子类的虚函数地址

案例一——计算机类

使用普通方法和多态2种方法实现计算器类

①普通方法

class caculator
{
public:
	int getResult()
	{
		cin >> num1 >> oper >> num2;
		if (oper == "+")
		{
			return num1 + num2;
		}
		else if (oper == "-")
		{
			return num1 - num2;
		}
		else if (oper == "*")
		{
			return num1 * num2;
		}
	}
	string oper;
	int num1;
	int num2;
};
void test01()
{
	caculator c;
	int ret = c.getResult();
	cout << ret << endl;
}

现在实现了加法、减法和乘法三种功能，但是如果想要增加功能，则需要修改源码

实际开发中提倡开闭原则：对扩展进行开放，对修改进行关闭

②多态的方法

class caculator_abstract // 计算器抽象类
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int num1;
	int num2;
};

class Add:public caculator_abstract  // 加法 Addition
{
	int getResult()
	{
		return num1 + num2;
	}
}; 
class Sub :public caculator_abstract // 减法 subtraction
{
	int getResult()
	{
		return num1 - num2;
	}
};
class Mul :public caculator_abstract // 乘法 multiplication
{
	int getResult()
	{
		return num1 * num2;
	}
};
class Div :public caculator_abstract // 除法 division
{
	int getResult()
	{
		return num1 / num2;
	}
};

调用

void test02()
{
	// 多态的使用方法：
	//父类指针或者引用子类对象
	caculator_abstract* c = new Add; // 加法调用
	c->num1 = 10;
	c->num2 = 5;
	cout << c->getResult() << endl;
	delete c;// 堆区的数据，记得销毁

	c = new Sub;
	c->num1 = 10;
	c->num2 = 5;
	cout << c->getResult() << endl; // 减法调用
	delete c;

	c = new Mul;
	c->num1 = 10;
	c->num2 = 5;
	cout << c->getResult() << endl; // 乘法调用
	delete c;

	c = new Div;
	c->num1 = 10;
	c->num2 = 5;
	cout << c->getResult() << endl; // 除法调用
	delete c;
}

多态的优点：

①组织结构清晰

②可读性强

③对于扩展以及维护能力高

二、纯虚函数与抽象类

在多态中，通常父类中虚函数的实现没有什么意义，主要是调用子类重写的内容

因此可将父类中的虚函数改为纯虚函数

纯虚函数：写一个虚函数，使其 = 0，即为纯虚函数

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

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

特点：

①无法实例化对象

class Base
{
public:
	virtual void func() = 0;
};

void test01()
{
	Base b;
	new Base;
}

无论是栈上还是堆区都无法实例化对象

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

首先，不重写：

class Son :public Base
{
public:
	
};

void test01()
{
	Son s;
	new Son;
}

一样的无法实例化对象

加上重写

class Son :public Base
{
public:
	virtual void func() {}; // 重写
};

即使重写是空实现，仍然可以实例化对象

简单修改一下

class Son :public Base
{
public:
	virtual void func() 
	{
		cout << "Son_func的调用" << endl;
	}; // 重写
};

void test01()
{
	Son s;
	s.func();
	 // 多态的方法：
	Base* base = new Son;
	base->func();
}

案例二——制作饮品

简单制作一份饮品，咖啡or沏茶

咖啡：①煮水②冲泡咖啡③倒入杯中④加糖与牛奶

沏茶：①煮水②冲泡茶叶③倒入杯中④加柠檬

流程大致相同：①煮水②冲泡③倒入杯中④加佐料

class AbstactDrinking // 抽象类的饮品
{
public:
	virtual void Boil() = 0;
	virtual void Brew() = 0;
	virtual void Pour() = 0;
	virtual void Put() = 0;
	void makeDriking()
	{
		Boil();
		Brew();
		Pour();
		Put();
	}
};
class tea :public AbstactDrinking // 茶的具体实现
{
public:
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	virtual void Pour()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void Put() 
	{
		cout << "加柠檬" << endl;
	}
};
class coffee :public AbstactDrinking // 咖啡的具体实现
{
public:
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	virtual void Pour()
	{
		cout << "倒入杯中" << endl;
	}
	virtual void Put()
	{
		cout << "加糖与牛奶" << endl;
	}
};
void doDrinking(AbstactDrinking* abd)
{
	abd->makeDriking();
	delete abd; // new出的堆区数据，记得销毁
}
void test01()
{
	doDrinking(new tea);
	cout << "-----------------" << endl;
	doDrinking(new coffee);
}

没啥说的

三、虚析构与纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码，导致子类的堆区属性未被释放，引起内存泄漏

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

	共同点	不同点
虚析构	可以解决父类指针释放子类对象	\
纯虚析构	都需要有具体的函数实现	属于抽象类，无法实例化对象

语法：

虚析构	virtual~类名() {}；
纯虚析构	virtual~类名() = 0 ；声明类名 : : 类名() {} ；实现

接下来创建父类Animal类与子类Cat类

class Animal
{
public:
	virtual void speak() = 0;
};
class Cat:public Animal
{
public:
	virtual void speak()
	{
		cout << "小猫" << endl;
	}
};
void test01()
{
	Animal* animal = new Cat;
	animal->speak();
	delete animal;
}

接下来在Cat类中增加string属性c_name；

class Cat:public Animal
{
public:
	Cat(string name)
	{
		c_name = new string(name); // 堆区创建，应有释放
	}
	virtual void speak()
	{
		cout << *c_name << "小猫" << endl;
	}
	string *c_name;
};
void test01()
{
	Animal* animal = new Cat("yomi");
	animal->speak();
	delete animal;
}

而c_name是堆区开辟的内存，应有释放，补全Cat的析构：

	~Cat()
	{
		if (c_name != NULL)
		{
			cout << "Cat的析构" << endl;
			delete c_name;
			c_name = NULL;
		}
	}

同时，我们把父类Animal的析构和构造以及子类Cat的构造也补全：

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造" << endl;
	}
	~Animal()
	{
		cout << "Animal的析构" << endl;
	}
	virtual void speak() = 0;
};
class Cat:public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat的构造" << endl;
		c_name = new string(name); // 堆区创建，应有释放
	}
	virtual void speak()
	{
		cout << *c_name << "小猫" << endl;
	}
	string *c_name;

	~Cat()
	{
		if (c_name != NULL)
		{
			cout << "Cat的析构" << endl;
			delete c_name;
			c_name = NULL;
		}
	}
};

运行可以发现，没有子类Cat的析构，说明堆区new出的c_name属性并未释放

因为父类指针在析构时，不会调用子类中的析构函数，从而导致堆区属性未释放

解决：将父类虚构改为虚析构

	virtual ~Animal()
	{
		cout << "Animal的析构" << endl;
	}

就走了子类的析构

接下来实现纯虚析构

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造" << endl;
	}

	virtual ~Animal() = 0; // 纯虚析构

	virtual void speak() = 0; // 虚函数
};

如果只在父类中写 virtual ~Animal() = 0; 运行将报错

因为这个相当于声明，没有实现

接下来在类外实现纯虚析构的实现

Animal::~Animal() // 纯虚析构的实现
{
	cout << "Animal的纯虚析构" << endl;
}

因为如果父类有开辟堆区的属性，也需要释放，因此需要纯虚析构的实现

同时，当类中有了纯虚析构，这个类也属于抽象类，无法实例化对象

总结：

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

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

③纯虚析构的类也属于抽象类，无法实例化对象

案例三——电脑组装

电脑主要组成部件是处理器（计算）+显卡（显示）+内存条（存储）

将每个零件封装成抽象基类，并提供不同的厂商生产不同的零件

class CPU
{
public:
	// 抽象计算函数
	virtual void calculate() = 0;
};
class GraphicsCard
{
public:
	// 抽象显示函数
	virtual void display() = 0;
};
class Memory
{
public:
	// 抽象存储函数
	virtual void storage() = 0;
};

具体厂商零件：

// 具体零件厂商
// 1、Inter
class InterCPU :public CPU
{
	virtual void calculate()
	{
		cout << "Inter_CPU" << endl;
	}
};
class InterGPU :public GraphicsCard
{
	virtual void display()
	{
		cout << "Inter_GPU" << endl;
	}
};
class InterRAM :public Memory
{
	virtual void storage()
	{
		cout << "Inter_RAM" << endl;
	}
};
// 2、lenovo
class LenovoCPU :public CPU
{
	void calculate()
	{
		cout << "Lenovo_CPU" << endl;
	}
};
class LenovoGPU :public GraphicsCard
{
	void display()
	{
		cout << "Lenovo_GPU" << endl;
	}
};
class LenovoRAM :public Memory
{
	void storage()
	{
		cout << "Lenovo_RAM" << endl;
	}
};

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

// 电脑类的实现
class Computer
{
public:
	Computer(CPU* cpu, GraphicsCard* gpu, Memory* ram)
	{
		c_cpu = cpu;
		c_gpu = gpu;
		c_ram = ram;
	}
	void dowork() // 工作接口
	{
		c_cpu->calculate();
		c_gpu->display();
		c_ram->storage();
	}
private:
	CPU* c_cpu;
	GraphicsCard* c_gpu;
	Memory* c_ram;
};

测试时组装3种不同的电脑进行工作

void test01()
{
	// 创建第一台电脑的零件
	CPU* interCpu = new InterCPU;
	GraphicsCard* interGpu = new InterGPU;
	Memory* interRam = new InterRAM;
	// 创建第一台电脑
	Computer* computer1 = new Computer(interCpu, interGpu, interRam);
	computer1->dowork(); // 调用工作函数
	delete computer1;
}

在computer1工作完后，我们将其delete，但仍有一个问题：

上面new出的3个零件尚未delete，下面有2个方法

①在最后delete computer后，接着delete3个零件

②在电脑类中，提供析构函数，释放3个零件，下面实现方法②

	~Computer()
	{
		if (c_cpu != NULL) // 释放cpu
		{
			delete c_cpu;
			c_cpu = NULL;
		}
		if (c_gpu != NULL) // 释放gpu
		{
			delete c_gpu;
			c_gpu = NULL;
		}
		if (c_ram!= NULL) // 释放ram
		{
			delete c_ram;
			c_ram = NULL;
		}
	}

这样就解决了堆区的问题

创建另外2台电脑

2：

void test01()
{
		// 创建第二台电脑的零件
	CPU* lenovoCpu = new LenovoCPU;
	GraphicsCard* lenovoGpu = new LenovoGPU;
	Memory* lenovoRam = new LenovoRAM;
	// 创建第二台电脑
	Computer* computer2 = new Computer(lenovoCpu, lenovoGpu, lenovoRam);
	computer2->dowork(); // 调用工作函数
	delete computer2;
}

3：

	// 创建第三台电脑的零件
	CPU* InterCpu = new InterCPU;
	GraphicsCard* InterGpu = new InterGPU;
	Memory* lenovoRam = new LenovoRAM;
	// 创建第三台电脑
	Computer* computer3 = new Computer(InterCpu, InterGpu, lenovoRam);
	computer3->dowork(); // 调用工作函数
	delete computer3;