Mein Aliegen ist eine Klasse zu schreiben die ich ähnlich wie delegaten in .NET benutzen kann.
Also eine Klasse die ich in einer Klasse A erstellen kann und der ich in Klasse B eine (Member-)Funktion zuweisen kann, die bei einem Ereignis in A ausgeführt werden soll. (z.B. vie Funktion meiner event-Klasse: EventHandler.exec(); )

Geplant hatte ich das mit einem array von Pointern auf Funktionen zu realisieren.
zuerst hatte ich gedacht das wäre mit einer einfachen Variablen Parameterliste
(z.B. void func(char* Arg,...) ) hab dann aber schnell gemerkt, dass es das nicht ist was ich will da ich ja die Argumente die über den char* kommen auswerten muss.
Weiter gings mit einer typelist mit der ich beim instanzieren meiner Klasse die Funktions-Parameterliste darauf abgestimmt generiere. Da war von vorn herein das Problem, dass ich zwar schon länger Programmiere aber erst vor kurzem zu C++ kam und auch in der Meta-Programmierung noch einige unerforrschte gefilde liegen.

Viel Text... mit folgenden Antworten wäre ich zufrieden:
- Ja richtiger ansatz, aber [...]
- Nein völlig falsch, besser [...]
- hör lieber auf und beschäftige dich mit was anderem weil [...]

Dürfen aber auch anders geartet sein vielen Dank schon mal.

Damit hat sich auch wahrscheinlich die Frage erübrigt, ob dass nicht auch für beliebig viele parameter geht.

Aber da ich es noch nicht wirklich verstanden habe was die genau da treiben und ich nichts gerne benutz von dem ich nicht genau weiß wie es geht mach ich mich jetzt auch daran es so gut es geht zu verstehen.
Wer meint er weiß es und will darüberhinaus auch noch mir dabei helfen dem sag ich nicht nein

€:
ich war wohl zu vorschnell:
Ich will ja nicht nur diesen Pointer auf die Funktion, sondern ich will eine Klasse die mehrere solcher Pointer besitzt und auf wunsch dann ausführt.
So weit ich das jetzt geplant habe gebe ich meiner Klasse, die die Funktionspointer sammelt, beim instanzieren eine typelist mit.

Ich kann zwar die Länge und die Typen der typelist auslesen, bei der Deklaration des arrays seh ich allerdings noch das Problem, dass die länge der typelist, die ich übergebe variieren kann.

Beispiel:
Setze ich das maximum der Parameter für meine funktionen auf 5 übergebe dann aber nur eine typelist mit 3 Werten wirft die typelist einen error beim 4 parameter, dass dieser nicht vorhanden sei.
Dummy-Parameter will ich aber nicht übergeben.

So sieht die typelist aus falls das nötig ist

#pragma once

struct Nil {};

// default Typelist
template < typename H = Nil, typename T=Nil >
struct TypeList;

template < typename H, typename T >
struct TypeList {
	typedef H	Head;
	typedef T	Tail;
};

// returns number of Elements in the TypeList
template < class List >
struct size {
	enum { result = 1 + size< typename List::Tail >::result };
};
template <>
struct size<Nil> {
	enum { result = 0 };
};

// returns the Type-Element with the passed index
template < 
	class List, 
	int index, 
	int step = 0, 
	bool stop = ( index==step ), 
	bool OutOfRange = ( size< typename List >::result == 0 ) 
>
struct get {
	typedef typename get< List, step+1 >::result result;
};
// OutOfRange-Exeption of get
template < 
	class List, 
	int index, 
	int step, 
	bool stop
>
struct get < List, index, step, stop, true > {};
// Element found of get
template < 
	class List, 
	int index, 
	int step, 
	bool OutOfRange
>
struct get < List, index, step, true, OutOfRange > {
	typedef typename List::Head result;
};

class A
{
    int x;
    eventklasse e;
    ...
    A() { e = new eventklasse(/* Übergabe von welcher "Art" der event sein soll */) }
    ...
    void mach_was(){
        x--;
        e.execute();
    }
}

class B
{
    ...
    B(A& a) {
        a.e.neuerevent(&B::reagiere_auf_A)
    }
    ...
    void reagiere_auf_A() {
        cout << "A hat was getan" << endl;
    }
}

class eventklasse // "Art" der Funktionen muss angeben 
{                 // ich dachte daran Return-Typ und Parameter via typelist zu übergeben

    // datentyp indem ich Pointer auf Funktionen oder so etwas ähnliches speichern kann
    ...
    neuerevent(/* Pointer auf eine Funktion von gleicher "Art" wie der obige Datentyp */) {
    ...}
    execute() {
        // alle Gespeicherten Funktionen ausführen
    }
}

vllt ist jetzt mein problem klarer dargelegt...es geht nicht darum die Pointer oder was auch immer zu erstellen.
Auch bei boost::function muss ich doch die typnamen angeben. und gerade die sind in meiner typelist welche durchaus unterschiedliche Längen aufweisen kann.
will ich in meiner eventklasse aber ein array von boost::function erstellen muss ich direkt mit angeben mit welchen Parametern die Funktion ausgerüstet werden soll. Ich kann doch nicht einfach boost::function<...> aufrufen wenn ich gar nicht weiß ob alle parameter die ich übergebe in der typelist stecken, die könnte ja mal mehr mal weniger Elemente besitzen.

Oder habe ich etwas grundsätzliches an boost::function nicht verstanden und das was ich will lässt sich auch damit bewerkstalligen?

Du willst ja auf verschiedene Arten von Events reagieren, wie z.B MouseEvent oder KeyBoardEvent . Und da willst du jetzt eine Reihe von Funktionen, welche aufgerufen werden, wenn sein solches Ereigniss passiert. Spätestens beim Aufruf der Funktion musst du aber deren Signatur wissen (naja zumindest die obligatorischen Parameter). Also muss jede Funktion, welche sich für ein Event registiert die gleiche Schnittstelle anbieten, damit überhaupt ein generelles aufrufen passieren kann. Also folgt daraus, dass jeder Event seine eigene Liste mit Funktionen hat, wo du weiss, was es für eine Signatur hat.

(pseudecode, habe auch C++0x - for Variante benutzt)

class MouseEvent
{
  typedef boost::function<void(int x, int y)> function_type;
  public:
    void register (function_type f){ functions.push_back ( f ); }
    void notify () const { for(function_type f: functions_) f (0,0/*x und y position*/); }

  private:
    std::list<function_type> functions_;
};

class KeyboardEvent
{
 typedef boost::function<void(int key)> function_type;

 public:
   void register (function_type f){ functions.push_back ( f ); }
   void notify () const { for(function_type f: functions_) f (0/*key_type*/); }

 private:
   std::list<function_type> functions_;
};

So in etwa stelle ich mir das vor. Vielleicht verstehe ich dich aber auch nur falsch. Kannst ja mal sagen, was du hier noch anderst haben willst.

Das hats im Kern getroffen. Was ich daran ändern würde/wollte, ist dass ich den funktions-Typ auch von außen bzw beim instanzieren der Klasse bestimmen kann, so dass ich das Ganze etwas allgemeiner aufsetzen kann... aber das bekomm ich vllt auch alleine hin bekommen.

Ich wundere mich immer wieder wie einfach doch die Lösung sein kann...
(immerhin hab ich jetzt Unmengen an template/Meta-Programmierungs Literatur intus was ja auch nicht schaden kann )

Vielen Dank

Ich denke, dass man das da auch noch wirklich so weiterspinnen kann, dass man am Ende so, wie du das willst eine Typliste angeben kannst und dann sozusagen dein neues Event hast und der Compiler dir dann die Klassen erzeugt, aber das überlasse ich jetzt mal dir, wenn du magst.

die Methode notify hätte ich gerne mit der selben Parameter Liste wie die, die ich per typedef erstellt habe.

ich will das in elegant:

template < typename ft >
class EventX
{
  typedef ft function_type;

  public:
	void add (function_type f){ functions_.push_back ( f ); }

	void notify () const { 
		for(int i=functions_.size()-1; i>-1; --i) 
			functions_[i] (); 
	}
	template < typename T1 >
	void notify ( T1 p1) const { 
		for(int i=functions_.size()-1; i>-1; --i) 
			functions_[i] ( p1 ); 
	}
	template < typename T1, typename T2 >
	void notify ( T1 p1, T2 p2) const { 
		for(int i=functions_.size()-1; i>-1; --i) 
			functions_[i] ( p1, p2 ); 
	}

        // usw. 
        // ob es nicht irgendwie besser geht, dass notify die selbe Parameterliste bekommt, wie sie in funktion_type vorhanden ist

  private:
    std::vector<function_type> functions_;

};

Was du versuchen könntest ist so eine Art Tuple zu erstellen. Dann hättest du zwar immer lediglich einen Parameter, aber da es ein Tuple wäre beliebig viele Parameter haben kann. Obwohl ich denke, dass auch das recht hässlich wird..

btw:
In Eiffel, fällt mir ein, kann das so sehr gut gehandhabt werden, da es eine recht gute Tuple Unterstützung gibt.
Hier ab ca. Seite 30:
http://se.inf.ethz.ch/teaching/2009-H/eprog-0001/slides/17_agents.pdf

Hilft dir jetzt direkt wahrscheinlich nicht sehr viel, aber wenn du das wirklich implementieren willst, kannst du da sehen, wie die Handhabung in etwa geschen sollte, damit das ganze dann auch funktioniert.