以下是我个人写的一段小程序，仅供娱乐，呵呵！

///////////////#Baseclass.h

class Baseclass

{

public:

virtual ~Baseclass()=0;

};

class directclass1:public Baseclass

{

public:

directclass1(int strongcount=0);



//private:

int strongcount;

};

class directclass2:public Baseclass

{

public:

directclass2(int strongcount=0);



//private:

int strongcount;

};

void direct2direct1(const Baseclass&,const Baseclass&);

void direct1direct2(const Baseclass&,const Baseclass&);

////////////////////////////#216.h

#include <map>

#include <string>

#include <iostream>

using namespace std;

namespace

{



typedef void (*Hitfunction)(const Baseclass&,const Baseclass&);

typedef map<pair<string,string>,Hitfunction>Hitmap;

static Hitmap* phf;



void makestringpair(const string&class1,const string&class2);

void Registerclassmap(const string& class1,

const string& class2,

Hitfunction,

bool istrueselect=true);

void AddEntryclass(const string&class1,

const string&class2,

Hitfunction);

void Moveclass(const string&class1,

const string&class2,

Hitfunction);

Hitfunction lookup(const string&class1,const string&class2);

void Bothcollision(const Baseclass&,const Baseclass&);

void releasesource();

}

////////////#216.cpp

#include "Baseclass.h"

#include "216.h"

static int counts=0;

directclass1::directclass1(int strongcount):strongcount(strongcount){}

directclass2::directclass2(int strongcount):strongcount(strongcount){}

void direct1direct2(const Baseclass&class11,const Baseclass&class22)

{

const directclass1& class1=dynamic_cast<const directclass1&>(class11);

const directclass2& class2=dynamic_cast<const directclass2&>(class22);

if(class1.strongcount>class2.strongcount)

{

cout<<"directclass2已被坠毁！"<<endl;

}

else if(class1.strongcount<class2.strongcount)

{

cout<<"directclass1已被坠毁！"<<endl;

}

else

cout<<"directclass1与directclass2同时被坠毁！"<<endl;

}

void direct2direct1(const Baseclass&class11,const Baseclass&class22)

{

const directclass2& class1=dynamic_cast<const directclass2&>(class11);

const directclass1& class2=dynamic_cast<const directclass1&>(class22);

direct1direct2(class2,class1);

}

Baseclass::~Baseclass(){}

namespace

{

void Registerclassmap(const string& class1,

const string& class2,

Hitfunction ptr,

bool istrueselect)

{

if(istrueselect)

AddEntryclass(class1,class2,ptr);

}

}

namespace

{

pair<string,string>makestringpair(const char*class1,const char*class2)//如果将char*改为string呢？

{

return pair<string,string>(class1,class2);

}

}

namespace

{

void AddEntryclass(const string&class1,

const string&class2,

Hitfunction ptr)

{

counts++;

if(counts==1)

phf=new Hitmap;

(*phf)[pair<string,string>(class1,class2)]=ptr;



}

}

namespace

{

Hitfunction lookup(const string&class1,const string&class2)

{

Hitmap*collisionmapptr=phf;

map<pair<string,string>,Hitfunction>::iterator ite=phf->find(make_pair(class1,class2));

if(ite==collisionmapptr->end())

return 0;

else

return (*ite).second;



}

}

namespace

{

void Bothcollision(const Baseclass&class1,const Baseclass&class2)

{ double a=0;

try

{

Hitfunction ptr1;

ptr1=lookup(typeid(class1).name(),typeid(class2).name());

if(ptr1)

(ptr1)(class1,class2);

else

throw a;

}

catch(double)

{

cout<<"不明物体撞击！"<<endl;

}

}

}

namespace

{

void Moveclass(const string&class1,

const string&class2,

Hitfunction)

{

map<pair<string,string>,Hitfunction>::iterator ite=phf->find(make_pair(class1,class2));

if(ite==(*phf).end())

cout<<"未找到要删除的元素！"<<endl;

else

(*phf).erase(ite);

}

}

namespace

{

void releasesource()

{

delete phf;

}

}

void main()

{

Registerclassmap("class directclass1","class directclass2",&direct1direct2);

Registerclassmap("class directclass2","class directclass1",&direct2direct1);

directclass1 class1;

directclass2 class2;

directclass1 class3(10);

directclass2 class4(30);

Bothcollision(class1,class2);

Bothcollision(class3,class4);

Moveclass("class directclass2","class directclass1",&direct2direct1);

Bothcollision(class4,class3);

releasesource();

}

/*namespace

{

typedef (*Hitfunction)(const Replacedclass<T>&,const Replacedclass<T>&);

typedef map<pair<string,string>,Hitfunction>Hitmap;

void Registerclassmap(const string& class1,

const string& class1,

Hitfunction,

bool istrueselect=true);

void AddEntryclass(const string&class1,

const string&class2,

Hitfunction);

Hitfunction lookup(const string&class1,const string&class1);

void Bothcollision(const Replacedclass<T>&,const Replacedclass<T>&);

}*/