面向对象程序设计中的多态性是指向不同的对象发送同一个消息，不同对象对应同一消息产生不同行为。在程序中消息就是调用函数，不同的行为就是指不同的实现方法，即执行不同的函数体。也可以这样说就是实现了“一个接口，多种方法”。
从实现的角度来讲，多态可以分为两类：编译时的多态性和运行时的多态性。前者是通过静态联编来实现的，比如C++中通过函数的重载和运算符的重载。后者则是通过动态联编来实现的，在C++中运行时的多态性主要是通过虚函数来实现的，也正是今天我们要讲的主要内容。
1.不过在说虚函数之前，我想先介绍一个有关于基类与派生类对象之间的 赋值兼容关系的内容。它也是之后学习虚函数的基础。我们有时候会把整型数据赋值给双精度类型的变量。在赋值之前，先把整形数据转换为双精度的，在把它赋值给双精度类型的变量。这种不同类型数据之间的自动转换和赋值，称为赋值兼容。同样的， 在基类和派生类之间也存在着赋值兼容关系，它是指需要基类对象的任何地方都可以使用公有派生类对象来代替。为什么只有公有继承的才可以呢，因为在公有继承中派生类保留了基类中除了构造和析构之外的所有成员，基类的公有或保护成员的访问权限都按原样保留下来，在派生类外可以调用基类的公有函数来访问基类的私有成员。因此基类能实现的功能，派生类也可以。
那么它们具体是如何体现的呢？(1)派生类对象直接向基类赋值，赋值效果，基类数据成员和派生类中数据成员的值相同;(2)派生类对象可以初始化基类对象引用;(3)派生类对象的地址可以赋给基类对象的指针;(4)函数形参是基类对象或基类对象的引用，在调用函数时，可以用派生类的对象作为实参;
#include "stdafx.h"
#include<iostream>
#include<string>
class ABCBase
{
private:
std::string ABC;
public:
ABCBase(std::string abc)
{
ABC=abc;
}
void showABC();
};
void ABCBase::showABC()
{
std::cout<<"字母ABC=>"<<ABC<<std::endl;
}
class X:public ABCBase
{
public:
X(std::string x):ABCBase(x){}
};
void function(ABCBase &base)
{
base.showABC();
}
int main()
{
ABCBase base("A");
base.showABC();
X x("B");
base=x;
base.showABC();
ABCBase &base1=x;
base1.showABC();
ABCBase *base2=&x;
base2->showABC();
function(x);
return0;
}
要注意的是：第一，在基类和派生类对象的赋值时，该派生类必须是公有继承的。第二，只允许派生类对象向基类对象赋值，反过来不允许；
2.紧接着来讲一下虚函数，它允许函数调用与函数体之间的联系在运行时才建立，即在运行时才决定如何动作。虚函数声明的格式：
virtual 返回类型 函数名(形参表)
{
函数体
}
那么定义虚函数有什么用呢？让我们先来看看下面这个示例：
#include "stdafx.h"
#include <iostream>
#include <string>
class Graph
{
protected:
double x;
double y;
public:
Graph(double x,double y);
void showArea();
};
Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}
void Graph::showArea()
{
std::cout<<"计算图形面积"<<std::endl;
}
class Rectangle:public Graph
{
public:
Rectangle(double x,double y):Graph(x,y){};
void showArea();
};
void Rectangle::showArea()
{
std::cout<<"矩形面积为："<<x*y<<std::endl;
}
class Triangle:public Graph
{
public:
Triangle(double d,double h):Graph(d,h){};
void showArea();
};
void Triangle::showArea()
{
std::cout<<"三角形面积为："<<x*y*0.5<<std::endl;
}
class Circle:public Graph
{
public:
Circle(double r):Graph(r,r){};
void showArea();
};
void Circle::showArea()
{
std::cout<<"圆形面积为："<<3.14*x*y<<std::endl;
}
int main()
{
Graph *graph;
Rectangle rectangle(10,5);
graph=&rectangle;
graph->showArea();
Triangle triangle(5,2.4);
graph=▵
graph->showArea();
Circle circle(2);
graph=&circle;
graph->showArea();
return0;
}
三个都输出基类的showArea()，这是因为程序里采用的是静态联编机制，graph的指向在编译时就已经确定，是指向Graph类的，所以输出都是Graph->showArea()。
对比一下程序：
#include <iostream>
#include <string>
class Graph
{
protected:
double x;
double y;
public:
Graph(double x,double y);
void showArea();
virtual~Graph();//定义虚析构函数
};
Graph::Graph(double x,double y)
{
std::cout<<"调用图形类构造函数"<<std::endl;
this->x=x;
this->y=y;
}
void Graph::showArea()
{
std::cout<<"计算图形面积"<<std::endl;
}
Graph::~Graph()
{
std::cout<<"调用图形类析构函数"<<std::endl;
}
class Rectangle:public Graph
{
public:
Rectangle(double x,double y):Graph(x,y){std::cout<<"调用矩形类构造函数"<<std::endl;};
void showArea();
void rect(){std::cout<<"rect"<<std::endl;}
~Rectangle();//虚析构函数
};
void Rectangle::showArea()
{
std::cout<<"矩形面积为："<<x*y<<std::endl<<std::endl;
}
Rectangle::~Rectangle()
{
std::cout<<"调用矩形类析构函数"<<std::endl;
}
int main()
{
Rectangle rectangle(10,5);
rectangle.showArea();
return 0;
}
Rectangle是Graph的子类，并重写了showArea()函数。当调用rectangle.showArea()时，先从Rectangle类中寻找showArea()函数，如果没有，再到基类Graph中寻找。在本例中，由于Rectangle重新实现了showArea()，所以在从子类Rectangle->父类Graph寻找showArea()的过程中，现在子类Rectangle找到了showArea()，所以调用Rectangle类的showArea()。如果Rectangle没有重写showArea()，则调用父类Graph的showArea()。
当基类对象指针指向公有派生类的对象时，它只能访问从基类继承下来的成员，而不能访问派生类中定义的成员。但是使用动态指针就是为了表达一种动态调用的性质即当前指针指向哪个对象，就调用那个对象对应类的成员函数。那要怎么来解决的，这时虚函数就体现出了它的作用。其实我们只需要对上一个示例代码中所有的类里出现的showArea()函数声明之前加一个关键字virtual:
#include "stdafx.h"
#include <iostream>
#include <string>
class Graph
{
protected:
double x;
double y;
public:
Graph(double x,double y);
voidvirtual showArea();//定义为虚函数或virtual void showArea()
};
Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}
void Graph::showArea()
{
std::cout<<"计算图形面积"<<std::endl;
}
class Rectangle:public Graph
{
public:
Rectangle(double x,double y):Graph(x,y){};
virtualvoid showArea();//定义为虚函数
};
void Rectangle::showArea()
{
std::cout<<"矩形面积为："<<x*y<<std::endl;
}
class Triangle:public Graph
{
public:
Triangle(double d,double h):Graph(d,h){};
virtualvoid showArea();//定义为虚函数
};
void Triangle::showArea()
{
std::cout<<"三角形面积为："<<x*y*0.5<<std::endl;
}
class Circle:public Graph
{
public:
Circle(double r):Graph(r,r){};
virtualvoid showArea();//定义为虚函数
};
void Circle::showArea()
{
std::cout<<"圆形面积为："<<3.14*x*y<<std::endl;
}
int main()
{
Graph *graph;
Rectangle rectangle(10,5);
graph=&rectangle;
graph->showArea();
Triangle triangle(5,2.4);
graph=▵
graph->showArea();
Circle circle(2);
graph=&circle;
graph->showArea();
return0;
}
在基类中的某成员函数被声明为虚函数后，在之后的派生类中可以重新来定义它。但定义时，其函数原型，包括返回类型、函数名、参数个数、参数类型的顺序，都必须和基类中的原型完全相同。其实在上述修改后的示例代码里，只要在基类中显式声明了虚函数，那么在之后的派生类中就需要用virtual来显式声明了，可以略去，因为系统会根据其是否和基类中虚函数原型完全相同来判断是不是虚函数。因此，上述派生类中的虚函数如果不显式声明也还是虚函数。最后对虚函数做几点补充说明：(1)因为虚函数使用的基础是赋值兼容，而赋值兼容成立的条件是派生类是从基类公有派生而来。所以使用虚函数，派生类必须是基类公有派生的;(2)定义虚函数，不一定要在最高层的类中，而是看在需要动态多态性的几个层次中的最高层类中声明虚函数;(3)虽然在上述示例代码中main()主函数实现部分，我们也可以使用相应图形对象和点运算符的方式来访问虚函数，如：
rectangcle.showArea(),但是这种调用在编译时进行静态联编，它没有充分利用虚函数的特性。只有通过基类对象来访问虚函数才能获得动态联编的特性;(4)一个虚函数无论配公有继承了多少次，它仍然是虚函数;(5)虚函数必须是所在类的成员函数，而不能是友元函数，也不能是静态成员函数。因为虚函数调用要靠特定的对象类决定该激活哪一个函数;(6)内联函数不能是虚函数，因为内联函数是不能在运行中动态确定其位置的即使虚函数在类内部定义，编译时将其看作非内联;(7)构造函数不能是虚函数，但析构函数可以是虚函数;
如果在main()主函数中用new建立一个派生类无名对象和定义一个基类对象指针，并将无名对象的地址赋给基类对象指针时，当我们用delete运算符来撤销无名对象时，系统只执行基类析构函数，而不执行派生类析构函数。比如：
#include "stdafx.h"
#include <iostream>
#include <string>
class Graph
{
protected:
double x;
double y;
public:
Graph(double x,double y);
voidvirtual showArea();//定义为虚函数或virtual void showArea()
~Graph();
};
Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}
void Graph::showArea()
{
std::cout<<"计算图形面积"<<std::endl;
}
Graph::~Graph()
{
std::cout<<"调用图形类析构函数"<<std::endl;
}
class Rectangle:public Graph
{
public:
Rectangle(double x,double y):Graph(x,y){};
virtualvoid showArea();//定义为虚函数
~Rectangle();
};
void Rectangle::showArea()
{
std::cout<<"矩形面积为："<<x*y<<std::endl;
}
Rectangle::~Rectangle()
{
std::cout<<"调用矩形类析构函数"<<std::endl;
}
int main()
{
Graph *graph;
graph=new Rectangle(10,5);
graph->showArea();
delete graph;
return0;
}
因为在撤销指针graph所指的派生类对象，在调用析构函数时，采用静态联编，只调用了Graph类的析构函数。如果也想调用派生类Rectangle类的析构函数的话，可将Graph类的析构函数定义为虚析构函数，这样在析构对象时，由运行时多态得知graph实际上指的是Rectangle类对象，从而调用Rectangle类的析构函数（同时调用基类Graph的析构函数）。其定义的一般格式：
virtual ~类名()
{
函数体
};
虽然派生类的析构函数与基类的析构函数名字不同，但是如果将基类的析构函数定义为虚函数，由该基类派生而来的所有派生类的析构函数都自动成为虚函数。我们把上一示例中的Graph类的析构函数前加上关键字virtual，那么执行结果：
显然这个结果才是我们所需要的。
3.上述示例中用了虚函数后，会发现其实Graph类(图形类)中的虚函数的函数体根本没有被用到过，就算被用到，该基类体现了图形的抽象的概念，并不与具体事物相联系。所以基类中的虚函数也没有实质性的功能。因此我们只需要在基类中留下一个函数名，而具体的实现留给派生类去定义。在C++中就是用纯虚函数来说明的。纯虚函数的一般形式：
virtual 返回类型 函数名(形参表)=0;
这里的"=0"并不是函数的返回值等于零，它只是起到形式上的作用，告诉编译系统"这是纯虚函数"。纯虚函数不具备函数功能，不能被调用。
class Graph
{
protected:
double x;
double y;
public:
Graph(double x,double y);
voidvirtual showArea()=0;//定义纯虚函数
};
Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}
5.最后用一个实例来总结一下今天所讲的内容(开发工具：vs2010):
#include "stdafx.h"
#include <iostream>
#include <string>
class Graph //抽象类
{
protected:
double x;
double y;
public:
Graph(double x,double y);
//void virtual showArea();//定义为虚函数或virtual void showArea()
voidvirtual showArea()=0;//定义纯虚函数
virtual~Graph();//定义虚析构函数
};
Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}
void Graph::showArea()
{
std::cout<<"计算图形面积"<<std::endl;
}
Graph::~Graph()
{
std::cout<<"调用图形类析构函数"<<std::endl;
}
class Rectangle:public Graph
{
public:
Rectangle(double x,double y):Graph(x,y){};
void showArea();//虚函数
~Rectangle();//虚析构函数
};
void Rectangle::showArea()
{
std::cout<<"矩形面积为："<<x*y<<std::endl;
}
Rectangle::~Rectangle()
{
std::cout<<"调用矩形类析构函数"<<std::endl;
}
class Triangle:public Graph
{
public:
Triangle(double d,double h):Graph(d,h){};
virtualvoid showArea();//虚函数
~Triangle();//虚析构函数
};
void Triangle::showArea()
{
std::cout<<"三角形面积为："<<x*y*0.5<<std::endl;
}
Triangle::~Triangle()
{
std::cout<<"调用三角形类析构函数"<<std::endl;
}
class Circle:public Graph
{
public:
Circle(double r):Graph(r,r){};
virtualvoid showArea();//虚函数
~Circle();//虚析构函数
};
void Circle::showArea()
{
std::cout<<"圆形面积为："<<3.14*x*y<<std::endl;
}
Circle::~Circle()
{
std::cout<<"调用圆形类析构函数"<<std::endl;
}
int main()
{
{
//Graph g(10,10);//抽象类不能建立对象
Graph *graph;
Rectangle rectangle(10,5);
graph=&rectangle;
graph->showArea();
Triangle triangle(5,2.4);
graph=▵
graph->showArea();
Graph *graph1;
graph1=new Circle(2);//new运算符建立无名对象
graph1->showArea();
delete graph1;//delete运算符撤销派生类Circle无名对象
}
return0;
}
Reference:http://www.cnblogs.com/CaiNiaoZJ/archive/2011/08/11/2134673.html
7232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
