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

普通函数重载

#include<iostream>
using namespace std;
class SpaceShip;
class SpaceStation;
class Asteriod;
class GameObject
{
public:

};

class SpaceShip: public GameObject
{
public:
};

class SpaceStation: public GameObject
{
public:
};

class Asteriod: public GameObject
{
public:
};

void collide(GameObject &ob1,GameObject &ob2)
{
cout<<"GameObject &ob1=>GameObject &ob2"<<endl;
}

void collide(GameObject& ob1,SpaceShip& ob2)
{
cout<<"GameObject &ob1=>SpaceShip &ob2"<<endl;
}

void collide(SpaceStation& ob1,Asteriod& ob2)
{
cout<<"SpaceStation &ob1=>Asteriod &ob2"<<endl;
}

void collide(SpaceShip &ob1,SpaceStation &ob2)
{
cout<<"SpaceShip &ob1=>SpaceStation &ob2"<<endl;
}

void TestCollide(GameObject &ob1,GameObject &ob2)
{
collide(ob1,ob2);
}
int main()
{
SpaceShip sp;
SpaceStation ss;
TestCollide(sp,ss);//对象切片
cout<<"==============================="<<endl;
collide(sp,ss);//调用重载函数
getchar();
return 0;
}


结果：



条款31所述方法实现多态

#include<iostream>
using namespace std;
class SpaceShip;
class SpaceStation;
class Asteriod;
class GameObject
{
public:
virtual void collide(GameObject& otherObject) = 0;
virtual void collide(SpaceShip& otherObject) = 0;
virtual void collide(SpaceStation& otherObject) = 0;
virtual void collide(Asteriod& otherObject) = 0;
};

void GameObject::collide(GameObject& otherObject)
{
cout<<"Base::collide"<<endl;
}

class SpaceShip: public GameObject
{
public:
virtual void collide(GameObject& otherObject)
{
cout<<"SpaceShip::collide"<<endl;
otherObject.collide(*this);
}
virtual void collide(SpaceShip& otherObject)
{
cout<<"SpaceShip::collide(SpaceShip& otherObject)"<<endl;
}

virtual void collide(SpaceStation& otherObject)
{
cout<<"SpaceShip::collide(SpaceStation& otherObject)"<<endl;
}
virtual void collide(Asteriod& otherObject)
{
cout<<"SpaceShip::collide(Asteriod& otherObject)"<<endl;
}
};

class SpaceStation: public GameObject
{
public:
virtual void collide(GameObject& otherObject)
{
cout<<"SpaceStation::collide"<<endl;
otherObject.collide(*this);
}
virtual void collide(SpaceShip& otherObject)
{
cout<<"SpaceStation::collide(SpaceShip& otherObject)"<<endl;
}

virtual void collide(SpaceStation& otherObject)
{
cout<<"SpaceStation::collide(SpaceStation& otherObject)"<<endl;
}
virtual void collide(Asteriod& otherObject)
{
cout<<"SpaceStation::collide(Asteriod& otherObject)"<<endl;
}
};

class Asteriod: public GameObject
{
public:
virtual void collide(GameObject& otherObject)
{
cout<<"Asteriod::collide"<<endl;
otherObject.collide(*this);
}
virtual void collide(SpaceShip& otherObject)
{
cout<<"Asteriod::collide(SpaceShip& otherObject)"<<endl;
}

virtual void collide(SpaceStation& otherObject)
{
cout<<"Asteriod::collide(SpaceStation& otherObject)"<<endl;
}
virtual void collide(Asteriod& otherObject)
{
cout<<"Asteriod::collide(Asteriod& otherObject)"<<endl;
}
};

void TestCollide(GameObject &ob1,GameObject &ob2)
{
ob1.collide(ob2);
}

int main()
{
SpaceShip oShip;
SpaceStation oStation;
Asteriod oAst;
GameObject& g1=oShip;
GameObject& g2=oStation;
GameObject& g3=oAst;
TestCollide(g1,g1);
cout<<"==============================="<<endl;
TestCollide(g1,g2);
cout<<"==============================="<<endl;
TestCollide(g1,g3);
cout<<"==============================="<<endl;
TestCollide(g2,g3);
getchar();
return 0;
}


结果：