c++学习笔记（三）多态性

一、概述

本文介绍了C++编程中的多态性的概念及用法，多态性即是同样的消息发给不同派生类对象会产生多种形式的结果。

二、使用Virtual函数和动态绑定实现多态性

通过基类的指针或引用（指针句柄或引用句柄）调用一个virtual函数时，C++动态地（在运行时）根据对象初始化的类选择正确的函数来执行。

代码如下：

//CommissionEmployee.h
#ifndef COMMISSION_H
#define COMMISSION_H

#include <string>
#include <iostream>
using std::string;
using std::cout;

class CommissionEmployee
{
public:
	CommissionEmployee( const string &yourName ,const string &yourNumber,
		double gSales = 0.0,double cRate=0.0)
		:name(yourName),number(yourNumber)
	{
		setGrossSales(gSales);
		setCommissionRate(cRate);
	}
	void setName(const string &yourName )
	{
		name =yourName;
	}
	string getName()const
	{
		return name;
	}
	void setNumber(const string &yourNumb )
	{
		name =yourNumb;
	}
	string getNumber()const
	{
		return number;
	}
	void setGrossSales(double sales )
	{
		grossSales = sales>0? sales:0;
	}
	double getGrossSales()const
	{
		return grossSales;
	}
	void setCommissionRate( double rate)
	{
		commissionRate = (rate<1.0&&rate>0.0)? rate:0.0;
	}
	double getCommissionRate()const
	{
		return commissionRate;
	}
	virtual double earning()const
	{
		return getGrossSales()*getCommissionRate();
	}
	virtual void print()const
	{
		cout<<"Name: "<<getName()
			<<"\nNumber: "<<getNumber()
			<<"\nGross sales: "<<getGrossSales()
			<<"\nCommission rate: "<<getCommissionRate();
	}
private:
	string name;
	string number;
	double grossSales;
	double commissionRate;
};
#endif

//BasePlusCommissionEmployee.h
#ifndef BASEPULS_H
#define BASEPULS_H

#include <string>
using std::string;

#include "CommissionEmployee.h"

class BasePlusCommissionEmployee : public CommissionEmployee
{
public:
	BasePlusCommissionEmployee(const string &yourName,const string &yourNumber,
		double sales,double rate,double salary)
		:CommissionEmployee(yourName,yourNumber,sales ,rate)
	{
		setBaseSalary(salary);
	}
	
	void setBaseSalary(double yourSalary)
	{
		baseSalary = yourSalary;
	}
	double getBaseSalary()const
	{
		return baseSalary;
	}
	virtual double earning()const
	{
		return getBaseSalary()+CommissionEmployee::earning();
	}
	virtual void print()const
	{
		CommissionEmployee::print();
		cout<<"\nbase salary: "<<getBaseSalary();
	}
private:
	double baseSalary;
};
#endif 

以上为BasePluseCommissionEmployee类和CommissionEmployee类，前者是后者的派生，两者均含有函数doubleearning()const和void print()const，派生类

BasePluseCommissionEmployee类增加一个数据成员double baseSalary，并且重写了double earning()const和void print()const。main()函数如下：

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

#include "BasePlusCommissionEmployee.h"
#include "CommissionEmployee.h"

int main()
{
	CommissionEmployee commissionEmployee(
		"Jay","1111",10000, 0.06);                 //初始化基类对象
	CommissionEmployee *commissionEmployeePtr =NULL; 

	BasePlusCommissionEmployee basePlusCommissionEmployee(
		"Ken","2222" ,8000,0.05 ,400);             //初始化派生类对象
	BasePlusCommissionEmployee *basePlueCommissionEmployeePtr =NULL;

	cout<<"使用句柄： \n";
	commissionEmployee.print();
	cout<<"\n\n";
	basePlusCommissionEmployee.print();
	
	cout<<"\n\n使用指针： \n";
	commissionEmployeePtr = &commissionEmployee;   //指向基类对象的基类指针
	basePlueCommissionEmployeePtr = &basePlusCommissionEmployee;  //指向派生类对象的派生类指针
	commissionEmployeePtr->print();
	cout<<"\n\n";
	basePlueCommissionEmployeePtr->print();
	
	cout<<"\n\n";
	commissionEmployeePtr = &basePlusCommissionEmployee;  //指向派生类的基类指针
	//BasePlusCommissionEmployee = &commissionEmployee;   //编译不通过
	commissionEmployeePtr->print();                       //指向派生类的基类指针动态地调用了派生类的成员函数
							      //如果不设置为virtual函数，则此处调用的是基类的成员函数
	cout<<"\n\n";
	return 0;

}

 

可以看出将基类和派生类的成员函数doubleearning()const和void print()const前加上Virtual声明为虚函数，并且将派生类对象地址赋给基类指针，基类指针调用earning()和print()函数时，即可调用派生类的相应成员函数；相反，当不使用Virtual时，基类指针调用的是基类自己的earning()和print()函数。当基类中的虚函数无意义时，可以将其声明为纯虚函数，及没有任何实现的函数

如Virtualearing() const =0或Virtual earing() =0;

这样在派生类中必须给出这一虚函数的各自的实现，也即各自重载基类的纯虚函数

结果

三、使用向下强制类型转换dynam_cast实现多态性

<span style="font-size:10px;">BasePlusCommissionEmployee *derivePtr =                                //使用向下强制转换符dynamic_cast
	dynamic_cast<BasePlusCommissionEmployee *>(commissionEmployeePtr); //将基类指针转换为派生类指针derivePtr 
derivePtr->print();  </span>

此方法也可实现调用派生类的成员函数

四、Virtual析构函数

当删除一个具有非虚析构函数的派生类对象，而一个基类指针却指向了该对象，则对它应用delete运算符，C++标准会指出这一行为未定义。这种问题的简单方法，即在基类中创建virtua析构函数（在析构函数前加上virtual关键字），即使所有派生类的析构函数与基类的析构函数不同名。这样，如果对一个基类指针用delete运算符来显示删除它所指的类层次中的某个对象，那么系统会根据指针所指对象调用相应类的析构函数。基类的析构函数在派生类析构函数调用之后调用。