c++ 多态，虚函数、重载函数、模版函数

c++三大特性：封装、继承、多态。封装使代码模块化，继承扩展已存在的代码，多态的目的是为了接口重用

虚函数实现：虚函数表；指针放到虚函数表

多态：同名函数对应到不同的实现

构造父类指针指向子类的对象

father *p = new son();

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

虚函数的目的就是通知系统在函数调用时能够自动识别对应的类对象类型，从而能够根据指针所指类型调用对应的类对象，实现函数调用时的多态性。

C++ 支持两种多态性：编译时多态性，运行时多态性
a、编译时多态性（静态多态）：通过重载函数实现
b、运行时多态性（动态多态）：通过虚函数实现

多态的作用：

那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法

c++中共有三种实现多态的方式：第一种是函数重载；第二种是模板函数；第三种是虚函数

1.虚函数：

有virtual才可能发生动态多态现象，无virtual调用就按原类型调用

虚函数： 就是允许被其子类重新定义的成员函数，子类重新定义父类虚函数的做法，可实现成员函数的动态覆盖（Override）。

纯虚函数： 是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”

virtual void funtion()=

抽象类： 包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能进行实例化。

纯虚函数的作用：

　　　　a.为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。

　　　　b.在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。

析构函数能否为虚？

能。

为什么基类的析构函数必须为虚？

如果不为虚函数，只释放基类，不释放子类，造成内存泄漏

基类指针指向子类对象创建实例，而将这个对象释放的时候，调用的是基类析构函数；如果基类析构函数不是虚函数，那么只会释放基类的部分，而子类部分不会被释放。基类析构函数是虚函数时，则调用子类析构函数，基类子类都释放，这样释放才完整。

2.函数重载：

函数重载是这样一种机制：允许有不同参数的函数有相同的名字

具体一点讲就是：假如有如下三个函数：

void test(int arg){}         //函数1
void test(char arg){}         //函数2
void test(int arg1,int arg2){}    //函数3

如果在C中编译，将会得到一个名字冲突的错误而不能编译通过。在C++中这样做是合法的。可是当我们调用test的时候到底是会调用上面三个函数中的哪一个呢？这要依据你在调用时给的出的参数来决定。如下：

test();       //调用函数1
test('c');//调用函数2
test(,); //调用函数3

C++是如何做到这一点的呢？原来聪明的C++编译器在编译的时候悄悄的在我们的函数名上根据函数的参数的不同做了一些不同的记号。具体说如下：

void test(int arg)            //被标记为　‘test有一个int型参数’
void test(char arg)           //被标记为　‘test有一个char型的参数’
void test(int arg1,int arg2) //被标记为　‘test第一个参数是int型，第二个参数为int型’

这样一来当我们进行对test的调用时，C++就可以根据调用时的参数来确定到底该用哪一个test函数了。噢，聪明的C++编译器。其实C++做标记做的比我上面所做的更聪明。我上面哪样的标记太长了。C++编译器用的标记要比我的短小的多。看看这个真正的C++的对这三个函数的标记：

test@@YAXD@Z
test@@YAXH@Z
test@@YAXHH@Z

是不是短多了。但却不好看明白了。好在这是给计算机看的，人看不大明白是可以理解的。 还记得cout吧。我们用<<可以让它把任意类型的数据输出。比如可以象下面那样：

 cout << ;    //输出int型
 cout << 8.9; //输出double型
 cout << 'a';   //输出char型
 cout << "abc";//输出char数组型
 cout << endl; //输出一个函数

cout之所以能够用一个函数名<<（<<是一个函数名）就能做到这些全是函数重载的功能。要是没有函数重载，我们也许会这样使用cout，如下：

    cout int<< ;                //输出int型
    cout double<< 8.9;          //输出double型
    cout char<< 'a';            //输出char型
    cout charArray<< "abc";　    //输出char数组型
    cout function(…)<< endl;   //输出函数

为每一种要输出的类型起一个函数名，这岂不是很麻烦呀。 不过函数重载有一个美中不足之处就是不能为返回值不同的函数进行重载。那是因为人们常常不为函数调用指出返回值。并不是技术上不能通过返回值来进行重载。

3.模版函数：

概念：函数的内容有了，但函数的参数类型却是待定的（注意：参数个数不是待定的）

比如说一个(准确的说是一类或一群)函数带有两个参数，它的功能是返回其中的大值。这样的函数用模板函数来实现是适合不过的了。如下：

template < typename T>
T getMax(T arg1, T arg2)
{
    return arg1 > arg2 ? arg1:arg2; //代码段1
}

这就是基于模板的多态吗？不是。因为现在我们不论是调用getMax(1, 2)还是调用getMax(3.0, 5.0)都是走的上面的函数定义。它没有根据调用时的上下文不同而执行不同的实现。所以这充其量也就是用了一个模板函数，和多态不沾边。怎样才能和多态沾上边呢？用模板特化呀！象这样：

template<>
char* getMax(char* arg1, char* arg2)
{
    return (strcmp(arg1, arg2) > )?arg1:arg2;//代码段2
}

这样一来当我们调用getMax(“abc”, “efg”)的时候，就会执行代码段2，而不是代码段1。这样就是多态了。 更有意思的是如果我们再写这样一个函数：

char getMax(char arg1, char arg2)
{
    return arg1>arg2?arg1:arg2; //代码段3
}

当我们调用getMax(‘a’, ‘b’)的时候，执行的会是代码段3，而不是代码段1或代码段2。C++允许对模板函数进行函数重载，就象这个模板函数是一个普通的函数一样。于是我们马上能想到写下面这样一个函数来做三个数中取大值的处理：

int getMax( int arg1, int arg2, int arg3)
{
    return getMax(arg1, max(arg2, arg3) );　//代码段4
}

同样我们还可以这样写：

template <typename T>
T getMax(T arg1, T arg2, T arg3)
{
    return getMax(arg1, getMax(arg2, arg3) ); //代码段5
}

现在看到结合了模板的多态的威力了吧。比只用函数重载厉害多了

模版函数就是函数模版生成的具体的函数，比如 getmax(int arg1,int arg2,int arg3)

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/

https://my.oschina.net/zhjunjun/blog/1505594