C / C++ / MFC

Advanced Function Pointer?

6-Jan-03 11:16

Hi all,

Is it possible to declare a function pointer outside function arguments? I mean like declaring a pointer as a separate variable which isn’t an argument and can change the function it is pointing at, assuming that whatever function it points at always has the same arguments. Like this code for example. Please note that I know this following code doesn’t compile, I just want to explain my question in code, it’s always a lot easier.

<br />
void realfunc(void){ // declaring a normal function with no arguments<br />
      return;<br />
}<br />
<br />
int main(){<br />
      void (*funcptr)(void); // declaring "function pointer" with no arguments<br />
      *funcptr=realfunc; // "function pointer" pointing at a normal function with same argument settings<br />
      funcptr(); // calling the function that the "function pointer" is pointing at<br />
      return 0;<br />
}<br />

So is there something similar to this code? In other words is it possible to do something like this? Confused | :confused:

Aidman » over and out

Re: Function Pointer?

Stefan Pedersen6-Jan-03 11:35

Stefan Pedersen

6-Jan-03 11:35

Short answer: Yes

"You can stand all night at a redlight anywhere in town, hailing Marys left and right but none of them slow down. I've seen the best of men go past. I don't wanna be the last..."

Re: Function Pointer?

Chris Richardson6-Jan-03 11:38

Chris Richardson

6-Jan-03 11:38

Long answer: Yes, and you can use a typedef to make it simpler.

Try this sample code:

[edit]oops, forgot the darn formatting so the stdio.h got removed.[/edit]

#include <stdio.h>
typedef void (*PFN_YOURFUNCTION)(void);

void TestFunction1()
{
   printf( "TestFunction1\n" );
}

void TestFunction2()
{
   printf( "TestFunction2\n" );
}

int main()
{
   PFN_YOURFUNCTION a_pfnFunction = NULL;
   a_pfnFunction = TestFunction1; // Set it to TestFunction1
   a_pfnFunction(); // Call pointed at function.
   a_pfnFunction = TestFunction2; // Set it to TestFunction2
   a_pfnFunction(); // Call pointed at function.
   return 0;
}

The output will be:

TestFunction1
TestFunction2

Chris Richardson

Programmers find all sorts of ingenious ways to screw ourselves over. - Tim Smith

Aidman6-Jan-03 13:02

6-Jan-03 13:02

Great Thanks Chris Richardson! Smile | :)

I am sorry, I feel a little dumb not realizing that C++ must hade such a method.

But here’s another “function pointer” related question, which may be more advanced if that’s ok? Let’s say you have a function (in your own application) whose arguments are stored customable in variable arrays and the function name you don’t know. The only thing you have as a pointer of the function is a simple memory pointer/adress (no real function pointer) that points to a memory location where the function is stored during run-time. The following code example would demonstrate what I am trying to say.

<br />
// MEMPTR is a variable type pointing to a location in memory<br />
<br />
struct FUNCSTRUCT { // Function calling structure<br />
      MEMPTR *FunctPtr; // Function pointer<br />
      int VarCount; // Number of Variables<br />
      MEMPTR *VarPtr[255]; // Varaible pointers<br />
      int VarSize[255]; // Varaible byte sizes<br />
}<br />
<br />
MEMPTR CallFunc(FUNCSTRUCT *FunctData); // The powerful function that does the call<br />
<br />
int TheRealFunc(int Argument){ // Declare normal function<br />
      return Argument;<br />
}<br />
<br />
int main(){<br />
      FUNCSTRUCT FuncData; // Declare function type<br />
      int Value = 1; // Give a value to send as argument<br />
<br />
      FuncData.FunctPtr = TheRealFunc; // Point to normal function<br />
      FuncData.VarCount = 1; // Number of values to send as arguments<br />
      FuncData.VarPtr[0] = Value; // Point to the value<br />
      FuncData.VarSize[0] = 2; // Byte size of an integer value<br />
<br />
      return CallFunc(&FuncData); // Call the function<br />
}<br />

Is it possible to create such a function as “CallFunc” that could call a function, only knowing the custom arguments and a memory pointer/address? If so then how and how would the “MEMPTR” variable type look like? I presume that this question is a lot harder and I guess it includes some low-level knowledge. But is this possible and if it is then please explain how and demonstrate it in code please or could you point me to a tutorial on this. Confused | :confused:

valikac6-Jan-03 14:13

valikac

6-Jan-03 14:13

No.

main() must return an int. CallFunc return a MEMPTR object.

Kuphryn

Aidman6-Jan-03 21:37

6-Jan-03 21:37

Yes I know this code doesn't compile it is only to demonstrate my words in code. And fourther more the MEMPTR return is pointing to an int variable and that was part of my question, How would MEMPTR look like, meaning how would it be constructed and operate, to get the memory location.

Please help me anyone. Confused | :confused:

Aidman » over and out

Stefan Pedersen7-Jan-03 1:55

Stefan Pedersen

7-Jan-03 1:55

I guess you could handcraft then stack using assembler. I'm not that up to date
on calling conventions so you have to get the dirty details from someone else.

"You can stand all night at a redlight anywhere in town, hailing Marys left and right but none of them slow down. I've seen the best of men go past. I don't wanna be the last..."

Aidman7-Jan-03 3:28

7-Jan-03 3:28

Any ideas of where I could find some info on this type function pointer calls?

Stefan Pedersen7-Jan-03 3:34

Stefan Pedersen

7-Jan-03 3:34

You might want to check out
http://www.codeproject.com/cpp/calling_conventions_demystified.asp[^]

"You can stand all night at a redlight anywhere in town, hailing Marys left and right but none of them slow down. I've seen the best of men go past. I don't wanna be the last..."

Todd Smith7-Jan-03 5:46

Todd Smith

7-Jan-03 5:46

It looks you're trying to create a scripting engine. If that's the case then most scripting engines accept arguments as strings and then convert those arguments into the proper types.

int TheRealFunc(const char* argument)
{
    // agument is an integer so lets convert
    int i = atoi(argument);

    // blah blah blah
}

Or, for each "real" function there's a wrapper function for your scripting engine that parses the parameters and then does the real call

int TheRealFunc(int a1, int a2, float a3)
{
    // blah blah blah
}

int TheRealFuncWrapper(const char* argument1, const char* argument2, const char* argument3)
{
    // convert the parameters
    int a1 = atoi(argument1);
    int a2 = atoi(argument2);
    float a3 = atof(argument3);

    return TheRealFunc(a1, a2, a3);
}

Todd Smith

Aidman7-Jan-03 6:37

7-Jan-03 6:37

You guessed right, I am trying to create a simple script that can call function in the application that runs the script. But my "script engine", if you real can call it that, is declared as a class where you should be able to call a function named "AddFunction" and you simple add the pointer of the function you want to add into the script class so the script can call it. And also the script has to be able to call win32 API dll calls. Please help how can I make this work, how do I make the call and get the a pointer of the function I wanto add? Confused | :confused:

Aidman » over and out

Chris Richardson7-Jan-03 7:38

Chris Richardson

7-Jan-03 7:38

If you are looking to create a scripting engine, take a look at the IDispatch interface in the MSDN. Specifically, the Invoke member of IDispatch. What it defines is sort of what you are looking for I think.

Chris Richardson

Programmers find all sorts of ingenious ways to screw ourselves over. - Tim Smith

Aidman7-Jan-03 10:50

7-Jan-03 10:50

Please understand that I don't wanto use any already designed scripts, escially an script object. I wanto create my own language and own engine Smile | :)

Aidman » over and out

Function Pointers in OOP

tilli again6-Jan-03 11:11

tilli again

6-Jan-03 11:11

Hey everyone!

Okay, I have the following code:

typedef int (*funcP) (int v1, int v2);

struct pStruc
{
funcP callback;
};

struct pStruc *callbacks;

int someFunc (int v1, int v2)
{
return v1 + v2;
}

int anotherFunc (int v1, int v2)
{
return v1 - v2;
}

struct pStruc *assignFuncs ()
{
return (struct pStruc []) {&someFunc, &anotherFunc};
}

void main ()
{
callbacks = assignFuncs ();
cout << callbacks->callback (10, 20);
}

Output will be 30.

You should get the idea: I have an array of function pointers, and I need to call the stored functions. Works so far. Now, what will I have to do if assignFuncs as well as the two refered functions are members of some class? I'd like to have it working in a very flexible way, without any hardcoded class name! Any idea?

tilli

Alvaro Mendez6-Jan-03 11:38

Alvaro Mendez

6-Jan-03 11:38

I'd like to give you an exact answer but I'm afraid my experience with member function pointers is extremely limited (thank God). If you haven't already, you may want to search the C/C++ articles here for ways of accomplishing what you need.

What I'd like to know is why? Why go through this syntactic nightmare when OO techniques such as virtual functions may provide a more elegant and maintainable solution?

Regards,
Alvaro

Well done is better than well said. -- Benjamin Franklin
(I actually prefer medium-well.)

William E. Kempf6-Jan-03 12:03

William E. Kempf

6-Jan-03 12:03

C++ is strongly typed, so you can't use member-function pointers with out a class name. Nor can you mix function pointers with member-function pointers. However, you can accomplish what you want (and a lot more) by giving up on function pointers and turning to higher level "function objects" with libraries like Loki or Boost.Function (and Boost.Bind is quite handy when using Boost.Function as well!). http://www.boost.org[^]

William E. Kempf

valikac6-Jan-03 16:07

valikac

6-Jan-03 16:07

One solution is static declaration. Given assignFuncs points to a class member function, then that class member function must be static if you want to call it anytime and anywhere. Otherwise, you must call it via object.

Kuphryn

tilli again7-Jan-03 8:43

tilli again

7-Jan-03 8:43

Great! Making them static is working. To answer the question about "why the hassle": I'm writing on an Win32 API OOP Wrapper, and I wanted the user to be able to overwrite a function (assignFunc in this case) which is called by the class during the initialization process. What it does then is returning a list of Window Messages with their corresponding callback functions. Once a message needs to be processed then, the window message loop checks if the message has a callback defined and launches it. The reason I wanna be able to use class member functions for this purpose is so the callback functions can use member variables.

tilli