Call to non-static member function without an object argument ERROR AGAIN

Where is TRACE_Function defined? From your call to pRETC_TEST->TRACE_Function it should be a member of some class, and pRETC_TEST should point to an instantiated object of that class, as per my answer to your question in the C++ forum: Re: BUMP Re: Passing a class (pointer) to library - Linux - C / C++ / MFC Discussion Boards[^].

The error message you show suggests that pRETC_TEST is not a pointer to an object of the class that includes TRACE_Function as one of its non-static methods. However it is not really clear and detailed enough; you need to provide full details of the class, and the methods that you are trying to call.


[edit]
Here is a simple example of using a method pointer:

#include <iostream>

//
// QTextEdit is a class that contains a static function
// which outputs a message
class QTextEdit
{
public:
    QTextEdit() {}
    static void Debug(const char *debugText);
};

//
// the implementation of the Debug method
//
void QTextEdit::Debug(const char *debugText)
{
    std::cout << "Some debug information: ";
    std::cout << debugText << std::endl;
}

//
// this class contains a single function 
//
class REG_EXP_Test_Class
{
public:
    REG_EXP_Test_Class(){}
    void TRACE_Function(void(*method)(const char *msg), const char *parameter);
};

//
// the implementation of TRACE_Function takes a pointer to
// a method (which takes a single parameter, and returns nothing)
// and a pointer to a string. It then calls the delegated method
// passing the string, in order to print some information
//
void REG_EXP_Test_Class::TRACE_Function(void(*method)(const char *msg), const char *parameter)
{
    method(parameter);  // call the passed in method, via its pointer
}

int main()
{
    REG_EXP_Test_Class *pREG_EXP_Test_Class = new REG_EXP_Test_Class();
    // call the TRACE_Function passing it the delegate function
    // and the text to be printed.
    //
    // Note that Debug must be a static method in its class
    pREG_EXP_Test_Class->TRACE_Function(QTextEdit::Debug, "Hello World!");

    return 0;
}

Try replacing the call to pREG_EXP_Test_Class->TRACE_Function in main with the following:

QTextEdit* pTextEdit = new QTextEdit();
pREG_EXP_Test_Class->TRACE_Function(pTextEdit->Debug, "Hello World!");

Does it still work? Now try removing the word static from the declaration of QTextEdit's Debug method. Pay particular attention to the error messages that you now see.

[/edit]

Let me try again. Consider:

int foo(int n) { return 2 * n; }

void bar( int(fn)(int), int param )
{
   int x = fn(param);
   std::cout << x << std::endl;
}

That should be pretty clear. We have a function foo that returns an int, and a function bar that takes a pointer to a function, and a parameter. bar calls the fn with the passed in parameter and prints out the result. Simple, straight forward, right?
Now if we do this:

bar(foo, 2)

All is Good. The compiler is happy, code is generated, and when the generated program is run 4 will be printed to stdout when that statement is executed. Everybody's happy, we get to go home on time. Bonuses all round for the team. Yay!

However if we do this:

bar(foo(2), 2)

All is Not Good. The compiler is unhappy, no code is generated. No one is happy, we have to stay late and no bonuses are paid. Can you spot the difference? In the second instance, what is the type of the first argument? Hint: It's not a pointer to a function.

Read, think, reread as necessary. See if this can lead you to enlightenment.