【C++】让函数根据一个以上的对象来决定怎么虚拟

　　问题来源：假设正在编写一个小游戏，游戏的背景是发生在太空，有宇宙飞船、太空船和小行星，它们可能会互相碰撞，而且其碰撞的规则不同，如何用C++代码处理物体间的碰撞。代码的框架如下：

class GameObject{...};
class SpaceShip:public GameObject{...};
class SpaceStation:public GameObject{...};
class Asteroid:public GameObject{...};

void checkForCollision(GameObject& obj1,GameObject& obj2)
{
    if(theyJustCollided(obj1,obj2))
    {
        processCollision(obj1,obj2);
    }
    else
    {
        ...
    }
}

　　正如上述代码所示，当调用processCollision()时，obj1和obj2的碰撞结果取决于obj1和obj2的真实类型，但我们只知道它们是GameObject对象。相当于我们需要一种作用在多个对象上的虚函数。这类型问题，在C++中被称为二重调度问题，下面介绍几种方法解决二重调度问题。

1.虚函数加RTTI

　　虚函数实现了一个单一调度，我们只需要实现另一调度。其具体实现方法：将processCollision()定义为虚函数，解决一重调度，然后只需要检测一个对象类型，利用RTTI来检测对象的类型，再利用if...else语句来调用不同的处理方法。具体实现如下：

class GameObject{
public:
    virtual void collide(GameObject& otherObject) = 0;
    ...
};
class SpaceShip:public GameObject{
public:
    virtual void collide(GameObject& otherObject);
    ...
};

class CollisionWithUnknownObject{
public:
    CollisionWithUnknownObject(GameObject& whatWehit);
    ...
};
void SpaceShip::collide(GameObject& otherObject)
{
    const type_info& objectType = typeid(otherObject);
    if(objectType == typeid(SpaceShip))
    {
        SpaceShip& ss = static_cast<SpaceShip&>(otherObject);
        process a SpaceShip-SpaceShip collision;
    }
    else if(objectType == typeid(SpaceStation))
    {
        SpaceStation& ss = static_cast<SpaceStation&>(otherObject);
        process a SpaceShip-SpaceStation collision;
    }
    else if(objectType == typeid(Asteroid))
    {
        Asteroid& a = static_cast<Asteriod&>(otherObject);
        process a SpaceShip-Asteroid collision;
    }
    else 
    {
        throw CollisionWithUnknownObject(otherObject);
    }
}

　　该方法的实现简单，容易理解，其缺点是其扩展性不好。如果增加一个新的类时，我们必须更新每一个基于RTTI的if...else链以处理这个新的类型。

2.只使用虚函数

　　基本原理就是用两个单一调度实现二重调度，也就是有两个单单独的虚函数调用：第一次决定第一个对象的动态类型，第二次决定第二个对象动态类型。其具体实现如下：

class SpaceShip;
class SpaceStation;
class Asteroid;
class GameObject{
public:
    virtual void collide(GameObject& otherObject) = 0;
    virtual void collide(SpaceShip& otherObject) = 0;
    virtual void collide(SpaceStation& otherObject) = 0;
    virtual void collide(Asteroid& otherObject) = 0;
    ...
};
class SpaceShip:public GameObject{
public:
    virtual void collide(GameObject& otherObject);
    virtual void collide(SpaceShip& otherObject);
    virtual void collide(SpaceStation& otherObject);
    virtual void collide(Asteroid& otherObject);
    ...
};

void SpaceShip::collide(GameObject& otherObject)
{
    otherObject.collide(*this);
}
void SpaceShip::collide(SpaceShip& otherObject)
{
    process a SpaceShip-SpaceShip collision;
}
void SpaceShip::collide(SpaceStation& otherObject)
{
    process a SpaceShip-SpaceStation collision;
}
void SpaceShip::collide(Asteroid& otherObject)
{
    process a SpaceShip-Asteroid collision;
}

　　与前面RTTI方法一样，该方法的缺点扩展性不好。每个类都必须知道它的同胞类，当增加新类时，所有的代码都必须更新。

3.模拟虚函数表

　　编译器通常创建一个函数指针数组(vtbl)来实现虚函数，并在虚函数被调用时在这个数组中进行下标索引。我们可以借鉴编译器虚拟函数表的方法，建立一个对象到碰撞函数指针的映射，然后在这个映射中利用对象进行查询，获取对应的碰撞函数指针，进行函数调用。具体代码实现如下：

namespace{
    void shipAsteroid(GameObject& spaceShip,GameObject& asteroid);
    void shipStation(GameObject& spaceShip,GameObject& spaceStation);
    void asteroidStation(GameObject& asteroid,GameObject& spaceStation);
    ...
    //implement symmetry
    void asteroidShip(GameObject& asteroid,GameObject& spaceShip)
    {    shipAsteroid(spaceShip,asteroid);}
    void stationShip(GameObject& spaceStation,GameObject& spaceShip)
    {    shipStation(spaceShip,spaceStation);}
    void stationAsteroid(GameObject& spaceStation,GameObject& asteroid)
    {    asteroidStation(asteroid,spaceStation);}
    
    typedef void(*HitFunctionPtr)(GameObject&,GameObject&);
    typedef    map<pair<string,string>,HitFunctionPtr> HitMap;
    pair<string,string> makeStringPair(const char *s1,const char *s2);
    
    HitMap* initializeCollisionMap();
    HitFunctionPtr lookup(const string& class1,const string& class2);
}

void processCollision(GameObject& obj1,GameObject& obj2)
{
    HitFunctionPtr phf = lookup(typeid(obj1).name(),typeid(obj2).name());
    if(phf)
        phf(obj1,obj2);
    else
        throw UnknownCollision(obj1,obj2);
}

namespace{
    pair<string,string> makeStringPair(const char *s1,const char *s2)
    {
        return pair<string,string>(s1,s2);
    }
    
    HitMap* initializeCollisionMap()
    {
        HitMap *phm = new HitMap;
        (*phm)[makeStringPair("SpaceShip","Asteroid")] = &shipAsteroid;
        (*phm)[makeStringPair("SpaceShip","SpaceStation")] = &shipStation;
        ...
        return phm;
    }
    
    HitFunctionPtr lookup(const string& class1,const string& class2)
    {
        static auto_ptr<HitMap>    collisionMap(initializeCollisionMap());
        HitMap::iterator mapEntry = collisionMap->find(make_pair(class1,class2));
        if(mapEntry == collisionMap->end())
            return 0;
        return (*mapEntry).second;
    }
}

　　如上述代码所示，使用非成员函数来处理碰撞过程，根据obj1和obj2来查询初始化之后映射表，来确定对应的非成员函数指针。利用模拟虚函数表的方法，基本上完成了基于多个对象的虚拟化功能。但是为了更方便的使用代码，更方便的维护代码，我们还需要进一步完善其实现过程。

4.将映射表和注册映射表过程封装起来

　　由于具体应用的过程，映射表的映射关系存在着增加和删除的操作，因而需要把映射表封装类体，提供增加，删除等接口。具体实现如下：

class CollisionMap{
public:
    typedef void (*HitFunctionPtr)(GameObject&,GameObject&);
    void addEntry(const string& type1,const string& type2,HitFunctionPtr collisionFunction,bool symmetric = true);
    void removeEntry(const string& type1,const string& type2);
    HitFunctionPtr lookup(const string& type1,const string& type2);
    
    static CollisionMap& theCollisinMap();
private:
    CollisionMap();
    CollisinMap(const CollisionMap&);
};

　　在应用中，我们必须确保在发生碰撞前将映射关系加入了映射表。一个方法是让GameObject的子类在构造函数中进行确认，这将导致在运行期的性能开销，另外一个方法创建一个RegisterCollisionFunction类，用于完成映射关系的注册工作。RegisterCollisionFunction相应的代码如下：

class RegisterCollisionFunction{
public:
    RegisterCollisionFunction(const string& type1,const string& type2,CollisionMap::HitFunctionPtr collisionFunction,bool symmetric = true)
    {
        CollisionMap::theCollisionMap().addEntry(type1,type2,collisionFunction,symmetric);
    }
};
//利用此类型的全局对象来自动地注册映射关系
RegisterCollisionFunction cf1("SpaceShip","Asteroid",&shipAsteroid);
...

参考资料：More Effective C++