在构造函数中初始化静态函数指针

Question

我想声明一个类成员函数指针，因为它可以被静态成员函数调用，并将指针指派给传递给构造函数的函数。

到目前为止，我还没有能够得到它的工作，这是否有可能？

#include <stdio.h> 

//external callback function 
static void innerFunc(int i, float f){ 
    printf("running inner function : %i %f\n", i, f); 
} 

class A{ 
// member function pointer 
typedef void (A::*cbPtr)(int, float); 
static cbPtr cbptr; 

public: 

//constructor 
A(void(*func)(int, float)) 
{ 
    A::cbptr = func; // < this doesn't work 
} 

void run() 
{  
    memberFunc(5, 4.4, NULL, NULL);  
} 

private: 
// static member function 
static void memberFunc(int i, float f, void* a, const void* aa) 
{ 
    printf("running outer function.\n"); 
    // cbptr(i, f); // << I want to be able to call the function here 

} 

}; 

int main() { 

    A a(innerFunc); 
    a.run(); 
    return 0; 
} 

Answer 1

的A::cbPtr类型期望的指针A类的非静态成员函数。但是，您正试图将一个指向非成员函数的指针指定给您的静态变量cbptr。它们是两种不同的类型，这就是代码不能编译的原因。

降A::从cbPtr的typedef，例如：

#include <stdio.h> 

//external callback function 
static void innerFunc(int i, float f) 
{ 
    printf("running inner function : %i %f\n", i, f); 
} 

class A 
{ 
public: 
    // non-member function pointer 
    typedef void (*cbPtr)(int, float); 

    //constructor 
    A(cbPtr func) 
    { 
     m_cbptr = func; 
    } 

    void run() 
    {  
     memberFunc(5, 4.4, NULL, NULL);  
    } 

private: 
    static cbPtr m_cbptr; 

    // static member function 
    static void memberFunc(int i, float f, void* a, const void* aa) 
    { 
     printf("running outer function.\n"); 
     m_cbptr(i, f); 
    } 
}; 

A::cbPtr A::m_cbptr = NULL; 

int main() 
{ 
    A a(innerFunc); 
    a.run(); 
    return 0; 
} 

当你学会如何在声明和定义分成.h和.cpp文件，它看起来更像是这个：

啊：

#ifndef A_H 
#define A_H 

class A 
{ 
public: 
    // non-member function pointer 
    typedef void (*cbPtr)(int, float); 

    //constructor 
    A(cbPtr func); 

    void run(); 

private: 
    static cbPtr m_cbptr; 

    // static member function 
    static void memberFunc(int i, float f, void* a, const void* aa); 
}; 

#endif 

A.cpp：

#include "A.h" 
#include <stdio.h> 

A::cbPtr A::m_cbptr = NULL; 

A::A(A::cbPtr func) 
{ 
    m_cbptr = func; 
} 

void A::run() 
{  
    memberFunc(5, 4.4, NULL, NULL);  
} 

void A::memberFunc(int i, float f, void* a, const void* aa) 
{ 
    printf("running outer function.\n"); 
    m_cbptr(i, f); 
} 

main.cpp中：

#include "A.h" 
#include <stdio.h> 

//external callback function 
static void innerFunc(int i, float f) 
{ 
    printf("running inner function : %i %f\n", i, f); 
} 

int main() 
{ 
    A a(innerFunc); 
    a.run(); 
    return 0; 
} 

无论哪种方式，只知道因为m_cbptr是static的A多个实例将共享相同的变量，所以你将不能够有独立的回调不同的A对象。如果memberFunc()不是static，或者其a或aa参数是一个用户定义的值，可以将其设置为指向A对象的this指针，则可以为每个对象分别设置一次回调。