C++多态

什么是多态

多态是C++中的一个重要的基础，可以这样说，不掌握多态就是C++的门外汉。然而长期以来，C++社群对于多态的内涵和外延一直争论不休。大有只见树木不见森林之势。多态到底是怎么回事呢？说实在的，我觉的多态这个名字起的不怎么好（或是译的不怎么好）。要是我给起名的话，我就给它定一个这样的名字–“调用’同名函数’却会因上下文不同会有不同的实现的一种机制”。这个名字长是长了点儿，可是比“多态”清楚多了。看这个长的定义，我们可以从中找出多态的三个重要的部分。一是“相同函数名”，二是“依据上下文”，三是“实现却不同”。嘿，还是个顺口溜呢。我们且把它们叫做多态三要素吧。

多态带来的好处

多态带来两个明显的好处：一是不用记大量的函数名了，二是它会依据调用时的上下文来确定实现。确定实现的过程由C++本身完成另外还有一个不明显但却很重要的好处是：带来了面向对象的编程。

C++中实现多态的方式

C++中共有三种实现多态的方式。由“容易说明白”到“不容易说明白”排序分别为。第一种是函数重载；第二种是模板函数；第三种是虚函数。

细说用函数重载实现的多态

函数重载是这样一种机制：允许有不同参数的函数有相同的名字。
具体一点讲就是：假如有如下三个函数：

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

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

    test(5);       //调用函数1
    test(‘c’);//调用函数2
    test(4,5); //调用函数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 << 1;    //输出int型
    cout << 8.9; //输出double型
    cout << ‘a’;   //输出char型
    cout << “abc”;//输出char数组型
    cout << endl; //输出一个函数

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

    cout int<< 1;                //输出int型
    cout double<< 8.9;          //输出double型
    cout char<< ‘a’;            //输出char型
    cout charArray<< “abc”;　    //输出char数组型
    cout function(…)<< endl;   //输出函数

为每一种要输出的类型起一个函数名，这岂不是很麻烦呀。

不过函数重载有一个美中不足之处就是不能为返回值不同的函数进行重载。那是因为人们常常不为函数调用指出返回值。并不是技术上不能通过返回值来进行重载。

细说用模板函数实现的多态

所谓模板函数（也有人叫函数模板）是这样一个概念：函数的内容有了，但函数的参数类型却是待定的（注意：参数个数不是待定的）。比如说一个(准确的说是一类或一群)函数带有两个参数，它的功能是返回其中的大值。这样的函数用模板函数来实现是适合不过的了。如下。

    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) > 0)?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
    }

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

小结

上面的两种多态在C++中有一个总称：静态多态。之所以叫它们静态多态是因为它们的多态是在编译期间就确定了。也就是说前面所说的函数1，2，3代码段1，2，3，4，5这些，在编译完成后，应该在什么样的上下文的调用中执行哪一些就确定了。比如：如果调用getMax(0.1, 0.2, 0.3)就会执行代码段5。如果调用test(5)就执行函数1。这些是在编译期间就能确定下来的。

静态多态还有一个特点，就是：“总和参数较劲儿”。

下面所要讲的一种多态就是必需是在程序的执行过程中才能确定要真正执行的函数。所以这种多态在C++中也被叫做动态多态。

细说用虚函数实现的多态

虚函数是怎么回事

首先来说一说虚函数，所谓虚函数是这样一个概念：基类中有这么一些函数，这些函数允许在派生类中其实现可以和基类的不一样。在C++中用关键字virtual来表示一个函数是虚函数。

C++中还有一个术语 “覆盖”与虚函数关系密切。所谓覆盖就是说，派生类中的一个函数的声明，与基类中某一个函数的声明一模一样,包括返回值，函数名，参数个数，参数类型，参数次序都不能有差异。（注1）说覆盖和虚函数关系密切的原因有两个：一个原因是，只有覆盖基类的虚函数才是安全的。第二个原因是，要想实现基于虚函数的多态就必须在派生类中覆盖基类的虚函数。

接下来让我们说一说为什么要有虚函数，分析一下为什么派生类非要在某些情况下覆盖基类的虚函数。就以那个非常著名的图形绘制的例子来说吧。假设我们在为一个图形系统编程。我们可能有如下的一个类结构。

形状对外公开一个函数来把自己绘制出来。这是合理的，形状就应该能绘制出来，对吧？由于继承的原因，多边形和圆形也有了绘制自己这个函数。

现在我们来讨论在这三个类中的绘制自己的函数都应该怎么实现。在形状中嘛，什么也不做就行了。在多边形中嘛,只要把它所有的顶点首尾相连起来就行了。在圆形中嘛，依据它的圆心和它的半径画一个360度的圆弧就行了。

可是现在的问题是：多边形和圆形的绘制自己的函数是从形状继承而来的，并不能做连接顶点和画圆弧的工作。

怎么办呢？覆盖它，覆盖形状中的绘制自己这个函数。于是我们在多边形和圆形中各做一个绘制自己的函数，覆盖形状中的绘制自己的函数。为了实现覆盖，我们需要把形状中的绘制自己这个函数用virtual修饰。而且形状中的绘制自己这个函数什么也不干，我们就把它做成一个纯虚函数。纯虚函数还有一个作用，就是让它所在的类成为抽象类。形状理应是一个抽象类，不是吗？于是我们很快写出这三个类的代码如下：

    // code 1
    class Shape//形状
    {
    public:
        virtualvoid DrawSelf()//绘制自己
        {
           cout << ”我是一个什么也绘不出的图形” << endl;
        }
    };
    // code 2 
    class Polygo:public Shape//多边形
    {
    public:
        void DrawSelf()   //绘制自己
        {
           cout << ”连接各顶点” << endl;
        }
    };
    // code 3    
    class Circ:public Shape//圆
    {
    public:
        void DrawSelf()   //绘制自己
        {
           cout << ”以圆心和半径为依据画弧” << endl;
        }
    };

下面，我们将以上面的这三个类为基础来说明动态多态。在进行更进一步的说明之前，我们先来说一个不得不说的两个概念：“子类型”和“向上转型”。

向上转型

子类型很好理解，比如上面的多边形和圆形就是形状的子类型。关于子类型还有一个确切的定义为：如果类型X扩充或实现了类型Y，那么就说X是Y的子类型。

向上转型的意思是说把一个子类型转的对象换为父类型的对象。就好比把一个多边形转为一个形状。向上转型的意思就这么简单，但它的意义却很深远。向上转型中有三点需要我们特别注意。第一，向上转型是安全的。第二，向上转型可以自动完成。第三，向上转型的过程中会丢失子类型信息。这三点在整个动态多态中发挥着重要的作用。

假如我们有如下的一个函数：

    void OutputShape( Shape arg)//专门负责调用形状的绘制自己的函数
    {
        arg.DrawSelf();
    }

那么现在我们可以这样使用OutputShape这个函数：

    Polygon shape1;
    Circ shape2;
    OutputShape(shape1);
    OutputShape(shape2);

我们之所以可以这样使用OutputShape函数，正是由于向上转型是安全的（不会有任何的编译警告），是由于向上转弄是自动的（我们没有自己把shape1和shape2转为Shape类型再传给OutputShape函数）。可是上面这段程序运行后的输出结果是这样的：

    我是一个什么也绘不出的图形
    我是一个什么也绘不出的图形

明明是一个多边形和一个圆呀，应该是输出这下面这个样子才合理呀！

    连接各顶点
    以圆心和半径为依据画弧

造成前面的不合理的输出的罪魁祸首正是‘向上转型中的子类型信息丢失’。为了得到一个合理的输出，得想个办法来找回那些丢失的子类型信息。C++中用一种比较巧妙的办法来找回那些丢失的子类型信息。这个办法就是采用指针或引用。

为什么要用指针或引用来实现动态多态

对于一个对象来说无论有多少个指针指向它，这些个指针所指的都是同一个对象。(即使你用一个void的指针指向一个对象也是这样的，不是吗？)同理对于引用也一样。

这究竟有多少深层次的意义呢？这里的深层的意义是这样的：子类型的信息本来就在它本身中存在，所以我们用一个基类的指针来指出它，这个子类型的信息也会被找到，同理引用也是一样的。C++正是利用了指针的这一特性。来做到动态多态的。(注2)现在让我们来改写OutputShape函数为这样：

    void OutputShape( Shape& arg)//专门负责调用形状的绘制自己的函数
    {
        arg.DrawSelf();
    }

现在我们的程序的输出为：

    连接各顶点
    以圆心和半径为依据画弧

这样的输出才是我们真正的想要的。我们实现的这种真正想要的输出就是动态多态的实质。

为什么动态多态要用public继承

在我们上面的代码中，圆和多边形都是从形状公有继承而来的。要是我们把圆的继承改为私有或保护会怎么样呢？我们来试一试。哇，我们得到一个编译错误。这个错误的大致意思是说：“请不要用一个私有的方法”。怎么回事呢？

是这么回事。它的意思是说下面这样说不合理。
所有的形状都可以画出来，圆这种形状是不能画出来的。
这样合理吗？不合理。所以请在多态中使用公有继承吧。

总结

多态的思想其实早在面向对象的编程出现之前就有了。比如C语言中的+运算符。这个运算符可以对两个int型的变量求和，也可以对两个char的变量求和，也可以对一个int型一个char型的两个变量求和。加法运算的这种特性就是典型的多态。所以说多态的本质是同样的用法在实现上却是不同的。

附录：

注1：严格地讲返回值可以不同，但这种不同是有限制的。详细情况请看有关协变的内容。
注2：C++会悄悄地在含有虚函数的类里面加一个指针。用这个指针来指向一个表格。这个表格会包含每一个虚函数的索引。用这个索引来找出相应的虚函数的入口地址。对于我们所举的形状的例子来说，C++会悄悄的做三个表，Shape一个，Polygon一个，Circ一个。它们分别记录一个DrawSelf函数的入口地址。在程序运行的过程中，C++会先通过类中的那个指针来找到这个表格。再从这个表格中查出DrawSelf的入口地址。然后现通过这个入口地址来调用正直的DrawSelf。正是由于这个查找的过程，是在运行时完成的。所以这样的多态才会被叫做动态多态（运行时多态）。

C++多态技术

作者：荣耀

摘要

本文描述了C++中的各种多态性。重点阐述了面向对象的动态多态和基于模板的静态多态，并初步探讨了两种技术的结合使用。

关键词

多态 继承 虚函数 模板 宏 函数重载 泛型编程 泛型模式

导言

多态（polymorphism）一词最初来源于希腊语polumorphos，含义是具有多种形式或形态的情形。在程序设计领域，一个广泛认可的定义是“一种将不同的特殊行为和单个泛化记号相关联的能力”。和纯粹的面向对象程序设计语言不同，C++中的多态有着更广泛的含义。除了常见的通过类继承和虚函数机制生效于运行期的动态多态（dynamic polymorphism）外，模板也允许将不同的特殊行为和单个泛化记号相关联，由于这种关联处理于编译期而非运行期，因此被称为静态多态（static polymorphism）。

事实上，带变量的宏和函数重载机制也允许将不同的特殊行为和单个泛化记号相关联。然而，习惯上我们并不将它们展现出来的行为称为多态（或静态多态）。今天，当我们谈及多态时，如果没有明确所指，默认就是动态多态，而静态多态则是指基于模板的多态。不过，在这篇以C++各种多态技术为主题的文章中，我们首先还是回顾一下C++社群争论已久的另一种“多态”：函数多态（function polymorphism），以及更不常提的“宏多态（macro polymorphism）”。

函数多态

也就是我们常说的函数重载（function overloading）。基于不同的参数列表，同一个函数名字可以指向不同的函数定义：

    // overload_poly.cpp

    #include <iostream>
    #include <string>

    // 定义两个重载函数

    int my_add(int a, int b)
    {
        return a + b;
    }

    int my_add(int a, std::string b)
    {
        return a + atoi(b.c_str());
    }

    int main()
    {
        int i = my_add(1, 2);                // 两个整数相加
        int s = my_add(1, “2”);              // 一个整数和一个字符串相加
        std::cout << “i = ” << i << “\n”;
        std::cout << “s = ” << s << “\n”;
    } 

根据参数列表的不同（类型、个数或兼而有之），my_add(1, 2)和my_add(1, “2”)被分别编译为对my_add(int, int)和my_add(int, std::string)的调用。实现原理在于编译器根据不同的参数列表对同名函数进行名字重整，而后这些同名函数就变成了彼此不同的函数。比方说，也许某个编译器会将my_add()函数名字分别重整为my_add_int_int()和my_add_int_str()。

宏多态

带变量的宏可以实现一种初级形式的静态多态：

    // macro_poly.cpp

    #include <iostream>
    #include <string>

    // 定义泛化记号：宏ADD
    #define ADD(A, B) (A) + (B);

    int main()
    {
        int i1(1), i2(2);
        std::string s1(“Hello, “), s2(“world!”);
        int i = ADD(i1, i2);                        // 两个整数相加
        std::string s = ADD(s1, s2);                // 两个字符串“相加”
        std::cout << “i = ” << i << “\n”;
        std::cout << “s = ” << s << “\n”;
    }

当程序被编译时，表达式ADD(i1, i2)和ADD(s1, s2)分别被替换为两个整数相加和两个字符串相加的具体表达式。整数相加体现为求和，而字符串相加则体现为连接。程序的输出结果符合直觉：

    1 + 2 = 3
    Hello, + world! = Hello, world! 

动态多态

这就是众所周知的的多态。现代面向对象语言对这个概念的定义是一致的。其技术基础在于继承机制和虚函数。例如，我们可以定义一个抽象基类Vehicle和两个派生于Vehicle的具体类Car和Airplane：

    // dynamic_poly.h

    #include <iostream>

    // 公共抽象基类Vehicle
    class Vehicle
    {
    public:
        virtual void run() const = 0;
    };

    // 派生于Vehicle的具体类Car
    class Car: public Vehicle
    {
    public:
        virtual void run() const
        {
            std::cout << “run a car\n”;
        }
    };

    // 派生于Vehicle的具体类Airplane
    class Airplane: public Vehicle
    {
    public:
        virtual void run() const
        {
            std::cout << “run a airplane\n”;
        }
    }; 

客户程序可以通过指向基类Vehicle的指针（或引用）来操纵具体对象。通过指向基类对象的指针（或引用）来调用一个虚函数，会导致对被指向的具体对象之相应成员的调用：

    // dynamic_poly_1.cpp

    #include <iostream>
    #include <vector>
    #include “dynamic_poly.h”

    // 通过指针run任何vehicle
    void run_vehicle(const Vehicle* vehicle)
    {
        vehicle->run();            // 根据vehicle的具体类型调用对应的run()
    }

    int main()
    {
        Car car;
        Airplane airplane;
        run_vehicle(&car);         // 调用Car::run()
        run_vehicle(&airplane);    // 调用Airplane::run()
    }

此例中，关键的多态接口元素为虚函数run()。由于run_vehicle()的参数为指向基类Vehicle的指针，因而无法在编译期决定使用哪一个版本的run()。在运行期，为了分派函数调用，虚函数被调用的那个对象的完整动态类型将被访问。这样一来，对一个Car对象调用run_vehicle()，实际上将调用Car::run()，而对于Airplane对象而言将调用Airplane::run()。
或许动态多态最吸引人之处在于处理异质对象集合的能力：

    // dynamic_poly_2.cpp

    #include <iostream>
    #include <vector>
    #include “dynamic_poly.h”

    // run异质vehicles集合
    void run_vehicles(const std::vector<Vehicle*>& vehicles)
    {
        for (unsigned int i = 0; i < vehicles.size(); ++i)
        {
            vehicles[i]->run();     // 根据具体vehicle的类型调用对应的run()
        }
    }

    int main()
    {
        Car car;
        Airplane airplane;
        std::vector<Vehicle*> v;    // 异质vehicles集合
        v.push_back(&car);
        v.push_back(&airplane);
        run_vehicles(v);            // run不同类型的vehicles
    }

在run_vehicles()``中，vehicles[i]->run()“`依据正被迭代的元素的类型而调用不同的成员函数。这从一个侧面体现了面向对象编程风格的优雅。

静态多态

如果说动态多态是通过虚函数来表达共同接口的话，那么静态多态则是通过“彼此单独定义但支持共同操作的具体类”来表达共同性，换句话说，必须存在必需的同名成员函数。

我们可以采用静态多态机制重写上一节的例子。这一次，我们不再定义vehicles类层次结构，相反，我们编写彼此无关的具体类Car和Airplane（它们都有一个run()成员函数）：

    // static_poly.h

    #include <iostream>

    //具体类Car
    class Car
    {
    public:
        void run() const
        {
            std::cout << “run a car\n”;
        }
    };

    //具体类Airplane
    class Airplane
    {
    public:
        void run() const
        {
            std::cout << “run a airplane\n”;
        }
    };

run_vehicle()应用程序被改写如下：

    // static_poly_1.cpp

    #include <iostream>
    #include <vector>
    #include “static_poly.h”

    // 通过引用而run任何vehicle
    template <typename Vehicle>
    void run_vehicle(const Vehicle& vehicle)
    {
        vehicle.run();            // 根据vehicle的具体类型调用对应的run()
    }

    int main()
    {
        Car car;
        Airplane airplane;
        run_vehicle(car);         // 调用Car::run()
        run_vehicle(airplane);    // 调用Airplane::run()
    } 

现在Vehicle用作模板参数而非公共基类对象（事实上，这里的Vehicle只是一个符合直觉的记号而已，此外别无它意）。经过编译器处理后，我们最终会得到run_vehicle<Car>()和run_vehicle<Airplane>()两个不同的函数。这和动态多态不同，动态多态凭借虚函数分派机制在运行期只有一个run_vehicle()函数。
我们无法再透明地处理异质对象集合了，因为所有类型都必须在编译期予以决定。不过，为不同的vehicles引入不同的集合只是举手之劳。由于无需再将集合元素局限于指针或引用，我们现在可以从执行性能和类型安全两方面获得好处：

    // static_poly_2.cpp

    #include <iostream>
    #include <vector>
    #include “static_poly.h”

    // run同质vehicles集合
    template <typename Vehicle>
    void run_vehicles(const std::vector<Vehicle>& vehicles)
    {
        for (unsigned int i = 0; i < vehicles.size(); ++i) 
        {
            vehicles[i].run();            // 根据vehicle的具体类型调用相应的run()
        }
    }

    int main()
    {
        Car car1, car2;
        Airplane airplane1, airplane2;

        std::vector<Car> vc;              // 同质cars集合
        vc.push_back(car1);
        vc.push_back(car2);
        //vc.push_back(airplane1);        // 错误：类型不匹配
        run_vehicles(vc);                 // run cars

        std::vector<Airplane> vs;         // 同质airplanes集合
        vs.push_back(airplane1);
        vs.push_back(airplane2);
        //vs.push_back(car1);             // 错误：类型不匹配
        run_vehicles(vs);                 // run airplanes
    }

两种多态机制的结合使用

在一些高级C++应用中，我们可能需要结合使用动态多态和静态多态两种机制，以期达到对象操作的优雅、安全和高效。例如，我们既希望一致而优雅地处理vehicles的run问题，又希望“安全而高效”地完成给飞行器（飞机、飞艇等）进行“空中加油”这样的高难度动作。为此，我们首先将上面的vehicles类层次结构改写如下：

    // dscombine_poly.h

    #include <iostream>
    #include <vector>

    // 公共抽象基类Vehicle
    class Vehicle
    {
        public:
        virtual void run() const = 0;
    };

    // 派生于Vehicle的具体类Car
    class Car: public Vehicle
    {
    public:
        virtual void run() const
        {
            std::cout << “run a car\n”;
        }
    };

    // 派生于Vehicle的具体类Airplane
    class Airplane: public Vehicle
    {
    public:
        virtual void run() const
        {
            std::cout << “run a airplane\n”;
        }

        void add_oil() const
        {
            std::cout << “add oil to airplane\n”;
        }
    };

    // 派生于Vehicle的具体类Airship
    class Airship: public Vehicle
    {
    public:
        virtual void run() const
        {
            std::cout << “run a airship\n”;
        }

        void add_oil() const
        {
            std::cout << “add oil to airship\n”;
        }
    };

我们理想中的应用程序可以编写如下：

    // dscombine_poly.cpp

    #include <iostream>
    #include <vector>
    #include “dscombine_poly.h”

    // run异质vehicles集合
    void run_vehicles(const std::vector<Vehicle*>& vehicles)
    {
        for (unsigned int i = 0; i < vehicles.size(); ++i)
        {
            vehicles[i]->run();                 // 根据具体的vehicle类型调用对应的run()
        }
    }

    // 为某种特定的aircrafts同质对象集合进行“空中加油”
    template <typename Aircraft>
    void add_oil_to_aircrafts_in_the_sky(const std::vector<Aircraft>& aircrafts)
    {
        for (unsigned int i = 0; i < aircrafts.size(); ++i)
        {
            aircrafts[i].add_oil();
        }
    }

    int main()
    {
        Car car1, car2;
        Airplane airplane1, airplane2;

        Airship airship1, airship2;
        std::vector<Vehicle*> v;                // 异质vehicles集合
        v.push_back(&car1);
        v.push_back(&airplane1);
        v.push_back(&airship1);
        run_vehicles(v);                        // run不同种类的vehicles

        std::vector<Airplane> vp;               // 同质airplanes集合
        vp.push_back(airplane1);
        vp.push_back(airplane2);
        add_oil_to_aircrafts_in_the_sky(vp);    // 为airplanes进行“空中加油”

        std::vector<Airship> vs;                // 同质airships集合
        vs.push_back(airship1);
        vs.push_back(airship2);
        add_oil_to_aircrafts_in_the_sky(vs);    // 为airships进行“空中加油”
    } 

我们保留了类层次结构，目的是为了能够利用run_vehicles()一致而优雅地处理异质对象集合vehicles的run问题。同时，利用函数模板add_oil_to_aircrafts_in_the_sky<Aircraft>()，我们仍然可以处理特定种类的vehicles — aircrafts（包括airplanes和airships）的“空中加油”问题。其中，我们避开使用指针，从而在执行性能和类型安全两方面达到了预期目标。

结语

长期以来，C++社群对于多态的内涵和外延一直争论不休。在comp.object这样的网络论坛上，此类话题争论至今仍随处可见。曾经有人将动态多态（dynamic polymorphism）称为inclusion polymorphism，而将静态多态（static polymorphism）称为parametric polymorphism或parameterized polymorphism。

我注意到2003年斯坦福大学公开的一份C++ and Object-Oriented Programming教案中明确提到了函数多态概念：Function overloading is also referred to as function polymorphism as it involves one function having many forms。文后的“参考文献”单元给出了这个网页链接。

可能你是第一次看到宏多态（macro polymorphism）这个术语。不必讶异 — 也许我就是造出这个术语的“第一人”。显然，带变量的宏（或类似于函数的宏或伪函数宏）的替换机制除了免除小型函数的调用开销之外，也表现出了类似的多态性。在我们上面的例子中，字符串相加所表现出来的符合直觉的连接操作，事实上是由底部运算符重载机制（operator overloading）支持的。值得指出的是，C++社群中有人将运算符重载所表现出来的多态称为ad hoc polymorphism。

David Vandevoorde和Nicolai M. Josuttis在他们的著作C++ Templates: The Complete Guide一书中系统地阐述了静态多态和动态多态技术。因为认为“和其他语言机制关系不大”，这本书没有提及“宏多态”（以及“函数多态”）。（需要说明的是，笔者本人是这本书的繁体中文版译者之一，本文正是基于这本书的第14章The Polymorphic Power of Templates编写而成）

动态多态只需要一个多态函数，生成的可执行代码尺寸较小，静态多态必须针对不同的类型产生不同的模板实体，尺寸会大一些，但生成的代码会更快，因为无需通过指针进行间接操作。静态多态比动态多态更加类型安全，因为全部绑定都被检查于编译期。正如前面例子所示，你不可将一个错误的类型的对象插入到从一个模板实例化而来的容器之中。此外，正如你已经看到的那样，动态多态可以优雅地处理异质对象集合，而静态多态可以用来实现安全、高效的同质对象集合操作。

静态多态为C++带来了泛型编程（generic programming）的概念。泛型编程可以认为是“组件功能基于框架整体而设计”的模板编程。STL就是泛型编程的一个典范。STL是一个框架，它提供了大量的算法、容器和迭代器，全部以模板技术实现。从理论上讲，STL的功能当然可以使用动态多态来实现，不过这样一来其性能必将大打折扣。

静态多态还为C++社群带来了泛型模式（generic patterns）的概念。理论上，每一个需要通过虚函数和类继承而支持的设计模式都可以利用基于模板的静态多态技术（甚至可以结合使用动态多态和静态多态两种技术）而实现。正如你看到的那样，Andrei Alexandrescu的天才作品Modern C++ Design: Generic Programming and Design Patterns Applied（Addison-Wesley）和Loki程序库已经走在了我们的前面。

参考文献
1. David Vandevoorde, Nicolai M. Josuttis, C++ Templates: The Complete Guide, Addison Wesley, 2002.
2. Chris Neumann, CS193d (Summer 2003) C++ and Object-Oriented Programming, http://www.stanford.edu/class/cs193d/, 2003.\

参考1
参考2