Обратный вызов функции-члена класса C++

Это невозможно сделать - в С++ вы должны использовать либо свободную функцию, либо статическую функцию-член, либо (в С++ 11) лямбду без захвата, чтобы получить указатель на функцию.

GCC позволяет вам создавать вложенные функции, которые могут делать то, что вы хотите, но только на C. Для этого он использует так называемые трамплины (в основном небольшие фрагменты динамически сгенерированного кода). Можно было бы использовать эту функцию, но только если вы разделите часть кода, вызывающего externalFunction, в отдельный модуль C.

Другой возможностью может быть генерация кода во время выполнения, например. используя libjit.

Поэтому, если вас устраивает функция без повторного входа, создайте глобальную/статическую переменную, которая будет указывать на this, и используйте ее в своей статической функции.

class myClass
{
public:
    static myClass* callback_this;
    static void classUDF(double* a)
    {
        callback_this.realUDF(a);
    };
};

Это действительно ужасный код, но я боюсь, что вам не повезло с таким плохим дизайном, как ваш externalFunction.

Вы можете использовать привязку Boost или привязку TR1 (на последних компиляторах);;

<удар>

externalFunction(n, boost::bind(&myClass::classUDF, boost::ref(myClassObj)));

К сожалению, последние 10 минут я жил несбыточной мечтой. Единственный путь вперед — вызвать цель с помощью какой-либо статической функции-оболочки. В других ответах есть различные лакомые кусочки (для компилятора), но вот главный трюк:

void externalFunction(int n, void (*udf)(double*) )
{ double x; udf(&x); }

myClass myClassObj;
void wrapper(double* d) { myClassObj.classUDF(d); }

int main()
{
    externalFunction(1, &wrapper);
}

станд::функция‹>

Сохраните связанную функцию в переменной следующим образом:

std::function<void(double*)> stored = std::bind(&myClass::classUDF, boost::ref(myClassObj))

(при условии, что сейчас компилятор поддерживает C++0x. Я уверен, что Boost имеет boost::function‹> где-то)

Ванильные указатели C++ на функцию-член

Без такой магии вам понадобился бы синтаксис указатель на функцию-член:

Смотрите также прямую трансляцию на http://ideone.com/Ld7It.

Изменить, чтобы прояснить для комментаторов, очевидно, что это работает только если вы контролируете определение externalFunction. Это прямой ответ на фрагмент /broken/ в ОП.

struct myClass
{
    void classUDF(double* a) { };
};

void externalFunction(int n, void (myClass::*udf)(double*) )
{
    myClass myClassObj;
    double x;
    (myClassObj.*udf)(&x); 
}

int main()
{
    externalFunction(1, &myClass::classUDF);
}

Идиоматическое решение С++ 98

// mem_fun_ref example
#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
#include <string>

int main () 
{
    std::vector<std::string> numbers;

    // populate vector:
    numbers.push_back("one");
    numbers.push_back("two");
    numbers.push_back("three");
    numbers.push_back("four");
    numbers.push_back("five");

    std::vector <int> lengths (numbers.size());

    std::transform (numbers.begin(), numbers.end(), lengths.begin(), 
                std::mem_fun_ref(&std::string::length));

    for (int i=0; i<5; i++) {
        std::cout << numbers[i] << " has " << lengths[i] << " letters.\n";
    }
    return 0;
}

Вот как я это делаю, когда MyClass является синглтоном:

void externalFunction(int n, void udf(double) );

class MyClass
{
public:
   static MyClass* m_this;
   MyClass(){ m_this = this; }
   static void mycallback(double* x){ m_this->myrealcallback(x); }
   void myrealcallback(double* x);
}

int main()
{
   MyClass myClass;
   externalFunction(0, MyClass::mycallback);
}