文章目录

• • 面向对象的三个基本特征
  • • 1. 封装
    • 2. 继承
    • • 2.1 继承的三种实现方式
    • 3. 多态
    • • 3.1 多态的俩种实现方式分析
      • 3.2 多态存在的三个必要条件
      • 3.3 C++多态机制的实现：
    • 4. 动态绑定与多态
    • • 4.1 什么是动态绑定
      • 4.2 动态绑定发生的条件？
      • 4.3 动态绑定的实际意义
      • 4.4 程序

面向对象的三个基本特征

• 面向对象的三个基本特征是：数据抽象（继承）、继承、多态

1. 封装

• 封装可以隐藏实现细节，使得代码模块化，使代码和功能独立
• 封装是把函数和数据包围起来，对数据的访问只能通过可信任的对象和类进行访问，对不可信的进行信息隐藏。

2. 继承

• 继承可以扩展已存在的代码模块（类）
• 它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。其继承的过程，就是从一般到特殊的过程。

2.1 继承的三种实现方式

• 继承概念的实现方式有三类：实现继承、接口继承和可视继承。
  • 实现继承是指使用基类的属性和方法而无需额外编码的能力；
  • 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
  • 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

3. 多态

• 多态是同一个行为具有多个不同表现形式或形态的能力。
• 多态就是同一个接口，使用不同的实例而执行不同操作

答案：call child func
	 call ~child
	 call ~base

3.1 多态的俩种实现方式分析

• 覆盖：是指子类重新定义父类的虚函数的做法。
• 重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

重载与覆盖区别

• 重载是指在同一个类中相同的返回类型和方法名，但是参数的个数和类型可以不同
• 覆盖\重写是在不同的类中。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。
那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。

总结：重载只是一种语言特性，与多态无关，与面向对象也无关，多态属于面向对象！,多态是晚绑定

3.2 多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

3.3 C++多态机制的实现：

该部分转自：http://blog.chinaunix.net/uid-7396260-id-2056657.html
1、c++实现多态的方法

• 面向对象有了一个重要的概念就是对象的实例，对象的实例代表一个具体的对象，故其肯定有一个数据结构保存这实例的数据，这一数据包括对象成员变量，如果对象有虚函数方法或存在虚继承的话，则还有相应的虚函数或虚表指针，其他函数指针不包括。
• 虚函数在c++中的实现机制就是用虚表和虚指针，是每个类用了一个虚表，每个类的对象用了一个虚指针。要讲虚函数机制，必须讲继承，因为只有继承才有虚函数的动态绑定功能，先讲下c++继承对象实例内存分配基础知识：

class A
{
public:
    virtual void f();
    virtual void g();
private:
    int a
};

class B : public A
{
public:
    void g();
private:
    int b;
};

• 因为A有virtual void f（），和g（），所以编译器为A类准备了一个虚表vtableA，内容如下：
  
• B因为继承了A，所以编译器也为B准备了一个虚表vtableB，内容如下：
  
• 注意：因为B::ｇ是重写了的，所以B的虚表的g放的是B::g的入口地址，但是f是从上面的A继承下来的，所以f的地址是A::f的入口地址。然后某处有语句 B bB;的时候，编译器分配空间时，除了A的int a，B的成员int b；以外，还分配了一个虚指针vptr，指向B的虚表vtableB，bB的布局如下：

• 当如下语句的时候：

A *pa = &bB;

• pa的结构就是A的布局（就是说用pa只能访问的到bB对象的前两项，访问不到第三项int b）

• 那么pa->g()中，编译器知道的是，g是一个声明为virtual的成员函数，而且其入口地址放在表格（无论是vtalbeA表还是vtalbeB表）的第2项，那么编译器编译这条语句的时候就如是转换：call *(pa->vptr)[1]（C语言的数组索引从0开始哈~）。

• 这一项放的是B：：g()的入口地址，则就实现了多态。（注意bB的vptr指向的是B的虚表vtableB）

• 另外要注意的是，如上的实现并不是唯一的，C++标准只要求用这种机制实现多态，至于虚指针vptr到底放在一个对象布局的哪里，标准没有要求，每个编译器自己决定。我以上的结果是根据g++ 4.3.4经过反汇编分析出来的。

2、两种多态实现机制及其优缺点

• 除了c++的这种多态的实现机制之外，还有另外一种实现机制，也是查表，不过是按名称查表，是smalltalk等语言的实现机制。这两种方法的优缺点如下：
  • （1）按照绝对位置查表，这种方法由于编译阶段已经做好了索引和表项(如上面的call *(pa->vptr[1]） )，所以运行速度比较快;缺点是：当A的virtual成员比较多（比如1000个），而B重写的成员比较少（比如2个），这种时候，B的vtableＢ的剩下的998个表项都是放Ａ中的virtual成员函数的指针，如果这个派生体系比较大的时候，就浪费了很多的空间。
  • （２）按照函数名称查表，这种方案可以避免如上的问题；但是由于要比较名称，有时候要遍历所有的继承结构，时间效率性能不是很高。

总结：

• 如果继承体系的基类的virtual成员不多，而且在派生类要重写的部分占了其中的大多数时候，用C++的虚函数机制是比较好的；但是如果继承体系的基类的virtual成员很多，或者是继承体系比较庞大的时候，而且派生类中需要重写的部分比较少，那就用名称查找表，这样效率会高一些

4. 动态绑定与多态

• C++的多态性与动态绑定是分不开的,动态绑定是c++支持多态性的根本原因
• 多态是运行时绑定，动态绑定，指的是只有当运行阶段才能确定调用的函数

4.1 什么是动态绑定

• 函数运行的版本不是一开始就确定好了的而是在程序运行的时候才选择函数运行的版本，至于到底选择哪个函数版本取决于调用该函数的指针或者引用实际绑定的数据对象

4.2 动态绑定发生的条件？

• 当使用基类的指针或者引用去调用一个虚函数的时候才会发生动态绑定

4.3 动态绑定的实际意义

• 我们都知道c++语言支持面向对象编程，多态性是面向对象编程的三大特征之一，其实动态绑定是c++支持多态性的根本原因。为什么这么说呢？在c++语言中我们常用一个基类的指针或者引用去指向一个派生类对象，当我们通过基类的指针或者引用调用虚函数时，实际运行的虚函数版本取决于该基类指针或者引用绑定的真实数据类型(可能是派生类对象也可能是基类对象本身)。

4.4 程序

结果解析

• （1）ptrA->fun(); 我们是通过一个基类指针去调用一个虚函数，此时就会发生动态绑定，那么最后实际运行的fun函数版本取决于ptr指针实际绑定的数据对象，此时ptr指向的是objB也就是派生类的对象，所以最后实际调用的是派生类B中的fun函数。
• （2）ptrA->fun1(); 我们是通过一个基类指针去调用一个非虚函数，此时不会发生动态绑定，那么最后实际运行的fun1函数版本就是ptr指针的静态类型A对应的版本。
• （3）objA->fun(); 我们是通过一个基类对象去调用一个虚函数，此时不会发生动态绑定，那么最后实际运行的fun函数版本就是objA静态类型A对应的版本。
• （4）objA->fun1(); 我们是通过一个基类对象去调用一个非虚函数，此时不会发生动态绑定，那么最后实际运行的fun1函数版本就是objA静态类型A对应的版本。
  当我们通过基类的引用来调用虚函数或者非虚函数时产生的结果跟通过基类指针调用一样，在此我不再赘述。

源文章：ruyue_ruyue