C++基础之C++多态技术(1)

多态（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()。

宏多态

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

#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 carn";  
    }  
};  
// 派生于Vehicle的具体类Airplane  
class Airplane: public Vehicle  
{  
public:  
    virtual void run() const 
    {  
        std::cout << "run a airplanen";  
    }  
};  

客户程序可以通过指向基类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 carn";  
    }  
};  
//具体类Airplane  
class Airplane  
{  
public:  
    void run() const 
    {  
        std::cout << "run a airplanen";  
    }  
}; 

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  
}