Funktionspointer auf Memberfunktionen sind grundsätzlich möglich, jedoch ist der Aufruf einer solchen Funktion anders. Ist es möglich, in einer queue von Funktionspointern (std::queue<void (*)(std::ifstream)>) sowohl Pointer auf normale Funktionen als auch Pointer auf Memberfunktionen zu speichern und aufzurufen?

es gibt im TR1 das Template function. Ist dies einfach "modernerer" Funktionspointer (d.h. kann diese ersetzen) oder etwas völlig anderes? Ist dieses template möglicherweise in Bezug auf meine erste Frage hilfreich?

Danke schon im Voraus!

mfg
mr x

So einfach geht das nicht.

Das habe ich mir schon gedacht...

Statische Memberfunktionen könntest du wahrscheinlich irgendwie umbiegen.

Die dürften kein Problem sein, da sie ja nicht auf ein bestimmtes Objekt der Klasse bezogen sind. Leider ist die Funktion bei mir nicht statisch.

Meine Frage zielte mehr darauf ab, ob es vielleicht Zeiger auf Memberfunktionen bezogen auf ein festgelegtes Objekt gibt.

#include <iostream>
#include <tr1/functional>

typedef std::tr1::function<void(int)> my_func_type; // dein funktionstyp

struct test
{
    void member_func(int v) { std::cout << "member_func: " << v <<  std::endl; }
};

void free_func(int v) { std::cout << "free_func: " << v << std::endl; }

int main()
{
    // zeiger auf member function
    test t;
    my_func_type func1 = std::tr1::bind(&test::member_func, t, std::tr1::placeholders::_1);

    // zeiger auf freie funktion
    my_func_type func2 = std::tr1::bind(&free_func, std::tr1::placeholders::_1);

    // aufruf funktioniert für beide gleich
    func1(23);
    func2(42);
}

Das funktioniert und hat zugleich meine Frage nach std::tr1::function geklärt

Was bedeutet "std::tr1::placeholders::_1"?

Ausführlichere Erklärungen findest du bei Boost.Bind.

// Erste Funktion
int f(int c) {
	return c * c;
}

// Zweite Funktion
double d(float f) {
	return f * f;
}

// Funktor
struct c {
	int operator ()(int d) {
		return d + d;
	}
};

// Ruft Fkt.-Ptr. auf
void aufruf(int (*fptr)(int)) {
	fptr(34);
}

// Ruft Template auf
template <typename T>
void aufruf2(T t) {
	t(54);
}

// Ruft tr1::function auf
void aufruf3(std::tr1::function<int (int)> fkt) {
	fkt(43);
}

aufruf(f); // Prima!
aufruf(c()); // oh-oh! c kann nicht in int (*)(int) konvertiert werden
aufruf(d); // oh-oh! double (*)(float) kann nicht in int (*)(int) konvertiert werden

// Optionaler Tpl-Parameter zur Veranschaulichung
aufruf2<int (int)>(f); // Prima!
aufruf2<c>(c()); // Prima!
aufruf2<double (float)>(d); // Prima!

// Prima! Mit Konvertierungen
aufruf3(f);
aufruf3(c());
aufruf3(d);