item31让函数根据一个以上的对象类型来决定如何虚化

#include <iostream>
/*
    >如果宇宙飞船以低速与太空站碰撞，宇宙飞船会泊进太空站（程序没有涉及）
    否则宇宙飞船和太空站受到的损害与其速度成正比

    >如果宇宙飞船与宇宙飞船碰撞，或是太空站与太空站碰撞，都会受损，受到的损害与其速度成正比

    >如果小号的小行星与宇宙飞船或太空站相撞，小行星会损毁。如果碰到的是大号小行星，
    那宇宙飞船或太空站损毁

    >如果小行星撞击另一颗小行星，两者都碎裂成更小的小行星，且想四面八方散去
*/
class GameObject{ ... };
class SpaceShip : public GameObject{... };
class SpaceStation : public GameObject{... };
class Asteroid : public GameObject{... };

void checkForCollision(GameObject&, GameObject&)
{
    if(theyJustCollision(lhs, rhs))
        processCollision(lhs, rhs)
        else
        ...
}//

//virtual fcn + RTTI
// if_then_else way
class GameObject{ 
    virtual void collide(GameObject& otherObject) = 0;
 };
class SpaceShip : public GameObject{... };
class SpaceStation : public GameObject{... };
class Asteroid : public GameObject{... };

class CollisionWithUnKnowObject{//except class
public:
    CollisionWithUnKnowObject(GameObject& whatWeHit);//why?
}
void SpaceShip::collide(GameObject& otherObject)
{
    const type_info& objectType = typeid(otherObject);//lookup typeid & type_info

    if(objectType == typeid(SpaceShip))
        SpaceShip& ss = static_cast<SpaceShip&>(otherObject);

    process a SpaceShip-SpaceShip collision;
    else if (objectType == typeid(SpaceStation))//--copy
        SpaceShip& ss = static_cast<SpaceStation&>(otherObject);

    process a SpaceShip-SpaceStation collision;
    else if (objectType == typeid(Asteroid))
        SpaceShip& ss = static_cast<Asteroid&>(otherObject);

    process a SpaceShip-Asteroid collision;//copy end
    else
        throw CollisionWithUnKnowObject(otherObject);
};

/*
*/

/////////////////////////////////////
 //overload只用虚函数，有图1
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) ;
 };

//impoint point:
virtual void collide(GameObject& otherObject) 
{
    otherObject.collide(*this);
}
//
class SpaceStation : public GameObject{... };
class Asteroid : public GameObject{... };

//////////////////////////////////////
// virtual FCN Tables way
class GameObject{ 
public:
    virtual void collide(GameObject& otherObject) ;
    virtual void hitSpaceShip(SpaceShip& otherObject) ;
    virtual void hitSpaceStation(SpaceStation& otherObject) ;
    virtual void hitAsteroid(Asteroid& otherObject) ;
 };

class SpaceShip : public GameObject{
private://!!
    typedef void (SpaceShip::*HitFCNPtr)(GameObject&);//!!
    static HitFCNPtr lookup(const GameObject& whatWeHit);
 };
void SpaceShip::collide(GameObject& otherObject)
{
    HitFCNPtr hfp = lookup(otherObject);

    if(hfp)
    { this->*hfp}(otherObject);
    else
        throw CollisionWithUnKnowObject(otherObject);
}
class SpaceShip : public GameObject{
private:
    typedef void (SpaceShip::*HitFCNPtr)(GameObject&);
    typedef map<string, HitFCNPtr> HitMap;
 };
void SpaceShip::lookup()
{
    static HitMap collisionMap;//static in fcn !!

    //init
    collisionMap["SpaceShip"] = &hitSpaceShip;
    collisionMap["SpaceStation"] = &hitSpaceStation;
    collisionMap["Asteroid"] = &hitAsteroid;//error

    HitMap::iterator mapEntry = 
        collisionMap.find(typeid(wharWeWait).name())//typeid::name
        if(mapEntry == collision.end())
            return 0;
        return (*mapEntry).second;
}

//make init be smart ptr 
//虽然只是为了调用时初始化，但好像简便了许多
class SpaceShip : public GameObject{
private://!!
    static HitMap * initCollisionMap();
 };

SpaceShip::HitFCNPtr
SpaceShip::lookup(const GameObject& otherObject)
{
    static auto_ptr<HitMap>
        collisionMap(initCollisionMap() );
}
SpaceShip::HitMap * SpaceShip::initCollisionMap()
{
    HitMap* phm = new HitMap;
    (*phm)["SpaceShip"] = &hitSpaceShip;
    (*phm)["SpaceStation"] = &hitSpaceStation;
    (*phm)["Asteroid"] = &hitAsteroid;

    return phm;
}
//但上面的会出错，因为map的元素：函数指针的类型不一样
//因参数类型不一样。也不符合声明
SpaceShip::HitMap * SpaceShip::initCollisionMap()
{
    HitMap * phm = new HitMap;
    (*phm)["SpaceShip"] = 
        reinterpret_cast<HitFCNPtr>(&hitSpaceShip);
    (*phm)["SpaceStation"] = 
        reinterpret_cast<HitFCNPtr>(&hitSpaceStation);
    (*phm)["Asteroid"] = 
        reinterpret_cast<HitFCNPtr>(&hitAsteroid);

    return phm;
}
//图2
//所谓reinterpret_cast 能不用就不用，解决办法是

class SpaceShip : public GameObject{ 
public:
    virtual void collide(GameObject& otherObject) ;
    virtual void hitSpaceShip(GameObject& otherObject) ;
    virtual void hitSpaceStation(GameObject& otherObject) ;
    virtual void hitAsteroid(GameObject& otherObject) ;
    /*参数类型一致了*/
 };

/*夹带真是性，我觉得我这一步有些多余，但为了消除使用者困惑*/
void SpaceShip::hitSpaceShip(GameObject& spaceShip) 
{
    SpaceShip& otherShip
        = dynamic_cast<SpaceShip&>(spaceShip);
    process a SpaceShip-SpaceShip collision;
}
void SpaceShip::hitSpaceStation(GameObject& spaceStation){...}
void SpaceShip::hitAsteroid(GameObject& asteroid){...}

//use non_member fcn to process a collision fcn

#include "SpaceShip.h"
#include "spaceStation"
#include "Asteroid"

namespace{
    void shipAsteroid(GameObject& spaceShip,GameObject &asteroid);
    void shipStation(GameObject& spaceShip,GameObject &spaceStation);
    void StationAsteroid(GameObject& spaceStation,GameObject &asteroid);

    void Asteroidship(GameObject& asteroid,GameObject &spaceShip)
    {
        shipAsteroid(asteroid,spaceShip);//就是如果参数相反，就调用上面的函数
    }
    //...都一样


};