本文摘抄自：
http://www.jb51.net/article/86223.htm
https://www.cnblogs.com/dormant/p/5223215.html
http://blog.csdn.net/pzhw520hchy/article/details/51850289
http://blog.csdn.net/haoel/article/details/1948051/
http://huqunxing.site/2016/09/08/C++%20%E4%B8%89%E5%A4%A7%E7%89%B9%E6%80%A7%E4%B9%8B%E5%A4%9A%E6%80%81/
C++ 的三大特性：封装，继承，多态
封装可以使得代码模块化，继承可以扩展已存在的代码，而多态的目的则是为了接口重用。封装和继承的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
为什么要有多态？
前几天在网上看到这样的一个问题：
多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。但我搞不懂为什么要那么做，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不就行了么？
然后有人这样回答：
将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但是也各不相同。如果我在写驱动的时候，我用个父类表示外设接口，然后在子类中重写父类那个读取设备的虚函数，那这样电脑的外设接口只需要一个。但如果我不是这样做，而是用每个子类表示一个外设接口，那么我的电脑就必须有3个接口分别来读取移动硬盘、U盘以及MP3。若以后我还有SD卡读卡器，那我岂不是要将电脑拆了，焊个SD卡读卡器的接口上去？
重载、重写与重定义
一、重载（overload）
指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。
（1）相同的范围（在同一个作用域中） ；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
（5）返回值可以不同；
二、重写（也称为覆盖 override）
是指派生类重新定义基类的虚函数，特征是：
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有 virtual 关键字，不能有 static 。
（5）返回值相同（或是协变），否则报错；<—-协变这个概念我也是第一次才知道…
（6）重写函数的访问修饰符可以不同。尽管 virtual 是 private 的，派生类中重写改写为 public,protected 也是可以的
三、重定义（也称隐藏）
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同。此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及覆盖混淆）。
（5）参数相同，但是基类函数没有 virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
1 #include <iostream>
2 #include <complex>
3 using namespace std;
4
5 class Base
6 {
7 public:
8 virtual void a(int x) { cout << "Base::a(int)" << endl; }
9 // overload the Base::a(int) function
10 virtual void a(double x) { cout << "Base::a(double)" << endl; }
11 virtual void b(int x) { cout << "Base::b(int)" << endl; }
12 void c(int x) { cout << "Base::c(int)" << endl; }
13 };
14
15 class Derived : public Base
16 {
17 public:
18 // redefine the Base::a() function
19 void a(complex<double> x) { cout << "Derived::a(complex)" << endl; }
20 // override the Base::b(int) function
21 void b(int x) { cout << "Derived::b(int)" << endl; }
22 // redefine the Base::c() function
23 void c(int x) { cout << "Derived::c(int)" << endl; }
24 };
25
26 int main()
27 {
28 Base b;
29 Derived d;
30 Base* pb = new Derived;
31 // ----------------------------------- //
32 b.a(1.0); // Base::a(double)
33 d.a(1.0); // Derived::a(complex)
34 pb->a(1.0); // Base::a(double), This is redefine the Base::a() function
35 // pb->a(complex<double>(1.0, 2.0)); // clear the annotation and have a try
36 // ----------------------------------- //
37 b.b(10); // Base::b(int)
38 d.b(10); // Derived::b(int)
39 pb->b(10); // Derived::b(int), This is the virtual function
40 // ----------------------------------- //
41 delete pb;
42
43 return 0;
44 }
通过这里可以看出：
1. Base类中的第二个函数a是对第一个的重载
2. Derived类中的函数b是对Base类中函数b的重写，即使用了虚函数特性。
3. Derived类中的函数a是对Base泪中函数a的隐藏，即重定义了。
4.pb指针是一个指向Base类型的指针，但是它实际指向了一个Derived的空间，这里对pd调用函数的处理(多态性)取决于是否重写 (虚函数特性)了函数，若没有，则依然调用基类。
5. 只有在通过基类指针或基类引用 间接指向派生类类型时多态性才会起作用。
6. 因为Base类的函数c没有定义为virtual虚函数，所以Derived类的函数c是对Base::c()的重定义。
1 #include<iostream>
2 using namespace std;
3 //基类对象
4 class Base
5 {
6 public:
7 //有virtual关键字，运行时多态
8 virtual void f(float x)
9 {
10 cout<<"Base::f(float)"<< x <<endl;
11 }
12 //无viratul关键字，不会发生运行时多态
13 void g(float x)
14 {
15 cout<<"Base::g(float)"<< x <<endl;
16 }
17 void h(float x)
18 {
19 cout<<"Base::h(float)"<< x <<endl;
20 }
21 };
22 class Derived : public Base
23 {
24 public:
25 virtual void f(float x)
26 {
27 cout<<"Derived::f(float)"<< x <<endl; //多态、覆盖
28 }
29 //子类与父类的函数同名，无virtual关键字，则为隐藏
30 void g(int x)
31 {
32 cout<<"Derived::g(int)"<< x <<endl; //隐藏
33 }
34 void h(float x)
35 {
36 cout<<"Derived::h(float)"<< x <<endl; //隐藏
37 }
38 };
39 int main(void)
40 {
41 Derived d; //子类
42 Base *pb = &d; //基类指针指向子类
43 Derived *pd = &d; //子类指针指向自己
44 // Good : behavior depends solely on type of the object
45 pb->f(3.14f); // Derived::f(float) 3.14 调用子类，多态
46 pd->f(3.14f); // Derived::f(float) 3.14 调用子类
47 // Bad : behavior depends on type of the pointer
48 pb->g(3.14f); // Base::g(float) 3.14 无多态，调用自己的
49 pd->g(3.14f); // Derived::g(int) 3 无多态，调用自己的
50 // Bad : behavior depends on type of the pointer
51 pb->h(3.14f); // Base::h(float) 3.14 无多态，调用自己的
52 pd->h(3.14f); // Derived::h(float) 3.14 无多态，调用自己的
53 return 0;
54 }
C++中多态的机制主要是通过虚函数来实现的
虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。
假设我们有这样的一个类：
1 class Base {
2 public:
3 virtual void f() { cout << "Base::f" << endl; }
4 virtual void g() { cout << "Base::g" << endl; }
5 virtual void h() { cout << "Base::h" << endl; }
6 };
按照上面的说法，我们可以通过Base的实例来得到虚函数表。
1 typedef void( *Fun )( void );
2
3 int main()
4 {
5 Base b;
6 Fun pFun = NULL;
7 std::cout << "虚函数表地址：" << ( int* )( &b ) << std::endl;
8 std::cout << "虚函数表 — 第一个函数地址：" << ( int* ) * ( int* )( &b ) << std::endl;
9
10 // Invoke the first virtual function
11 pFun = ( Fun ) * ( ( int* ) * ( int* ) ( &b ) );
12 pFun();
13 };
实际运行经果如下：(Windows XP+VS2003, Windows7+VS2008, Linux 2.6.22 + GCC 4.1.3)
虚函数表地址：0012FED4
虚函数表 — 第一个函数地址：0044F148
Base::f
通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：
(Fun)*((int*)*(int*)(&b)+0); // Base::f()
(Fun)*((int*)*(int*)(&b)+1); // Base::g()
(Fun)*((int*)*(int*)(&b)+2); // Base::h()
如图所示：
注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“/0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。
下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。
一般继承（无虚函数覆盖）
假设有如下所示的一个继承关系：
请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：
对于实例：Derive d; 的虚函数表如下：
我们可以看到下面几点：
1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。
一般继承（有虚函数覆盖）
覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。
在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：
我们从表中可以看到下面几点，
1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
2）没有被覆盖的函数依旧。
这样，我们就可以看到对于下面这样的程序，
Base *b = new Derive();
b->f();
由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。
多重继承（无虚函数覆盖）
再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。
对于子类实例中的虚函数表，是下面这个样子：
我们可以看到：
1） 每个父类都有自己的虚表。
2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）
这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。
多重继承（有虚函数覆盖）
下面我们再来看看，如果发生虚函数覆盖的情况。
下图中，我们在子类中覆盖了父类的f()函数。
下面是对于子类实例中的虚函数表的图：
我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：
Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()
安全性
通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。
一、通过父类型的指针访问子类自己的虚函数
我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：
Base1 *b1 = new Derive();
b1->f1(); //编译出错
任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）
二、访问non-public的虚函数
另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。
如：
1 class Base
2 {
3 private:
4 virtual void f() { cout << "Base::f" << endl; }
5 };
6
7 class Derive : public Base
8 {
9 };
10
11 typedef void(*Fun)(void);
12
13 void main()
14 {
15 Derive d;
16 Fun pFun = (Fun)*((int*)*(int*)(&d)+0);
17 pFun();
18 }
附录
下面是一个关于多重继承的虚函数表访问的例程：
1 #include <iostream>
2
3 using namespace std;
4
5 class Base1
6 {
7
8 public:
9 virtual void f() { cout << "Base1::f" << endl; }
10 virtual void g() { cout << "Base1::g" << endl; }
11 virtual void h() { cout << "Base1::h" << endl; }
12
13 };
14
15 class Base2
16 {
17 public:
18 virtual void f() { cout << "Base2::f" << endl; }
19 virtual void g() { cout << "Base2::g" << endl; }
20 virtual void h() { cout << "Base2::h" << endl; }
21 };
22
23 class Base3
24 {
25
26 public:
27 virtual void f() { cout << "Base3::f" << endl; }
28 virtual void g() { cout << "Base3::g" << endl; }
29 virtual void h() { cout << "Base3::h" << endl; }
30 };
31
32
33
34
35
36 class Derive : public Base1, public Base2, public Base3
37 {
38
39 public:
40 virtual void f() { cout << "Derive::f" << endl; }
41 virtual void g1() { cout << "Derive::g1" << endl; }
42 };
43
44 typedef void(*Fun)(void);
45
46 int main()
47 {
48 Fun pFun = NULL;
49
50 Derive d;
51
52 int** pVtab = (int**)&d;
53
54 //Base1's vtable
55 //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
56 pFun = (Fun)pVtab[0][0];
57 pFun();
58
59 //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
60 pFun = (Fun)pVtab[0][1];
61 pFun();
62
63 //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
64 pFun = (Fun)pVtab[0][2];
65 pFun();
66
67 //Derive's vtable
68 //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
69 pFun = (Fun)pVtab[0][3];
70 pFun();
71
72 //The tail of the vtable
73 pFun = (Fun)pVtab[0][4];
74 cout<<pFun<<endl;
75
76 //Base2's vtable
77 //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
78 pFun = (Fun)pVtab[1][0];
79 pFun();
80
81 //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
82 pFun = (Fun)pVtab[1][1];
83 pFun();
84
85 pFun = (Fun)pVtab[1][2];
86 pFun();
87
88 //The tail of the vtable
89 pFun = (Fun)pVtab[1][3];
90 cout<<pFun<<endl;
91
92 //Base3's vtable
93 //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
94 pFun = (Fun)pVtab[2][0];
95 pFun();
96
97 //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
98 pFun = (Fun)pVtab[2][1];
99 pFun();
100
101 pFun = (Fun)pVtab[2][2];
102 pFun();
103
104 //The tail of the vtable
105 pFun = (Fun)pVtab[2][3];
106 cout<<pFun<<endl;
107
108 return 0;
109 }