Verschiedene Funktionszeiger in einem Array

Hallo Leute,

ich habe zwei funktionszeiger:

typedef void(A::*func1)(const double&);
typedef void(B::*func2)(bool);

Gibt es irgende eine Möglichkeit diese in einem Array zu speichern so dass:

array[0] = func1;
array[2] = func2;

Mit welchem Datentyp müsste das Array initialisiert werden?
Ich habe hier langen Code vorliegen der sich für die beiden wiederholt und ich möchte diese beiden Teile in einer Schleife ausführen lassen, damit die redundaten Codezeilen wegfallen.

Ist dies ohne dirty Code möglich?

Natürlich sollte das array so lauten

array[0] = func1;
array[1] = func2;

Nukularfüsiker

Das geht wohl nicht. Wie sieht denn der Code aus, der diese Funktionen dann aufrufen soll?

(Warum schreibt jemand eigentlich const double& , aber ist dann nicht so konsequent const bool& zu schreiben? Nicht, dass auch nur eins davon sinnvoll wäre imho.)

Athar

Scheint wenig Sinn zu machen. Wenn die beiden Funktionen unterschiedliche Parameter erwarten, wird der Aufruf ebenfalls anders aussehen und du brauchst so oder so eine Fallunterscheidung.
Im ersten Durchlauf rufst du die eine Funktion auf, im nächsten die andere, ganz einfach.
Oder vielleicht auch nicht, dann musst du aber Code zeigen.

Nukularfüsiker schrieb:

Das geht wohl nicht. Wie sieht denn der Code aus, der diese Funktionen dann aufrufen soll?

Ich habe attribute die ich abarbeiten möchte:

wxString attr1[] = {_("a"),_("b"),_("c")};
wxString attr2[] = {_("d"),_("e"),_("e")}; // zweites e=dummy wg. größe

Die dazugehörigen Funktionszeiger:

typedef void(A::*func1)(const double&);
func1 set_func1[] = {&A::a,&A::b,&A::c,};

typedef void(B::*func2)(bool);
func2 set_func2[] = {&B::d,&B::e,,&B::e}; // zweites &B::e=dummy wg. größe

Was ich vorhatte war ungefähr so:

attrib[0] = attr1;
attrib[1] = attr2;

func[0] = func1;
func[1] = func2;

for(i=0;i<2;i++){
  for(j=0;j<3;j++){
   val = node->GetPropVal(attrib[i][j]);
   // if !flag blabla
   (object.*func[i][j])(val);
}

Es wird wahrscheinlich nicht klappen weil ja object ja auch verschieden ist...
da komme ich wohl nicht um ein template.

Nukularfüsiker schrieb:

(Warum schreibt jemand eigentlich const double& , aber ist dann nicht so konsequent const bool& zu schreiben? Nicht, dass auch nur eins davon sinnvoll wäre imho.)

gibt es auch bei double keinen Geschwindigkeitszuwachs wenn man es als Referenz übergibt? Wo kann man eine Grenze ziehen? Am besten in size_t einheiten

Nukularfüsiker

Irgendwo muss ja entschieden werden, welche Funktion augerufen werden soll. Welchen Typ soll denn val in deinem Beispiel haben, und woher weiß GetPropVal , welchen Typ es liefern soll?

gibt es auch bei double keinen Geschwindigkeitszuwachs wenn man es als Referenz übergibt? Wo kann man eine Grenze ziehen? Am besten in size_t einheiten

Ich persönlich würde die Grenze bei zusammengesetzten Objekten ziehen. Fundamentale Typen immer als Wert übergeben, zusammengesetzte gegebenenfalls als Referenz, falls eine Kopie für den konkreten Fall nicht sinnvoller ist.

Wenn dein Programm mit mehreren Threads arbeitet, sind solche unnützen Referenzen doch eher kontraproduktiv und eine schwer zu findende Fehlerquelle. Performancegewinne halte ich für unwahrscheinlich, sie sind sogar eher ein potenzieller Bremsklotz, wenn man zum Beispiel Locks länger halten muss als wenn man den Wert einfach kopiert hätte.

Nukularfüsiker schrieb:

...

Habe es jetzt mit Templates gelöst. Danke für deine Hilfe.

drakon

Für so etwas würde ich dir sehr boost::function ans Herz legen. Die Bibliothek ist wirklich sehr angenehm zu gebrauchen, wenn man mit Funktionszeigern arbeiten möchte.

drakon schrieb:

Für so etwas würde ich dir sehr boost::function ans Herz legen. Die Bibliothek ist wirklich sehr angenehm zu gebrauchen, wenn man mit Funktionszeigern arbeiten möchte.

Danke für den Tipp. Dieses Boost muss ja wirklich die eierlegende Wollmilchsaubibliothek für C++ sein.

Naja, mit funktionszeigern möchte ich ja nicht unbedingt arbeiten... manchmal wird jedoch dadurch der code wesentlich übersichtlicher.