ich habe mehrere Funktionen, die identisch aufgebaut sind, sich jedoch im Rückgabetyp unterscheiden (sind in verschiedenen Dll hinterlegt, dies nur als Anmerkung).

int f1(int x); //in DLL1
	double f2(int x); //in DLL2

Ich würde jetzt gerne mit einem einzigen Funktionspointer arbeiten, den ich ,al auf die eine oder mal die andere Funktion zeigen lasse.

template<class T> T (*IrgendeineFunction)(int x);

geht leider nicht.

Mach ich was falsch? Welche Möglichkeiten habe ich?

Danke.

geht leider nicht.

Na dann ist ja alles klar.

Meinst du vielleicht sowas?

template<class T> T IrgendeineFunction(int x);

template<> int IrgendeineFunction(int x){
 return f1(x);
}

template<> double IrgendeineFunction(int x){
 return f2(x);
}

Mach ich was falsch?

Du versuchst das Unmögliche.

Welche Möglichkeiten habe ich?

Viele. Du kannst Dir zB für eine von den zwei Funktionen einen "Wrapper" bauen, damit Du hinterher dieselben Typen hast:

double f1d(int x) {return f1(x);}

:
:

double (*x)(int) = f1d;
double (*y)(int) = f2;

Automatische Wrapper, falls Parameter und Returnwert konvertierbar sind, sollten auch mit boost::function funktionieren -- da bin ich mir aber nicht 100%ig sicher im Moment.

Nein, ich will wirklich einen Funktionszeiger haben, der auf eine Funktion zeigt, die ich bis auf den mir unbekannten Rückgabetyp kenne.

Nicht getestet, aber dürfte klappen:

template<typename T> struct myfunctionpointer{
  static T (*function)(int x);
};

template<> int (*myfunctionpointer<int>::function)(int x)=f1;
template<> double (*myfunctionpointer<double>::function)(int x)=f2;

Nein, ich will wirklich einen Funktionszeiger haben, der auf eine Funktion zeigt, die ich bis auf den mir unbekannten Rückgabetyp kenne.

Was/Wie/Wo/Warum? Mehr Details bitte. Mehr Beispiele bitte. Du kannst natürlich einen Funktionszeiger vom Typ X* nicht auf eine Funktion vom Typ Y zeigen lassen, wenn X!=Y gilt. Wozu sollte man das auch machen können? So, wie Du Deine Frage formulierst ("Ich will einen Funktionszeiger, ... unbekannten Typ") gibt es klar nur eine Antwort: Geht nicht. Was passt Dir denn an senfers Antwort nicht? Wrapper-Funktionen klingen doch nach 'ner "guten" Idee. (gut in Anführungszeichen, weil sich das, ohne Dein Design zu kennen, schlecht bewerten lässt)

Wrapper deluxe:

#include "boost/any.hpp"

template<typename Ret, Ret (*Fun)(int)>
struct ladida
{
  static boost::any wrapper(int x) { return Fun(x); }
};

int    f1 (int);
double f2 (int);

int main() {
  boost::any (*zeiger)(int);
  zeiger = ladida<int,f1>::wrapper;
  zeiger(23);
  zeiger = ladida<double,f2>::wrapper;
  zeiger(42);
}

(ungetestet -- müsste vom Prinzip her gehen)

Gruß,
SP