实现多态的四个条件 --- 百度百科

 

实现多态的四个条件：

1、虚函数

在C++编程中，采用关键字virtual，虚函数是动态联编，所以函数类型不能使private，必须是protect或者public类型。

条件
　　所以，实现动态联编需要三个条件： 
　　1、 必须把动态联编的行为定义为类的虚函数。 
　　2、 类之间存在子类型关系，一般表现为一个类从另一个类公有派生而来。 
　　3、 必须先使用基类指针指向子类型的对象，然后直接或者间接使用基类指针调用虚函数。

定义虚函数的限制：（1）非类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数也不能定义为虚函数，但可以将析构函数定义为虚函数。实际上，优秀的程序员常常把基类的析构函数定义为虚函数。因为，将基类的析构函数定义为虚函数后，当利用delete删除一个指向派生类定义的对象指针时，系统会调用相应的类的析构函数。而不将析构函数定义为虚函数时，只调用基类的析构函数。 
　　（2）只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数，而定义函数时不需要使用关键字“virtual”。 
　　（3）当将基类中的某一成员函数声明为虚函数后，派生类中的同名函数自动成为虚函数。 
　　（4）如果声明了某个成员函数为虚函数，则在该类中不能出现和这个成员函数同名并且返回值、参数个数、类型都相同的非虚函数。在以该类为基类的派生类中，也不能出现这种同名函数。 
　　虚函数联系到多态，多态联系到继承。所以本文中都是在继承层次上做文章。没了继承，什么都没得谈。

class A{ 
　　public: 
　　void print(){ cout<<"This is A"<<endl;} 
　　}; 
　　class B:public A{ 
　　public: 
　　void print(){ cout<<"This is B"<<endl;} 
　　}; 
　　int main(){ //为了在以后便于区分，我这段main()代码叫做main1 
　　A a; 
　　B b; 
　　a.print(); 
　　b.print(); 
　　} 
　　通过class A和class B的print（）这个接口，可以看出这两个class因个体的差异而采用了不同的策略，输出的结果也是我们预料中的，分别是This is A和This is B。但这是否真正做到了多态性呢？No，多态还有个关键之处就是一切用指向基类的指针或引用来操作对象。那现在就把main（）处的代码改一改。 
　　int main(){ //main2 
　　A a; 
　　B b; 
　　A* p1=&a; 
　　A* p2=&b; 
　　p1->print(); 
　　p2->print(); 
　　} 
　　运行一下看看结果，哟呵，蓦然回首，结果却是两个This is A。问题来了，p2明明指向的是class B的对象但却是调用的class A的print（）函数，这不是我们所期望的结果，那么解决这个问题就需要用到虚函数 
　　class A{ 
　　public: 
　　virtual void print(){ cout<<"This is A"<<endl;} //现在成了虚函数了 
　　}; 
　　class B:public A{ 
　　public: 
　　void print(){ cout<<"This is B"<<endl;} //这里需要在前面加上关键字virtual吗？ 
　　};

虚函数特例：

纯虚函数是一种特殊的虚函数，它的一般格式如下： 
　　class <类名> 
　　{ 
　　virtual <类型><函数名>(<参数表>)=0; 
　　… 
　　}; 在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。 
　　纯虚函数可以让类先具有一个操作名称，而没有操作内容，让派生类在继承时再去具体地给出定义。凡是含有纯虚函数的类叫做抽象类。这种类不能声明对象，只是作为基类为派生类服务。除非在派生类中完全实现基类中所有的的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。

关于虚函数是如何实现的，还是参见百度百科里的内容，地址：http://baike.baidu.com/view/161302.htm

 

 

2、覆盖

 

覆盖(OverRide) 
　　在面向对象的编程中，一般出现在继承(Inheritance)。 
　　当子类声明了与基类相同名字的方法，而且使用了相同的签名时，就称派生类的成员覆盖(hide)了基类的成员。面向对象编程(OOP)的三大特性：封装，继承，多态！重载overload)和覆盖都能实现多态，但是真正和多态相关的是覆盖！ （个人愚见：这里没有细说，个人感觉虚函数里的实现的就是包含覆盖的概念，因为子类和父类的方法名字是一样的，而父类指针指向子类调用方法时会调用子类的方法，这不是就相当于覆盖掉了父类的方法；）

 

3、重载

 

重载是可使函数、运算符等处理不同类型数据或接受不同个数的参数的一种方法

重载是不是多态？ 
第一种说法
　　重载是一种是多态（如C++），有四种形式的多态： 
　　1.虚函数多态 
　　2模板多态 
　　3重载 
　　4转换 
　　所谓的动态和静态区分是另一种基于绑定时间的多态分类，严格来说，重载是编译时多态，即静态多态，根据不同类型函数编译时会产生不同的名字如int_foo和char_foo等等，以此来区别调用。故重载仍符合多态定义——通过单一标识支持不同特定行为的能力，只是重载属于静态多态，而不是通过继承和虚函数实现的动态多态。 
第二种说法
　　重载（overload）和多态无关，真正和多态相关的是覆盖(override)。 
　　当派生类重新定义了基类的虚拟方法后，基类根据赋给它的不同的派生类引用，动态地调用属于派生类的对应方法，这样的方法调用在编译期间是无法确定的。因此，这样的方法地址是在运行期绑定的（动态绑定）。 
　　重载只是一种语言特性，是一种语法规则，与多态无关，与面向对象也无关。 
　　不过针对所谓的第二种重载，有一个专门的名词--重写或重定义。重载与重写的区别就在于是否覆盖，重写一般多发生在不同的类且存在继承关系之间，而重载多是在一个类里或者一块代码段里。

 

4、抽象类（百度百科里说的都挺经典了，直接copy过来了）

 

简介

　　用 abstract 修饰的类是抽象类。

　　在C++中，含有纯虚拟函数的类称为抽象类，它不能生成对象。

　　凡是包含纯虚函数的类都是抽象类。

　　抽象类是不完整的，并且它只能用作基类。它与非抽象类的不同：

　　1、抽象类不能直接实例化，并且对抽象类使用 new 运算符是编译时错误。虽然一些变量和值在编译时的类型可以是抽象的，但是这样的变量和值必须或者为 null，或者含有对非抽象类的实例的引用（此非抽象类是从抽象类派生的）。

　　2、允许（但不要求）抽象类包含抽象成员。

　　3、抽象类不能被密封。

　　当从抽象类派生非抽象类时，这些非抽象类必须具体实现所继承的所有抽象成员，从而重写那些抽象成员。在下边的示例中：

　　abstract class A{ public abstract void F();}

　　abstract class B: A{ public void G() {}}

　　class C: B{ public override void F() { // actual implementation of F }}
　　　　抽象类 A 引入抽象方法 F。类 B 引入另一个方法 G，但由于它不提供 F 的实现，B 也必须声明为抽象类。类 C 重写 F，并提供一个具体实现。由于 C 中没有了抽象成员，因此可以（但并非必须）将 C 声明为非抽象类。

　　抽象类与接口紧密相关。然接口又比抽象类更抽象，这主要体现在它们的差别上：1）类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。2）抽象类当中可以存在非抽象的方法，可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3）抽象类中的成员变量可以被不同的修饰符来修饰，可接口中的成员变量默认的都是静态常量（static final）。4）这一点也是最重要的一点本质的一点"抽象类是对象的抽象，然而接口是一种行为规范"。

定义

　　抽象类表示该类中可能已经有一些方法的具体定义，但是接口就仅仅只能定义各个方法的界面(方法名，参数列表，返回类型)，并不关心具体细节。

用法

　　1）在继承抽象类时，必须覆盖该类中的每一个抽象方法，而每个已实现的方法必须和抽象类中指定的方法一样，接收相同数目和类型的参数，具有同样的返回值，这一点与接口相同。

　　2）当父类已有实际功能的方法时，该方法在子类中可以不必实现，直接引用的方法，子类也可以重写该父类的方法（继承的概念）。

　　3）而实现 (implement)一个接口（interface)的时候，是一定要实现接口中所定义的所有方法，而不可遗漏任何一个。

　　4）另外，抽象类是不能产生对象的，但可以由它的实现类来声明对象。

　　有鉴于此，在实现接口时，我们也常写一个抽象类，来实现接口中的某些子类所需的通用方法，接着在编写各个子类时，即可继承该抽象类来使用，省去在每个都要实现通用的方法的困扰。

实例

　　为了让一个类成为抽象类，至少必须有一个纯虚函数。纯虚函数形式如下：

　　virtual return type function() = 0;

　　例如，类A有两个纯虚函数lock()、unlock()和一个虚析构函数：

　　class A

　　{

　　public:

　　virtual void lock(void)=0;

　　virtual void unlock(void)=0;

　　virtual ~A(void);

　　}

　　将函数lock()和unlock()初始化为0使它们成为纯虚函数，没有0这个初使化器，它们仅仅是虚函数。

　　class B : public A

　　{

　　protected:

　　pthread_mutex_t x;

　　public:

　　B(void);

　　~B(void);

　　virtual void lock(void)

　　{

　　ead_mutex_lock(x);

　　}

　　virtual void unlock(void)        {

　　ead_mutex_unlock(x);

　　}

　　}

　　抽象类对于提供模式、蓝图和后代类遵循的原则有用。如果遵循了蓝图的语义，后代类的行为可能按抽象类提供者和使用者所期望的那样。通过使用抽象类，C++程序员可以提供C++组件的规范，在它的构建中指导组件的实现者。