Question

我有一个需要回调函数的C库。

void func( int *a, double *b, double *c, double *d )

a，b，c输入，而＆＃39; d＆＃39;是输出。我的班级看起来像：

class Test{
public:
    Test()
    {
        a   = 2;               
        ip  = new int[128];     
        kd  = new int[a];   
        c   = new double[a];
        dp  = new double[26];
        ja  = NULL;         
        h   = 1.0e-7;       
        hm  = 1.0e-14;  
        ep  = 1.0e-8;   
        tr  = 1.0e-3;   

        for (int i = 0; i < 128; ++i)
            ip[i] = 0;

        b     = 0.0;
        t_e   = 160.e0;

        c[0]    = 2.e0;
        c[1]    = 0.e0;
    }

    void my_func( int *a, double *b, double *c, double *d ) {
       d[0] = some_value;
       d[1] = some_other_value;
    }

    operator()() 
    {
        auto member_func = std::bind( &Test::my_func, *this, _1, _2, _3, _4 );
        external_function( ip, &a, &b, &t_e, c, &member_func, ja, &h, &hm, &ep, &tr, dp, kd, &ie );
    }

private: 
    int *ip, *kd;
    int a, ie;
    double b, t_e;
    double *c, *dp;
    double h, hm, ep, tr;
    void *ja;
};

它编译得很好，但在运行时，它会给出＆＃34;分段错误（核心转储）＆＃34;。我不知道为什么会这样。

不使用成员函数（my_func），即，如果我声明，定义并使用＆＃34; func＆＃34;直接在全局范围内，它工作正常并产生正确的结果。

问题是，我不能同时并行运行Test的几个实例，因为它们都需要修改和使用类数据成员。不幸的是，＆＃34; func＆＃34;没有任何争论，例如，（void * data）允许强制转换为＆＃39;测试＆＃39;。

我可以帮忙吗？非常感谢。

Answer 1

因为my_func是一个成员函数，它对C函数有一个不同的调用约定，它容纳了一个隐藏的this指针。如果要在类中包含C的回调，请将其声明为static extern "C"。

您确定在编译单元中可以看到external_function(...)的正确原型吗？

一些例子：

extern "C" int f1(char(*)(void*,int,int), void* ctx);
extern "C" int f2(char(*)(int,int));
static callbacks* global; // Maybe thread local for thread safety...

extern "C" char cb1_helper(void* ctx, int a, int b) {
    return ((callbacks*)ctx)->cb(a, b);
}
extern "C" char cb2_helper(int a, int b) {
    return global->cb(a, b);
}
class callbacks {
    char cb(int, int) {}
}

int main() {
    callbacks A();
    f1(cb1_helper, &A);
    global = &A;
    f2(cb2_helper);
    return 0;
}

Answer 2

std :: bind对你没有帮助，因为你需要一个上下文来调用类方法。如果回调从其参数中获取某些上下文，则可以使用自由函数或静态方法作为回调：

typedef void (*Callback)(void* context, int arg1);

class A {
public:
    void method(int arg1);

private:
    static void callback(void* context, int arg1)
    {
        A* a = getObjectFromContext(context);
        if (a)
            a->method(arg1);
    }
    // getObjectFromContext may be implemented different ways
    // simpliest case, just cast to A*
    static A* getObjectFromContext(void* context)
    {
        return reinterpret_cast<A*>(context);
    }
};

Answer 3

这适用于单个线程和多个线程：

// C function
void func( int *a, double *b, double *c, double *d );

// Forward declaration of Test class
class Test;

// Thread local for thread safety
thread_local Test *p_global;

class Test{
public:
Test()
{
    a   = 2;               
    ip  = new int[128];     
    kd  = new int[a];   
    c   = new double[a];
    dp  = new double[26];
    ja  = NULL;         
    h   = 1.0e-7;       
    hm  = 1.0e-14;  
    ep  = 1.0e-8;   
    tr  = 1.0e-3;   

    for (int i = 0; i < 128; ++i)
        ip[i] = 0;

    b     = 0.0;
    t_e   = 160.e0;

    c[0]    = 2.e0;
    c[1]    = 0.e0;
}

void assign_this_pointer_to_global_and_dostuff()
{
    p_global = this;
    dostuff();
}

dostuff() 
{
    external_function( ip, &a, &b, &t_e, c, &func, ja, &h, &hm, &ep, &tr, dp, kd, &ie );
}

private: 
    int *ip, *kd;
    int a, ie;
    double b, t_e;
    double *c, *dp;
    double h, hm, ep, tr;
    void *ja;
};

// C function
void func( int *a, double *b, double *c, double *d ) {
   d[0] = some_value;
   d[1] = some_other_value;
}


int main()
{
    Test test;
    std::thread t1( &Test::assign_this_pointer_to_global_and_dostuff, &test );

    //Join the thread with the main thread
    t1.join();
}

使用C ++非静态成员函数的C回调函数的问题

3 个答案: