C++基础-类与对象(3)

C++类与对象(3)—多态

一个接口有多种形态，传入的对象不一样，同一个接口执行的操作不同

成都创新互联是一家集网站建设,青秀企业网站建设,青秀品牌网站建设,网站定制,青秀网站建设报价,网络营销,网络优化,青秀网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

多态的基本概念

多态分为两类

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

静态多态胡动态多态的区别

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

例子

早绑定

#include          
using namespace std;
class Animal{   //父类
public:
	 void speak(){
		cout << "动物在说话" << endl;
	}
};

class Cat:public Animal{  //子类
public:
	void speak(){
		cout << "小猫在说话" << endl;
	}
};
//地址早绑定
void doSpeak(Animal &animal){  //等价于 Animal &animal = cat;
	animal.speak();	
}
	
void test01(){
	Cat cat;
	doSpeak(cat);//本意输出猫在说话
}

int main(){
	test01();
	return 0;
}

晚绑定（只要在父类的函数前面加一个virtual）

virtual void speak(){
		cout << "动物在说话" << endl;
	}

动态多态的满足条件

有继承关系
子类要重写父类中的虚函数（可以不写virtual，其余完全一样）

动态多态的使用

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

多态的原理剖析

在使用virtual后父类结构改变，多列一个指针（虚函数表指针），指向一个虚函数表，在虚函数表中写着虚函数函数入口地址

子类重写虚函数时，会把原来的虚函数替换成子类新写的虚函数（如果不重写，则虚函数表中的数据和父类是一样的）

所以用父类的引用去指向子类对象时，当调用公共的接口（虚函数）时，会从子类中去寻找确实的函数地址，

多态案例(1)-计算机类

多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的拓展和保护

基础实现

#include          
using namespace std;
class Calculator{//计算器类
public:
	int getResult(string oper){
		if(oper == "+") return m_a + m_b;
		if(oper == "-") return m_a - m_b;
		if(oper == "*") return m_a * m_b;
	}
	int m_a;
	int m_b;
};

void test01(){
	Calculator C;
	C.m_a = 10;
	C.m_b = 10;
	cout << C.m_a << "+" << C.m_b << "=" << C.getResult("+") << endl;
	cout << C.m_a << "-" << C.m_b << "=" << C.getResult("-") << endl;
	cout << C.m_a << "*" << C.m_b << "=" << C.getResult("*") << endl;
}

int main(){
	test01();
	return 0;
}

但是我们发现，这个计算器是没有除法的，要想添加除法，必须去源码中修改，但是

在真实开发中，提倡：开闭原则（对拓张进行开放，对修改进行关闭）

所以我们来用多态的方式来写一下吧

多态实现

//乘法、除法的计算器就不写了
#include          
using namespace std;
class Calculator{ //虚基类
public:
	virtual int getResult(){ //只要个名字，没有任何功能
		return 0; 
	}
	int m_a;
	int m_b;
};

class SonAdd:public Calculator{ //加法类
public:
	int getResult(){
	    return m_a + m_b;
	}	
};

class SonSub:public Calculator{ //减法类
public:
	int getResult(){
		return m_a - m_b;
	}	
};

class SonMul:public Calculator{ //乘法类
public:
	int getResult(){
		return m_a * m_b;
	}	
};

class SonDiv:public Calculator{ //除法类
public:
	int getResult(){
		return m_a / m_b;
	}	
};


void test01(){//这次我们使用指针的方法来指向子类对象
	Calculator * C = new SonAdd;//加法计算器
	C->m_a = 10;
	C->m_b = 10;
	cout << C->m_a << "+" << C->m_b << "=" << C->getResult() << endl;
    delete C;//new在堆区，要记得释放哦
	C = new SonSub; //减法计算器
	C->m_a = 20;
	C->m_b = 20;
	cout << C->m_a << "-" << C->m_b << "=" << C->getResult() << endl;
	delete C;
}

int main(){
	test01();
	return 0;
}

纯虚函数和抽象类

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

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

当类中出现了纯虚函数，这个类就叫做抽象类

语法

virtual 返回值类型 函数名 (参数列表) = 0;

特点

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

例子

#include          
using namespace std;
class Base{//抽象类
public:
	virtual void func() = 0;	
};

class Son:public Base{ //子类
public:
	void func(){ //重写函数是
		cout << "子类重写成功" <func();	
}

int main(){
	test01();
	return 0;
}

多态案例(2)-制作饮品

在原本的代码上稍稍优化了一下

#include          
using namespace std;
class Base{ //抽象类
public:
	virtual void Boll() = 0;
	virtual void Brew() = 0;
	virtual void Pour() = 0;
	virtual void AddSome() = 0;
	
	void make(){//调用制作饮品的函数
		Boll();
		Brew();
		Pour();
		AddSome();
	}
};


class Tea:public Base{//茶类
public:
	void Boll(){
		cout << "1.煮茶水" << endl;
	}
	void Brew(){
		cout << "2.冲泡茶叶" << endl;
	}
	void Pour(){
		cout << "3.倒入茶杯中" << endl;
	}
	void AddSome(){
		cout << "4.加入辅料" << endl;
	}
};

class Coffee:public Base{ //咖啡类
public:
	void Boll(){
		cout << "1.煮水" << endl;
	}
    void Brew(){
	    cout << "2.冲泡咖啡" << endl;
}
    void Pour(){
	    cout << "3.倒入咖啡杯中" << endl;
}
    void AddSome(){
     	cout << "4.加入辅料(牛奶/放糖)" << endl;
}
};

void domake(Base *base){ //多态的实现
	base->make();
	delete base;
}

void test01(){ //制作茶
	domake(new Tea);	
}

void test02(){ //制作咖啡
    //domake(new Coffee);	
	Base * base = new Coffee;
	base->make();
	delete base;
}

void select(){ //选择要制作的饮品
	int i = 0;
	const int j = 3; //最大的制作次数
	while(1){
		cout << "请选择所需要的饮品(您现在最多可以选" << j-i << "次)" << endl;
		string drink;
		cin >> drink;
		if(drink == "茶"){
			test01();
		}else if(drink == "咖啡"){
			test02();
		}else{
			cout << "对不起，您所选的饮品目前没有..." << endl;
		} 
		i += 1;
		if(i == j) break;//达到3次后结束
	}
	return;
}

int main(){
	select();
	return 0;
}

虚析构和纯虚析构

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

所以，我们将父类中的析构函数改为(纯)虚析构

析构和纯虚析构的共性

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

析构和纯虚析构的区别

如果时纯虚析构，该类为抽象类，不可以实例化对象

语法

虚析构：

virtual ~类名(){}

纯虚析构：

virtual ~类名() = 0；//类内
类名::~类名(){}//类外

虚析构

#include
using namespace std;
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;
		m_Name = new string(name);
	}
    ~Cat(){
		if(m_Name != NULL){
			cout << "Cat析构调用" << endl;
			delete m_Name;
			m_Name = NULL;	
		}
    }   
    
	void speak(){
		cout << *m_Name << "小猫会说话" << endl;
	}
	string *m_Name;//要创建在堆区
};

void test01(){
	Animal * animal = new Cat("Tom");
	animal->speak();
	delete animal;	
}

int main(){
	test01();
	return 0;
}

没有调用Cat的析构函数，数据没有清楚干净，可能会造成内存泄露

原因：父类指针指向子类，delete父类时，不会调用子类的析构代码

解决：使用虚析构函数

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

结果

300

纯虚析构

内部要有函数的实现，不能只是下面这样

virtual ~Animal() = 0; //这是错的

看看正确的吧

{//类内声明
    virtual ~Animal() = 0;
}；
//类外定义
Animal::~Animal(){
    cout << "Animal纯虚析构调用" << endl;
};

案例(3)-电脑组装

案例描述：

主要零件时CPU(用于计算)，显卡(用于显示)，内存条(用于存储)

每个零件封装成抽象基类，并且用于不同的厂商生产不同的零件

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

测试时组装3台不同的电脑工作

#include
using namespace std;
class CPU{ //CPU类
public:
	virtual void calculate() = 0;
};

class Card{ //显卡类
public:
	virtual void display() = 0;

};

class Memory{ //内存条类
public:
	virtual void storage() = 0;
};

class Com{  //电脑类
private:
	CPU *m_cpu; //用指针来传入三个零件数据（要用多态嘛）
	Card *m_card;
	Memory *m_memory;
public:
	Com(CPU *cpu,Card *card,Memory *memory){  //有参构造
		m_cpu = cpu;
		m_card = card;
		m_memory = memory;	
	}
	
	void work(){  //调用不同零件的函数
		m_cpu->calculate();
		m_card->display();
		m_memory->storage();
	}
    
	//提供析构函数来释放三个零件
	~Com(){
		if(m_cpu != NULL){
			delete m_cpu;
			m_cpu = NULL;
		}
		if(m_card!= NULL){	
			delete m_card;
			m_card = NULL;
		}
		if(m_memory != NULL){
			delete m_memory;
			m_memory = NULL;
		}  
	}
    
};

//联想厂商
class Lenovo:public CPU,public Card,public Memory{//方法一：三个子类再整合成一个大类,亲测不太好用哎（我不知道该在怎么析构比较好）
public:
	void calculate(){
		cout << "联想的CPU开始计算" << endl;
	}
	
	void display(){
		cout << "联想的显卡开始显示" << endl;
	}

	void storage(){
		cout << "联想的内存条开始存储" << endl;
	}	
};

//苹果厂商
//方法二：把三个子类分开
class AppleCPU:public CPU{  //简单的继承和函数的重写
public:
	void calculate(){
		cout << "苹果的CPU开始计算" << endl;
	}
};
class AppleCard:public Card{
public:
	void display(){
	    cout << "苹果的显卡开始显示" << endl;
    }
};
class AppleMemory:public Memory{
public:
	void storage(){
		cout << "苹果的内存条开始显示" << endl;
	}
};	

//戴尔厂商
class DellCPU:public CPU{
public:
	void calculate(){
		cout << "戴尔的CPU开始计算" << endl;
	}
};
class DellCard:public Card{
public:
	void display(){
		cout << "戴尔的显卡开始显示" << endl;
	}
};
class DellMemory:public Memory{
public:
	void storage(){
		cout << "戴尔的内存条开始显示" << endl;
	}
};	



void test01(){	
//	Lenovo *lenovo = new Lenovo;	      不写那个析构的内容的化，我感觉是对的，但有一点怪怪的
//	Com *com = new Com(lenovo,lenovo,lenovo);
//	com->work();
//	//delete com;
//	delete lenovo;

    Com *com1 = new Com(new AppleCPU,new AppleCard,new AppleMemory); //使用了第二中的厂商法
	com1->work();
	delete com1;//delete的时候就调用析构函数啦
	cout << "=======================" << endl;
	Com *com2 = new Com(new DellCPU,new AppleCard,new DellMemory); //使用了第二中的厂商法
	com2->work();
	delete com2;
}

int main(){
	test01();
	return 0;
}

网站题目：C++基础-类与对象(3)
文章来源：http://jkwzsj.com/article/dsoippe.html