#include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>

struct obj
{
    void foo(int x) { std::cout << x << std::endl; }
};

void call(void (*func)())
{
    func();
}

typedef void (*func_t)();

int main(int, char**)
{
    obj x;
    boost::function<void ()> f = boost::bind(&obj::foo, boost::ref(x), 100);
    func_t g = *f.target<func_t>(); // Segmentation Fault
    call(g);

    return 0;
}

Warum bekomm ich da einen Segmentation Fault?!

Grüße,
Raz

Ach ja: Ubuntu 10.10, g++ 4.4.4, boost 1.43

Die Memberfunktion target() gibt einen Nullzeiger zurück, falls der angegebene Typ nicht mit dem internen übereinstimmt. Der interne Typ ist entweder der Funktionszeiger, mit dem das function -Objekt initialisiert wurde, oder die Adresse des Funktionsobjekts.

#include <iostream>
#include <boost/bind.hpp>
#include <boost/mem_fn.hpp>
#include <boost/function.hpp>

struct obj
{
    void foo(int x) { std::cout << x << std::endl; }
};

void call(void (*func)())
{
    func();
}

typedef void (*func_t)();

int main(int, char**)
{
    obj x;
    boost::function<void ()> f = boost::bind(boost::mem_fn(&obj::foo), boost::ref(x), 100);
    if(f.target<func_t>() == NULL)
        std::cout << "NULL" << std::endl;

    return 0;
}

Dann sag mir mal bitte, warum in dem Beispiel target NULL zurück gibt.

Ich habe doch geschrieben, wann target() einen Nullzeiger zurückgibt. Der Zeigertyp auf das von bind() erstellte Funktionsobjekt unterscheidet sich vom Typ des Funktionszeigers.

void (*)()

EDIT: Ah, dein edit gelesen.
Also müsste das theoretisch so funktionieren:

#include <iostream>
#include <boost/bind.hpp>
#include <boost/mem_fn.hpp>
#include <boost/function.hpp>

struct obj
{
    void foo(int x) { std::cout << x << std::endl; }
};

void call(void (*func)())
{
    func();
}

typedef void (*func_t)(int x);

int main(int, char**)
{
    obj x;
    obj nw = &boost::bind(boost::mem_fn(&obj::foo), boost::ref(x), 100);
    nw(); // Würde nw.foo(100) bewirken?

    return 0;
}

Aber ich bin eh auf dem Holzweg...

Okay, dann hab ich wohl bind noch nicht richtig verstanden?

bind() ist recht komplex. Es handelt sich um eine Überladung von sehr vielen Funktionstemplates (zumindest solange keine Variadic Templates aus C++0x unterstützt werden). Dass bind() derart mächtig ist, beruht auf der generischen Erzeugung von Funktionsobjekten. Funktionen hingegen kann man nicht einfach so zusammenbasteln.

Der Rückgabetyp von bind() ist implementation-defined, aber konvertierbar in ein function -Objekt mit einer passenden Signatur. Du wirst es nicht schaffen, einen Funktionszeiger zu erzeugen, der dieses Funktionsobjekt aufrufen kann.

Razoron schrieb:

Also müsste das theoretisch so funktionieren

Nein. Du darfst nicht die Adresse eines temporären Objekts nehmen, ausserdem sind Zeiger und obj inkompatible Typen und haben eigentlich nichts miteinander zu tun.

Ich rate dir, die Dokumentation zu function und bind ausführlich anzuschauen.

Ist das überhaupt möglich

Nein. Mit C++0x und Lambda-Ausdrücken könntest du das aber hinkriegen, da diese in Funktionszeiger konvertierbar sind (übrigens ein sehr nettes Feature :)).

Razoron schrieb:

oder muss ich die umständliche Variante nehmen

Nimmt dein Callback irgendwelche Parameter, z.B. void* ? Dann könntest du andere Argumente da hineinquetschen. Ansonsten wird es mühsam; ich sehe keine Möglichkeit, die ohne statische oder globale Variablen auskommt.

glutDisplayFunc nimmt void (*)() als Operator.