C++三大特征：封装 继承 多态

面向对象的三个基本特征

面向对象的三个基本特征是：封装、继承、多态

封装可以隐藏实现细节，使得代码模块化

继承可以扩展已存在的代码模块（类）

封装和继承的目的都是为了代码重用，而多态则是为了实现接口重用

 

---

封装

定义：封装就是将抽象得到的数据和行为相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成类，其中数据和函数都是类的成员，目的在于将对象的使用者和设计者分开，以提高软件的可维护性和可修改性

特性：1. 结合性，即是将属性和方法结合；2. 信息隐蔽性，利用接口机制隐蔽内部实现细节，只留下接口给外界调用；3. 实现代码重用

代码如下：

class Animal
{
public: //这就是公共成员,外部的接口
    void SetAnimalName(string strname);
    void ShowAnimalName();
private: //这是私有成员，外部是无法访问到的
    string m_strName;
};

我们可以通过封装使一部分成员充当类与外部的接口，而将其它的成员隐藏起来，这样就限制了外部对成员的访问，也使不同类之间的相互影响度降低

---

继承

定义：继承就是新类从已有类那里得到已有的特性。 类的派生指的是从已有类产生新类的过程。原有的类成为基类或父类，产生的新类称为派生类或子类，子类继承基类后，可以创建子类对象来调用基类函数，变量等

单一继承：继承一个父类，这种继承称为单一继承，一般情况尽量使用单一继承，使用多重继承容易造成混乱易出问题

多重继承：继承多个父类，类与类之间要用逗号隔开，类名之前要有继承权限，假使两个或两个基类都有某变量或函数，在子类中调用时需要加类名限定符如c.a::i = 1

菱形继承：多重继承掺杂隔代继承1-n-1模式，此时需要用到虚继承，例如 B，C虚拟继承于A，D再多重继承B，C，否则会出错

继承方式：继承方式规定了如何访问继承的基类的成员。继承方式指定了派生类成员以及类外对象对于从基类继承来的成员的访问权限

继承权限：子类继承基类除构造和析构函数以外的所有成员

权限图如下：

继承概念的实现方式有三类：实现继承、接口继承和可视继承

1、实现继承是指使用基类的属性和方法而无需额外编码的能力

2、接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力

3、可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力

为了便于理解，伪代码如下：

class Animal    //父类
{
    public:
        void eat()
        {
            cout<<"animal eat"<<endl;
        }
    protected:
        void sleep()
        {
            cout<<"animal sleep"<<endl;
        }
    private:
        void breathe(
        {
            cout<<"animal breathe"<<endl;
        }
};

class Fish:public Animal    //子类
{
    public:
        void test()
        {
            eat();    //此时eat()的访问权限为public，在类内部能够访问
            sleep();    //此时sleep()的访问权限为protected，在类内部能够访问
            breathe();    //此时breathe()的访问权限为no access，在类内部不能够访问
        }
};

int main(void)
{
    Fish f;
  　f.eat();    //此时eat()的访问权限为public，在类外部能够访问
    f.sleep();    //此时sleep()的访问权限为protected，在类外部不能够访问
  　f.breathe()；    //此时breathe()的访问权限为no access，在类外部不能够访问
}　　　

---

多态

定义：允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。可以简单概括为“一个接口，多种方法”，即用的是同一个接口，但是效果各不相同

实现多态有二种方式：覆盖和重载

覆盖：是指子类重新定义父类的虚函数的做法

重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）

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

---

实现多态的方法

虚函数：用virtual关键字修饰的函数；本质：由虚指针和虚表控制，虚指针指向虚表中的某个函数入口地址，就实现了多态；作用：实现了多态，虚函数可以被子类重写，虚函数地址存储在虚表中

纯虚函数：含有至少一个纯虚函数的类叫抽象类，因为抽象类含有纯虚函数，所以其虚表是不健全的，在虚表不健全的情况下是不能实例化对象的，子类继承抽象基类后必须重写基类的所有纯虚函数，否则子类仍为纯虚函数子类将抽象基类的纯虚函数全部重写后会将虚表完善，此时子类才能实例化对象，纯虚函数只声明不定义，形如 virtual void print() = 0 

c++实现多态的方法：http://blog.chinaunix.net/uid-7396260-id-2056657.html

可以分析一下如下代码的输出：

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
using namespace std;

class Father
{
public:
    void Face()
    {
        cout << "Father's face" << endl;
    }

    virtual void Say()
    {
        cout << "Father say hello" << endl;
    }
};

class Son:public Father
{
public:
    void Say()
    {
        cout << "Son say hello" << endl;
    }
};

void main()
{
    Son son;
    Father *pFather=&son; // 隐式类型转换
    pFather->Say();
}

输出结果