图例实解:C++中类的继承特性

核心提示：整个c++程序设计全面围绕面向对象的方式进行，类的继续特性是c++的一个非常非常重要的机制，图例实解:C++中类的继承特性，继续特性可以使一个新类获得其父类的操作和数据结构，程序员只需在新类中增加原有类中没有的成分，在这里由于类的成员是受保护的所以我们利用a.rm(a)来返回受保护的motor，作为函数参数进行调用，

　　整个c++程序设计全面围绕面向对象的方式进行，类的继续特性是c++的一个非常非常重要的机制，继续特性可以使一个新类获得其父类的操作和数据结构，程序员只需在新类中增加原有类中没有的成分。

　　可以说这一章节的内容是c++面向对象程序设计的要害。

　　下面我们简单的来说一下继续的概念，先看下图: 　　上图是一个抽象描述的特性继续表

　　交通工具是一个基类（也称做父类），通常情况下所有交通工具所共同具备的特性是速度与额定载人的数量，但按照生活常规，我们来继续给交通工具来细分类的时候，我们会分别想到有汽车类和飞机类等等，汽车类和飞类同样具备速度和额定载人数量这样的特性，而这些特性是所有交通工具所共有的，那么当建立汽车类和飞机类的时候我们无需再定义基类已经有的数据成员，而只需要描述汽车类和飞机类所特有的特性即可，飞机类和汽车类的特性是由在交通工具类原有特性基础上增加而来的，那么飞机类和汽车类就是交通工具类的派生类（也称做子类）。以此类推，层层递增，这种子类获得父类特性的概念就是继续。

　　下面我们根据上图的理解，有如下的代码：#include <iostream>　 
using namespace std; 
 
class Vehicle 
{ 
public: 
　　void EditSC(float speed,int total); 
PRotected: 
　　float speed;//速度 
　　int total;//最大载人量 
}; 
void Vehicle::EditSC(float speed,int total) 
{ 
　　Vehicle::speed = speed; 
　　Vehicle::total = total; 
} 
class Car:public Vehicle//Car类继续Vehicle的特性，Car类是Vehicle的派生类 
{ 
public: 
　　Car() 
　　{ 
　　　　aird=0; 
　　} 
protected: 
　　int aird;//排量 
}; 
 
class plane:public Vehicle 
{ 
protected: 
　　float wingspan;//翼展 
}; 
 
void main() 
{ 
　　Car a; 
　　a.EditSC(150,4); 
　　cin.get(); 
}　　派生类的定义可以在类名称后加冒号public空格加基类名称进行定义，如上面代码中的class Car:public Vehicle。 更多内容请看C/C++技术专题专题，或 　　一旦成功定义派生类，那么派生类就可以操作基类的所有数据成员包括是受保护型的，上面代码中的a.EditSC(100,4); 就是例子，甚至我们可以在构造派生类对象的时候初始化他们，但我们是不推荐这么做的,因为类于类之间的操作是通过接口进行勾通的，为了不破坏类的这种封专装特性，即使是父类于子类的操作也应按遵循这个思想，这么做的好处也是显而易见的，当基类有错的时候，只要不涉及接口，那么基类的修改就不会影响到派生类的操作。 　　至于为什么派生类能够对基类成员进行操作，我们上图可以简单的说明基类与子类在内存中的排列状态。

　　我们知道，类对象操作的时候在内部构造的时候会有一个隐的this指针，由于Car类是Vehicle的派生类，那么当Car对象创建的时候，这个this指针就会覆盖到Vehicle类的范围，所以派生类能够对基类成员进行操作。


　　笔者写到这里的时候不得不提一下，我有开发c#与java的经验，就这两种语言来说，学到这里的时候很多人很难理解继续这一部分的内容，或者是理解的模糊不清，其实正是缺少了与this指针相关的c++知识，多数高级语言的特性是不涉及内存状态的操作，java与c#是接触不到这些知识的，所以理解起这部分内容就更抽象更不具体。　　下面我们来说一下,派生类对象(子类对象)的构造。

　　由上面的例程我们知道Car类是Vehicle类的派生类(子类)，c++规定，创建派生类对象的时候首先调用基类的构造函数初始化基类成员，随后才调用派生类构造函数。

　　但是要注重的是，在创建派生类对象之前，系统首先确定派生类对象的覆盖范围（也可以称做大小尺寸），上面代码的派生类对象a就覆盖于Vehicle类和Car类上，至于派生类对象的创建是如何构造基类成员的，我们看如下代码，随后再进行分析：#include <iostream>　 
using namespace std; 
 
class Vehicle 
{ 
public: 
　　Vehicle(float speed=0,int total=0) 
　　{ 
　　　　cout<<"载入Vehicle类构造函数"<<endl; 
　　　　Vehicle::speed = speed; 
　　　　Vehicle::total = total; 
　　} 
　　Vehicle(Vehicle &temp) 
　　{ 
　　　　Vehicle::speed = temp.speed; 
　　　　Vehicle::total = temp.total; 
　　} 
　　~Vehicle() 
　　{ 
　　　　cout<<"载入Vehicle类析构函数"<<endl; 
　　　　cin.get(); 
　　} 
protected: 
　　float speed;//速度 
　　int total;//最大载人量 
}; 
class Car:public Vehicle 
{ 
public: 
　　Car(float aird=0,float speed = 0,int total = 0):Vehicle(speed,total) 
　　{ 
　　　　cout<<"载入Car类构造函数"<<endl; 
　　　　Car::aird = aird; 
　　} 
　　Car(Car &temp):Vehicle(temp.speed,temp.total) 
　　{ 
　　　　cout<<"载入Car类拷贝构造函数"<<endl; 
　　　　Car::aird = temp.aird; 
　　} 
　　~Car() 
　　{ 
　　　　cout<<"载入Car类析构函数"<<endl; 
　　　　cin.get(); 
　　} 

protected: 
　　float aird;//排量 
}; 
void main() 
{ 
　　Car a(250,150,4); 
　　Car b = a; 
　　cin.get(); 
}　　对象a创建的时候通过Car(float aird = 0,float speed = 0,int total = 0):Vehicle(speed,total)，也就是Car类构造函数，来构造Car类对象成员，但按照c++的规定首先应该调用基类构造函数构造基成员，在这里基类成员的构造是通过Vehicle(speed,total)，来实现的。 更多内容请看C/C++技术专题专题，或

　　但值得注重的是Vehicle(speed,total)的意义并不是对Vehicle类的个个成员的初始化，事实上是利用它创建了一个Vehicle类的无名对象，由于Car类对象的覆盖范围是覆盖于Vehicle类和Car类上， 所以系统在确定了派生类对象a的空间范围后，确定了this指针位置，这个this指针指向了Vehicle类的那个无名对象,这个成员赋值过程就是，this->speed＝无名对象.speed。

　　其实这里概念比较模糊，笔者因为个人能力的原因暂时也无法说的更明确了，读者对此处知识点的学习，应该靠自己多对比多练习，进行体会理解。

　　许多书籍对于派生类对象的复制这一知识点多是空缺的，为了教程的易读性，我还是决定说一下在复制过程中轻易出错的地方，Car b=a;是派生类对象复制的语句，通过前面教程的学习我们我们知道，类对象的复制是通过拷贝构造函数来完成的，假如上面的例子我们没有提供拷贝构造函数不完整如下： Car(Car &temp) 
{ 
　　cout<<"载入Car类拷贝构造函数"<<endl; 
　　Car::aird = temp.aird; 
} 　　那么复制过程中就会丢失基类成员的数据了，所以Car类拷贝构造函数不能缺少Vehicle类无名对象的创建过程:Vehicle(temp.speed,temp.total)，派生类对象的复制过程系统是不会再调用基类的拷贝构造函数的，this指针的问题再次在这里体现出来，大家可以尝试着把无名对象的创建去掉，观察b.speed的变化。

　　类对象够创建必然就有析构过程，派生类对象的析构过程首先是调用派生类的析构过程，再调用基类的构造函数，正好和创建过程相反，在这里笔者已经在上面代码中加入了过程显示，读者可以自行编译后观察。　　最后我们说一下类的继续与组合。

　　其实类的组合我们在早些的前面的教程就已经接触过，只是在这里换了个说法而已，当一个类的成员是另一个类的对象的时候就叫做组合，事实上就是类于类的组合。组合和继续是有明显分别的，为了充分理解继续与组合的关系，我们在不破坏类的封装特性的情况下，先看如下的代码：#include <iostream> 
using namespace std; 
 
class Vehicle 
{ 
public: 
　　Vehicle(float speed=0,int total=0) 
　　{ 
　　　　Vehicle::speed = speed; 
　　　　Vehicle::total = total; 
　　} 
protected: 
　　float speed;//速度 
　　int total;//最大载人量 
}; 
 
class Motor 
{ 
public: 
　　Motor(char *motor) 
　　{ 
　　　　Motor::motortype = motor; 

　　} 
 
　　char* SMT(Motor &temp); 
protected: 
　　char *motortype;//发动机型号 
}; 
char* Motor::SMT(Motor &temp) 
{ 
　　return temp.motortype; 
} 
 
class Car:public Vehicle//继续的体现 
{ 
public: 
　　Car(float speed,int total,int aird,char *motortype):Vehicle(speed,total),motor(motortype) 
　　{ 
　　　　Car::aird = aird; 
　　} 
 
　　Motor rm(Car &temp); 
protected: 
　　int aird;//排量 
　　Motor motor;//类组合的体现 
}; 
 
Motor Car::rm(Car &temp) 
{ 
　　return temp.motor; 
} 
 
//-------------------------------------------------------------- 
void test1(Vehicle &temp) 
{ 
　　//中间过程省略 
}; 
void test2(Motor &temp) 
{ 
　　cout<<temp.SMT(temp);//读者这里注重一下,temp既是对象也是对象方法的形参 
} 
//-------------------------------------------------------------- 
 
void main() 
{ 
　　Car a(150,4,250,"奥地利AVL V8"); 
　　test1(a); 
　　//test2(a);//错误,Car类与Motor类无任何继续关系 
　　test2(a.rm(a));//假如Car类成员是public的那么可以使用test2(a.motor) 
　　cin.get(); 
}　　在上面的代码中我们新增加了发动机类Motor，Car类增加了Motor类型的motor成员，这就是组合，拥有继续特性的派生类可以操作基类的任何成员，但对于与派生类组合起来的普通类对象来说，它是不会和基类有任何联系的。 

　　函数调用：test1(a);，可以成功执行的原因就是因为Car类对象在系统是看来一个Vehicle类对象，即Car类是Vehicle类的一种，Car类的覆盖范围包含了Vehicle。　　函数调用：test2(a);，执行错误的原因是因为Motor类并不认可Car类对象a与它有任何关系，但我们可以通过使用Car类对象a的Motor类成员motor，作为函数形参的方式来调用test2函数（test2(a.motor)），在这里由于类的成员是受保护的所以我们利用a.rm(a)来返回受保护的motor，作为函数参数进行调用。 更多内容请看C/C++技术专题专题，或