C++的三大特性：封装、继承、多态

一、面向对象编程

在面向对象编程上可理解为：
1、把客观事物封装成抽象的类，
2、类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

二、三者之间的关系

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

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

继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。

而多态则是为了实现另一个目的——接口重用！

 

三、封装

1、封装是隐藏对象的属性和实现的细节，

2、对外只保留一个接口与对象交互，将数据与操作数据的方法进行有机结合。 

 

 在C++中，类封装通常分为下边两个部分
        -类的实现细节
        -类的使用方式

    在我们使用别人提供的类时，我们只关心使用方式，至于类内部是怎么实现，不需要去关心；同样，当我们提供类给别人使用时，别人也只需要知道如何使用，至于我们怎么实现类的内部细节，他们也是不需要关心的，只需要用好接口就行。
    -使用类时，不需要关心类的实现细节
    -创建类时，才需要考虑其内部实现细节

    

封装的基本概念
    -不是每个属性都需要对外公开(女人不公开体重跟年龄，男人不公开身高及收入)
    -有一些类的属性是对外公开的(名字、学历等)

    -必须在类的表示法中定义属性和行为的公开级别

C++中类的封装
    -成员变量：C++中用于表示类属性的变量
    -成员函数：C++中用于表示类行为的函数
    -C++中可以给成员变量和成员函数定义访问级别

        public属性：成员变量跟成员函数可以在类的内部和外界访问及调用

        private属性：成员变量跟成员函数只能在类的内部被访问跟调用

四、继承 

（一）继承是什么

 继承是指这样一种能力：它可以使用原有类的所有功能，并在无需重新编写原来的类的情况下多这些功能进行扩展

其继承的过程，就是从一般到特殊的过程

通过继承创建的新类称为"子类"或“派生类”。被继承的类称为“基类”、“父类”或者“超类”，要实现继承，可以通过“继承”和“组合”来实现。在某些OOP语言中，一个子类可以继承多个基类，但在一般情况下，一个基类只能有一个基类，要实现多继承，可以通过 多级继承

（二）、继承的实现方法

实现继承的方式：实现继承、接口继承和可视继承

1.实现继承：就是使用基类的属性和方法而不需额外编码的能力

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

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

五、多态

（一）、概念

多泰即多种状态（形态）。简单来说，我们可以把多态定义为消息以多种形式显示的能力

多态是以封装和继承为基础的

C++中

是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

(二)、多态分类以及实现

1.重载多态（编译期间）：函数重载、运算符重载

2，子类型重载（运行期间）：虚函数

3.参数多态性（编译器）：类模板，函数模板

4.强制多态（编译期间、运行期）：基本类型转换、自定义类型转换

虚函数重载

例子：（2012某**软件公司笔试题）

请按顺序写出下面代码的输出结果：

答案：call child func

call ~child

call ~base

多态的实现方式分析？

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

分析：

“重载”是指在同一个类中相同的返回类型和方法名，但是参数的个数和类型可以不同

“覆盖\重写”是在不同的类中。

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

C++多态机制的实现：

该部分转自：http://blog.chinaunix.net/uid-7396260-id-2056657.html

1、c++实现多态的方法

面向对象有了一个重要的概念就是对象的实例，对象的实例代表一个具体的对象，故其肯定有一个数据结构保存这实例的数据，这一数据包括对象成员变量，如果对象有虚函数方法或存在虚继承的话，则还有相应的虚函数或虚表指针，其他函数指针不包括。

虚函数在c++中的实现机制就是用虚表和虚指针，但是具体是怎样的呢？从more effecive c++其中一篇文章里面可以知道：是每个类用了一个虚表，每个类的对象用了一个虚指针。要讲虚函数机制，必须讲继承，因为只有继承才有虚函数的动态绑定功能，先讲下c++继承对象实例内存分配基础知识：

从more effecive c++其中一篇文章里面可以知道：是每个类用了一个虚表，每个类的对象用了一个虚指针。具体的用法如下：
class A
{public:
    virtual void f();
    virtual void g();
private:
    int a
};

class B : public A
{
public:
    void g();
private:
    int b;
};
//A，B的实现省略
因为A有virtual void f（），和g（），所以编译器为A类准备了一个虚表vtableA，内容如下：

 

A::f 的地址

A::g 的地址

B因为继承了A，所以编译器也为B准备了一个虚表vtableB，内容如下：

A::f 的地址

B::g 的地址

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

vptr ： 指向B的虚表vtableB

int a： 继承A的成员

int b： B成员

当如下语句的时候：
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经过反汇编分析出来的。
————————————————
版权声明：本文为CSDN博主「ruyue_ruyue」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ruyue_ruyue/article/details/8211809