template < typename TEvent >
void handleEvent (TEvent& event);

Diese Funktion muss von den erbenden Klassen natürlich auf irgendeine Weise implementiert werden.
Da ich aber eine Templatefunktion nicht als virtuell deklarieren kann und auch die Funktion nicht in den abgeleiteten Klassen spezialisieren kann, muss eine andere Lösung her.
Natürlich könnte ich auch einfach ein Interface für die Events nehmen und einen Basisklassenzeiger an "handleEvent" übergeben. Das ist aber nicht Sinn der Sache. Mich interessiert ob es auch eine andere Möglichkeit gibt etwas in der Art und Weise zu implementieren.

Danke schon einmal im Voraus !

EDIT : Vielleicht sollte ich noch erwähnen, dass die Basisklasse des Beobachters eine zur Kompilierzeit bekannte Liste von denjenigen Events hat, auf die er reagieren soll.

template < typename... TTypes >
class Typelist;

template < typename TEventlist >
class ObserverInterface
{
    public:
        using Eventlist = TEventlist; // e.g Typelist<EventOne, EventTwo, EventThree>
}

template < typename... TTypes >
class TypeList;

namespace impl
{
	template < template<typename...> typename List, typename T >
	struct RenameImpl;

	template < template<typename...> typename List, template<typename...> typename T, typename... Ts >
	struct RenameImpl<List, T<Ts...>>
	{
		using Type = List<Ts...>;
	};
} 

template < template<typename...> typename List, typename T >
using RenameType = typename impl::RenameImpl<List, T>::Type;

template < typename TEventList >
class EventDispatcher
{
public:
	template < typename TEvent >
	void operator()(TEvent& event)
	{
		std::get<std::function<void(TEvent&)>>(dispatchTable_)(event);
	}

	template < typename TEvent, typename TFunction >
	void addDispatch(TFunction&& function)
	{
		std::get<std::function<void(TEvent&)>>(dispatchTable_) = std::forward<TFunction>(function);
	}
private:
	template < typename... TEventList >
	using DispatchTable = std::tuple<std::function<void(TEventList&)>...>;

	RenameType<DispatchTable, TEventList> dispatchTable_;
};

struct EventOne{};
struct EventTwo{};
struct EventThree{};

using EventList = TypeList<EventOne, EventTwo, EventThree>;

int main()
{
	EventDispatcher<EventList> ed;

	ed.addDispatch<EventOne>([](EventOne event) { std::cout << "EventOne!\n"; });
	ed.addDispatch<EventTwo>([](EventTwo event) { std::cout << "EventTwo!\n"; });
	ed.addDispatch<EventThree>([](EventThree event) { std::cout << "EventThree!\n"; });

	EventTwo two;

	ed(two);

	std::getchar();

	return 0;
}

[OUTPUT] EventTwo!