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:: typedef中删除cbPtr，例如：

#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文件时，它看起来更像是这样：

A.H：

#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的多个实例将共享相同的变量，因此您将无法为不同的{具有单独的回调{1}}个对象。如果A不是memberFunc()，或者其static或a参数是用户定义的值，可以将其设置为指向aa对象的{ {1}}指针，然后你可以为每个对象单独回调。

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

1 个答案: