Re: Multiple dispatch using templates - too good to be true?

Greetings,

I too have succumbed to the perhaps foolish urge to write a video
game, and I have been struggling with the implementation of multiple
dispatch. I read through "More Effective C++" by Scott Meyers, and
though I am impressed with his implementation, I wanted to find a way
to use multiple dispatch in a way that was less complicated.
Forgive me if the result, below, has been posted before or written of
before - I haven't read the "Purple Book" at all, so maybe it's all
been done before. What I'd like to know is what I'm missing - this
compiles on my machine, but am I doing something horribly wrong by
trying this? If I add a class later, like one out of a dynamically-
linked library, am I going to have to recompile everything? It just
seems to be too easy to be true.

//File: base_dispatch.h
#ifndef __BASEDISPATCH__
#define __BASEDISPATCH__

class BaseDispatcher
{
public:
virtual void Dispatch(void* A) = 0;
};
#endif

//File: dispatchany.cpp
#ifndef __DISPATCHANY__
#define __DISPATCHANY__

#include "base_dispatcher.h"

template<class T=BaseDispatcher, class U=BaseDispatcher>
class DispatchAny
{
public:
static void Dispatch(T* dispatcher, void* arg)
{
dispatcher->Dispatch(arg);
}

static void Dispatch(T* dispatcher, U* arg)
{
dispatcher->Dispatch(arg);
}
};

#endif

//File: testdispatchany.cpp
#include "dispatchany.cpp"
#include <iostream>

using std::cout;
using std::endl;

class Attack;
class Ability
{
public:
virtual void Dispatch(void* A) { cout<<"Dispatched to void in
ability"<<endl; }
virtual void Dispatch(Attack* a) { cout<<"Ability dispatches
attack"<<endl; }
};

class Attack
{
public:
virtual void Dispatch(void* A) { cout<<"Dispatched to void in
attack"<<endl; }
virtual void Dispatch(Ability* a) { cout<<"Attack dispatches
ability"<<endl; }
};

class Melee : public Attack
{
public:
virtual void Dispatch(void* A) { cout<<"Dispatched to void in
melee"<<endl; }
virtual void Dispatch(Ability* a) { cout<<"Melee dispatches
ability"<<endl; }
};

int main()
{
Ability* a = new Ability();
Attack* b = new Attack();

int* test = new int(5);

Melee* melee = new Melee();

DispatchAny<Ability, Attack> c;
DispatchAny<Attack,Ability> d;
DispatchAny<Melee,Ability> e;

c.Dispatch(a,b);
d.Dispatch(b,a);
e.Dispatch(melee,a);
d.Dispatch(melee,a);
c.Dispatch(a,a);
c.Dispatch(a,test);

delete a;
delete b;
delete melee;
delete test;

return 0;
}

I seek the wisdom of the opinions of those more experienced than I,
and I thank you for them.