c ++类方法指针作为函数参数

Question

I am trying to create a dynamic function pointer that points to some methods all the methods I want to save on the array return a bool and have an uint32_t parameter. The functions are Service functions. These are intended to be dynamic, so when a class is started, the constructor links the service function from the object to be called from outside the object.

With the code below I am getting the following error: Build error: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.

I have no clue what to do to overcome this problem, any idea would be greatly appreciated, thanks!

//File 1

    typedef bool (*ServiceFunctionsType)(uint32_t);

//File 2

#include "File1.hpp"

extern uint8_t ServiceFunctions_size;
extern ServiceFunctionsType *ServiceFunctions;

void Service_Functions_Setup();

bool SetPtr(ServiceFunctionsType a);
void ClearPtr(uint8_t id);

//File 3

#include "File1.hpp"
ServiceFunctionsType *ServiceFunctions;
uint8_t ServiceFunctions_size = 0;

//File 4
#include "File2.hpp"
#include <stdlib.h>

void Service_Functions_Setup()
{
    ServiceFunctions = NULL;
    if(SERVICE_FUNCTION_POINTER_START_SIZE != 0)
    {
        ServiceFunctions_size = SERVICE_FUNCTION_POINTER_START_SIZE;
        ServiceFunctions = (ServiceFunctionsType*)malloc(sizeof(ServiceFunctionsType)*SERVICE_FUNCTION_POINTER_START_SIZE);
        for(uint8_t i = 0; i < SERVICE_FUNCTION_POINTER_START_SIZE; i++)
        {
            ServiceFunctions[i] = NULL;
        }
    }
}

uint8_t SetServiceFunctionPointer(ServiceFunctionsType a, bool _realloc)
{
    if( ServiceFunctions == NULL )
    {
        ServiceFunctions = (ServiceFunctionsType*)malloc(sizeof(ServiceFunctionsType));
        ServiceFunctions[0] = a;
        return 0;
    }

    for(uint8_t i = 0; i < ServiceFunctions_size; i++)
    {
        if( ServiceFunctions[i] == NULL )
        {
            ServiceFunctions[i] = a;
            return i;
        }
    }

    if(_realloc)
    {
        ServiceFunctions_size++;
        ServiceFunctions = (ServiceFunctionsType*)realloc(ServiceFunctions,sizeof(ServiceFunctionsType)*ServiceFunctions_size);
        ServiceFunctions[ServiceFunctions_size - 1] = a;
        return ServiceFunctions_size - 1;
    }

    return INVALID_SERVICE_FUNCTION_POINTER;
}

void ClearServiceFunctionPointer(uint8_t id)
{
    ServiceFunctions[id] = NULL;
}

//File 5


class MonoStepSequencer
{
    public:
        MonoStepSequencer();
        ~MonoStepSequencer();

        uint8_t ServicePointerID;
        bool Service(uint32_t time);

    private:
};    

//File 6

#include "File2.hpp"


MonoStepSequencer::MonoStepSequencer()
{
    ServicePointerID = SetServiceFunctionPointer(&this -> Service);
}

//This is the function to be called with a pointer
bool MonoStepSequencer::Service(uint32_t time)
{
    //Some Code
}

Answer 1

this -> Service is an unqualified or parenthesized non-static member function

You probably meant :: instead of -> Also, you need a type on the left, not a variable.

Also, please don't put spaces around -> . That makes it look like you're specifying a trailing return type or something.

Answer 2

You can try, to use lambdas. Create method like

 std::function<void()> getService()

Where inside you can use:

return [this](){
    Service();
};

Also if your methods should use arguments, you can use this method, but add arguments into return value and lambda. One more, you can create lambda outside of class methods, like:

[&object]()
{
    object.Service();
}

In this way, better to use std::shared_ptr to guаrantee that object exists, when lambda called.