passing function as argument in c++

Question

I am trying pass the function as an argument, the Testabc is inherited from MainTest and the function I want to pass is protected function in MainTest class. I do not have the cpp access to the MainTest class which has this protected ReadTestPoint function.

Below is header file where I define the function that is taking the function as an argument.

#include <QObject>
#include <QDebug>

class TestManager
{
 public:
 TestManager();
~TestManager() {}
int ReadTestPointer(void *dp, unsigned int &val, int (*functioncall)(void *, 
unsigned int&));
};

Below is the cpp for the TestManager

#include "testmanager.h"
#include<QDebug>
TestManager::TestManager(){}

int TestManager::ReadTestPointer(void* dp, unsigned int &num, int (*readt)
(void*, unsigned int&))
{
   qDebug()<< "Function Pointer working";
   int g;
   g = (*readt)(dp, num);
   return g;
}

The class from where I am making the call:

 namespace PackageCore
 {

 TestAbc::TestAbc() : MainTest(){}
 TestAbc::~TestAbc(){}

 int TestAbc::Init()
 {
  // initialization code called once
   m_config = reinterpret_cast<Test_BaseClass*>
   (GetConfig(Test_BaseClass_INTERFACE_HASH));
  return 0;
}
int TestAbc::DeInit()
{
   return 0;
}

int TestAbc::Cycle()
{
   TestManager m_TestManager;
   unsigned int m_trigger;
   int (*abc)(void *, unsigned int&) = ReadTestPoint(m_config-
    >SHM_B_Trigger_U8, m_trigger);
   m_TestManager.ReadTestPointer(m_config->SHM_B_Trigger_U8, m_trigger, abc);
   qDebug()<< " getTrigger: " << m_trigger;
   return 0;
}
}

But I get the compile time error on this:

C:\test_manager_git\testabc.cpp:39: error: invalid conversion from 'int' to 'int (*)(void*, unsigned int&)' [-fpermissive]
 int (*abc)(void *, unsigned int&) = ReadTestPoint(m_config->SHM_B_Trigger_U8, m_trigger);
                                                                                            The MainTest.h is below:
   class MainTest : public QObject
  {
   Q_OBJECT

   public:

    // Callbacks
    virtual int Init() = 0;
    virtual int Cycle() = 0;
    virtual int DeInit() = 0;

   protected:


     int ReadTestPoint (void *dp, unsigned int &val);


 };

Thanks

Answer 1

First of all, consider using things like std::function instead of rolling your own pointer nightmare. But lets get started...

Basically, in order to call a member function from pointer, you need the function pointer and a member instance. The following code is based on your question code with the added member pointer.

#include <iostream>


class MainTest
{
public:

protected:
    int ReadTestPoint (void *dp, unsigned int &val)
    {
        std::cout << "protected ReadTestPoint called" << std::endl;
        return 0;
    }
};



class TestManager
{
public:
    TestManager() {}
    ~TestManager() {}
    int ReadTestPointer(void *dp, unsigned int &val, MainTest* instance, int (MainTest::*functioncall)(void *, unsigned int&))
    {
        return (instance->*functioncall)(dp, val);
    }
};


class TestAbc : public MainTest
{
public:
    void ExecTest()
    {
        TestManager testManager;
        unsigned int tVal;
        void* dummy = &tVal;

        testManager.ReadTestPointer(dummy, tVal, this, &TestAbc::ReadTestPoint);
    }
};


int main(void)
{
    TestAbc test;
    test.ExecTest();

    return 0;
}

If you don't want to restrict yourself to a specific member type, consider using a template function:

class TestManager
{
public:
    TestManager() {}
    ~TestManager() {}

    template<typename Fn>
    int ReadTestPointer(void *dp, unsigned int &val, Fn functioncall)
    {
        return functioncall(dp, val);
    }
};

It will accept non-member functions and objects that overload the operator() with appropriate parameters and return types.

You can wrap the member function pointer in a Functor object:

template<typename TMember, typename TResult, typename TParam1, typename TParam2>
struct Functor
{
    typedef TResult (TMember::*TFn)(TParam1, TParam2);

    Functor(TMember* m, TFn func):member(m), fn(func){}

    TMember* member;
    TFn fn;

    TResult operator()(TParam1 p1, TParam2 p2)
    {
        return (member->*fn)(p1, p2);
    }
};

The following example includes a free function call and a member function call:

int FreeFn(void *dp, unsigned int &val)
{
    std::cout << "free function called" << std::endl;
    return 1;
}


class TestAbc : public MainTest
{
public:
    void ExecTest()
    {
        TestManager testManager;
        unsigned int tVal;
        void* dummy = &tVal;

        testManager.ReadTestPointer(dummy, tVal, Functor<TestAbc, int, void*, unsigned int&>(this, &TestAbc::ReadTestPoint));

        testManager.ReadTestPointer(dummy, tVal, FreeFn);
    }
};