在構造函數中初始化靜態函數指針

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指針，則可以爲每個對象分別設置一次回調。