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?

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

(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.)

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

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.

...

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

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.