黑马：多态（135~142）

1.多态的基本概念

多态分为两类：

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

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

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

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

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

#include
using namespace std;
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

//多态

//动物类
class Animal {
public: 
	virtual void speak() {   //变成虚函数实现晚绑定
		cout << "动物在说话" << endl;
	}
};

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

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

//动态多态满足条件
// 1.有继承关系
// 2.子类要重写(函数返回值和参数列表完全相同）父类的虚函数（都是speak）

//动态多态使用
// 父类的指针或引用执行子类对象（Animal &animal）


//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果要让猫说话 就要让函数地址不能提前绑定，需要在运行阶段绑定，即晚绑定
void doSpeak(Animal &animal) {
	animal.speak();
}

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

	Dog dog;
	doSpeak(dog);
}



int main(int argc,char**argv) {
		
	test01();

	system("pause");
	return  0;
}

2.动态的原理剖析

3.多态案例一计算器类

多态的优点：

代码组织结构清晰

可读性强

利于前期和后期的扩展以及维护

#include
using namespace std;
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

//分别利用普通写法和多态写计算器

//普通写法

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



//利用多态实现计算器

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

	int m_Num1;
	int m_Num2;
};

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

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

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

void test02() {
	//多态使用条件：父类的引用或指针指向子类对象

	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁（new，开辟在堆区，手动创造手动释放）
	delete abc;

	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
	delete abc;

	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
	delete abc;
}

//多态的好处
//1.组织结构清晰
//2.可读性强
//3.对于前期和后期的拓展以及维护性高
int main(int argc,char**argv) {
		
	//test01();
	test02();

	system("pause");
	return  0;
}

4.纯虚函数和抽象类

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

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

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

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

抽象类特点

无法实例化对象

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

#include
using namespace std;
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

//纯虚函数和抽象类
class base {
public:
	//纯虚函数
	//只要有一个纯虚函数 这个类就是抽象类
	
	virtual void func() = 0;
};

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

void test01() {
	//抽象类不允许实例化对象
	// base b;   报错 栈区不行
	// new base; 报错 堆区也不行

	//Son s 如果25到27行什么也不写（即没有重写父类中的纯虚函数，也将无法实例化对象，这行会报错）

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

}

int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

5.多态案例二制作饮品

#include
using namespace std;
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

class AbstractDrinking {
public:
	//煮水
	virtual void Boil() = 0;

	//冲泡
	virtual void Brew() = 0;

	//倒入杯中
	virtual void PourInCup() = 0;

	//加入辅料
	virtual void PutSomething() = 0;

	//制作饮品
	void makeDrink() {
		Boil();
		Brew();
		PourInCup();
		PutSomething();

	}
};

 //制作咖啡
class Coffee :public AbstractDrinking {
public:
	//煮水
	virtual void Boil() {
		cout << "煮农夫山泉" << endl;
	}

	//冲泡
	virtual void Brew() {
		cout << "冲泡咖啡" << endl;
	}

	//倒入杯中
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}

	//加入辅料
	virtual void PutSomething() {
		cout << "加入牛奶和咖啡" << endl;
	}

};

//制作茶叶
class Tea :public AbstractDrinking {
public:
	//煮水
	virtual void Boil() {
		cout << "煮矿泉水" << endl;
	}

	//冲泡
	virtual void Brew() {
		cout << "冲泡茶叶" << endl;
	}

	//倒入杯中
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}

	//加入辅料
	virtual void PutSomething() {
		cout << "加入枸杞" << endl;
	}

};

//制作函数
void doWork(AbstractDrinking * abs) {
	abs->makeDrink(); //多态 同一个接口 传入不同的饮品
	delete abs;
}

void test01() {
	//制作咖啡
	doWork(new Coffee);

	cout << "-----------------------------" << endl;

	//制作茶叶
	doWork(new Tea);
}
int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

6.虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

1.可以解决父类指针释放子类对象

2..都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名（）=0；

类名：：~类名（）{}

#include
using namespace std;
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

//虚析构和纯虚析构
class Animal {
public:

	Animal() {
		cout << "Animal构造函数调用" << endl;
	}

	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	

	//我把上面的虚析构函数体注释了，因为虚析构和纯虚析构只能有一个

	//纯虚析构
	virtual ~Animal() = 0;   //因为没有类似24行所调用的函数体，只靠这一行的声明是不够的，还需要36行的实现

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

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

class Cat :public Animal {
public:
	Cat(string name) {
		cout << "cat构造函数调用" << endl;
		m_Name = new string(name); 
	}

	 virtual 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("Tom");
	animal->speak();
	//父类指针在析构时候 不会调用子类中析构函数，导致子类中如果有堆区属性，会出现内存泄漏；
	delete animal;
	
}
int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

总结：

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

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

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

7.多态案例三电脑组装

#include
using namespace std;
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

//抽象不同零件类
//抽象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() {
		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;
	VideoCard* m_vc;
	Memory* m_mem;

};


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

class InterVideoCard :public VideoCard{
public:
	virtual void display() {
		cout << "Inter的显卡开始显示了！" << endl;
	}
};


class InterMemory :public Memory{
public:
	virtual void storage() {
		cout << "Inter的内存条开始存储了！" << endl;
	}
};



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

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


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


void test01() {
		//第一台电脑
		CPU* intercpu = new InterCPU;
		VideoCard* intercard = new InterVideoCard;
		Memory* intelmem = new InterMemory;

		//创建第一台电脑
		cout << "第一台电脑开始工作" << endl;
		Computer* computer1 = new Computer(intercpu, intercard, intelmem);
		computer1->work();
		delete computer1;

		cout << "-----------------" << endl;

		//创建第二台电脑
		cout << "第二台电脑开始工作" << endl;	
		Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
		computer2->work();
		delete computer2;
		

	}

int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

黑马：多态（135~142）

C/C++/C#相关栏目本月热门文章