C++多态

多态：意味着多种形态。举个例子，多种品牌的笔记本，各有不同。它们具有相同的耳机接口，只需要一个耳机，就可以用在不同牌子的笔记本上。至于不同品牌的笔记本，采用的什么声卡、内部零件怎么配置、安装，就不需要知道了。

在面向对象方法中，一般这样表述多态：向不同对象发出同一个消息，不同对象在接收时，会产生不同的行为。
以上述例子来说，对每个品牌的笔记本发出通过耳机听声音的消息，每个笔记本在插入耳机会，通过各自内部的配置，将声音输出，当然输出声音的效果各有不同。

从系统实现角度来看，多态分为两种：静态多态和动态多态。
静态多态：通过函数的重载实现。
动态多态：通过虚函数来实现。

虚函数：在成员函数的返回类型前加上virtual，其作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。（如果不将基类的同名函数声明为虚函数类型，无法通过基类的指引或引用来访问派生类中的同名函数）。

纯虚函数：如 virtual double fun1（）const=0；在函数声明最后加上“const=0”为纯虚函数。包含一个或多个纯虚函数的类，称为抽象类。
抽象类：抽象类不可以实例化，从抽象类派生的类只有为所有纯虚函数提供了实现代码，才能够实例化。

注意：继承时，最好将基类的析构函数，声明为虚函数。否则可能会导致，内存泄露问题。（如：基类 * ptr=new 子类，如果基类的析构函数不是虚函数，子类的析构函数不会调用）

代码实例：
算术树（一种数据结构）：算术表达式可以转换为一个二叉树结构。
(a+b×(c-d))-e/f
二叉树结构为：

（1）将算术树的所有结点看成从类Node继承的类的对象。
（2）NumNode继承自Node，它表示数字。
（3）BinNode继承自Node，它表示运算符。
（4）AddNode继承自BinNode，它表示加运算符。
（5）MultNode继承自BinNode，它表示乘法运算符。
*这里限制运算符仅为+和 **
下面给出实现代码
源.cpp

#include"AddNode.h"
#include"MultNode.h"
#include"NumNode.h"
int main()
{
	//(20+(-10))*0.1
	Node* pNode1 = new NumNode(20.0);
	Node* pNode2 = new NumNode(-10.0);
	Node* pNode3 = new AddNode(pNode1, pNode2);
	Node* pNode4 = new NumNode(0.1);
	Node* pNode5 = new MultNode(pNode3, pNode4);
	std::cout << "Calculating the tree\n";
	double x = pNode5->Calc();
	std::cout << "Result:" << x << std::endl;
	//从根结点释放及二叉树所有结点
	delete pNode5;
	return 0;
}

Node类
Node.h

#ifndef NODE_H
#define NODE_H
#include <iostream>
class Node
{
public:
	virtual ~Node(){}
	virtual double Calc()const = 0;
};

#endif

NumNode类
NumNode.h

#ifndef NUMNODE_H
#define NUMNODE_H
#include "Node.h"
class NumNode :public Node
{
public:
	NumNode(double num) :_num(num){}
	double Calc()const;
private:
	const double _num;
};
#endif

NumNode.cpp

#include "NumNode.h"

double NumNode::Calc()const
{
	std::cout << "Numeric Node" << _num << std::endl;
	return _num;
}

BinNode类
BinNode.h

#ifndef BINNODE_H
#define BINNODE_H
#include "Node.h"
class BinNode :public Node
{
public:
	BinNode(Node * pLeft, Node * pRight)
		:_pLeft(pLeft), _pRight(pRight){}
	virtual ~BinNode()
	{
		delete _pLeft;
		delete _pRight;
	}
protected:
	Node * const _pLeft;
	Node * const _pRight;
};
#endif

AddNode类
AddNode.h

#ifndef ADDNODE_H
#define ADDNODE_H
#include "BinNode.h"
class AddNode:public BinNode
{
public:
	AddNode(Node* pLeft, Node *pRight) 
		:BinNode(pLeft, pRight){}
	double Calc()const;

};
#endif

AddNode.cpp

#include "AddNode.h"

double AddNode::Calc()const
{
	std::cout << "Adding" << std::endl;
	return _pLeft->Calc() + _pRight->Calc();
}

MultNode类
MultNode.h

#ifndef MULTNODE_H
#define MULTNODE_H
#include"BinNode.h"
class MultNode:public BinNode
{
public:
	MultNode(Node* pLeft, Node* pRight)
		:BinNode(pLeft, pRight){}
	double Calc()const;

};

#endif

MultNode.cpp

#include"MultNode.h"
double MultNode::Calc()const
{
	std::cout << "Multiplying" << std::endl;
	return _pLeft->Calc()*_pRight->Calc();
}