继承和派生
继承
继承是面向对象的程序设计的重要特色之一。面向对象的程序设计通过数据抽象，对具有共同属性和行为的事物用类进行描述。我们可以对事物按层次进行分类，把处于上层的抽象事物具有下层抽象事物的共同属性（数据成员）和行为（成员函数）；面处于下层抽象事物除具有上层的抽象事物所有的属性和行为外，不具有本身所特有的特征，例如：动物可分为有脊椎动物和无脊椎动物，有脊椎动物事分为鱼类、两栖类、爬行类、鸟类和哺乳类；哺乳类动物分为猫科等，猫科动物又分为猫，老虎，狮子，豹等。
在面向对象的程序设计中，继承类似于动物的分层关系。一个类可以从另一个类中继承特征，称为派生一个类；所派生的类称为派生类（子类）；上层的被派生的类被称为基类（父类）。
派生类的定义
定义派生类的格式如下：
class 派生类名：访问控制 基类名
{
成员表
}；
其中访问控制包括：public(公有派生）、protected(保护派生）和 private (私有派生）。
基类中的访问权限在派生类中的继承关系如下表：
访问权限的继承
| 派生性质 | 在基类中的访问权限 | 在派生类中的访问权限 |
|
public (公有派生) |
public | public |
| protected | protected | |
| private | 不可访问 | |
|
protected (保护派生） |
public | protected |
| protected | protected | |
| private | 不可访问 | |
|
private (私有派生) |
public | private |
| protected | private | |
| private | 不可访问 |
例：定义一个点和一个矩形类：
class Point {
protect:
int x,y;
public:
Point():x(0),y(0){ }
Point(int xx=0,int yy=0):x(xx),y(yy) { }
int getx(){ return x;}
int gety(){ return y;}
};
class Rectangle : public Point {
private:
int width,high;
public:
Rectangle(){width=0; high=0;}
Rectangle(int w,int h){width=w; high=h;}
int getwidth() { return width;}
int gethigh(){ return high;}
long area(){ return width*high; }
};
下面来看一个具体的例子:
计算球、圆柱、圆锥的表面积和体积。
分析：由于都要用到圆的半径，后两者还要用到圆的面积，所以把圆定义成基类。
#include <iostream.h>
#include <math.h>
#define PI 3.14159
class Circle { //圆类
protected:
double r; //半径
public:
Circle(double radius=0):r(radius){ }
double area() { return PI*r*r;} //圆的表面积
double volume() {return 0 } //计算圆的体积
};
class Sphere: public Circle { //球体类
public:
Sphere(double radius=0):Circle(radius){ }
double area() { return 4*PI*r*r; } //计算球的表面积
double volume() { return 4*PI*pow(r,3)/3; } //计算球的体积
};
class Cylinder: public Circle { //圆柱类
private:
double h; //高度
public:
Cylinder(double radius=0,double height=0):Circle(radius){
h=height;
}
double area() { return 2*PI*r*(r+h); } //计算圆柱的表面积
double volume() { return PI*r*r*h; } //计算圆柱的体积
};
class Cone: public Circle { //圆锥类
private:
double h; //高度
public:
Cone(double radius=0,double height=0):Circle(radius){
h=height;
}
double area() { //计算圆锥的表面积
double he=sqrt(h*h+r*r);
return *PI*r*(r+he); }
double volume() { return PI*r*r*h/3; } //计算圆锥的体积
};
void main()
{
Circle r1(2);
Sphere r2(2);
Cylinder r3(2,3);
Cone r4(2,3);
cout <<"Circle:"<<r1.area()<<" "<<r1.volume()<<endl;
cout <<"sphere:"<<r2.area()<<" "<<r2.volume()<<endl;
cout <<"Cylinder:"<<r3.area()<<" "<<r3.volume()<<endl;
cout <<"Cone:"<<r1.area()<<" "<<r1.volume()<<endl;
运行结果：
Circle:12.5664 0
sphere:50.2655 33.5103
Cylinder:62.8319 37.6991
Cone:35.2207 12.5664
构造函数、析构函数和继承的关系
利用派生类定义对象时，先调用基类的构造函数，然后才派生类的构造函数；析构函数以相反的顺序被调用。如：
#include <iostream.h>
class AX {
int x;
public:
AX(int xx=0):x(xx){
cout <<"AX constructor."<<endl;
}
~AX() { cout<<"AX destructor."<<endl;}
void output(){ cout <<x<<" ";}
};
class BX : public AX {
int y;
AX z;
public:
BX(int xx=0,int yy=0):AX(xx),y(yy),z(xx+yy)
{
cout<<"BX constructor."<<endl;
}
~BX() { cout <<"BX destructor."<<endl;}
}
void output()
{
AX::output;
cout<<" "<<y<<" " <<z.get()<<endl;
}
};
void main()
{
BX a(5),b(10,20);
a.output();
b.output();
}
程序的运行结果为：
AX constructor.
AX constructor.
BX constructor.
AX constructor.
AX constructor.
BX constructor.
5 0 5
10 20 30
BX destructor.
AX destructor.
AX destructor.
BX destructor.
AX destructor.
AX destructor.
