How to use a function pointer properly

Question

I have problem with a function pointer. I have this typedef :

typedef struct patchwork *(*create_patchwork_value_fct) 
                                            (const enum nature_primitif);

which is generic for the sake of it (implemented in another file). I want to call it with an input. How do I do ?

This function pointer typedef works exactly the same as if you would do `typedef int* obscure_t; ...obscure_t ptr = &some_int;` — Lundin, May 27 '15 at 09:38

score 1 · Answer 1 · edited May 23 '17 at 12:05

1

You need to

Define a variable of the type of the typedefed function pointer.
Put the address of a function having same signature to it.
Use the variable as a normal function name to make the function call.

Pseudo-code

If you have a function like

struct patchwork * funccall(const enum nature_primitif)
{
  //do something
}

and then, you can do

create_patchwork_value_fct fp= funccall;
struct patchwork * retptr = NULL;
enum nature_primitif enumVal = <some enum value>;

retptr = fp(enumVal);

Maybe you can read this answer to get some more insight.

edited May 23 '17 at 12:05

Community

1
1

answered May 27 '15 at 09:11

Sourav Ghosh

133,132
16
183
261

1

Am I missing something? Isnt create_patchwork_value_fct a typedef, not the func ptr itself? – mjs May 27 '15 at 09:15
1

@DaanTimmer yep, I stand correted. Thanks to mjs, though. :-) – Sourav Ghosh May 27 '15 at 09:23

mjs · Answer 2 · 2015-05-27T09:30:10.853

This isnt actually a function pointer - this is defining a function pointer type:

typedef struct patchwork *(*create_patchwork_value_fct) (const enum nature_primitif);

So, this defines a function pointer type called create_patchwork_value_fct. This is a function pointer to a function that takes a single parameter(const enum nature_primitif), and returns a struct patchwork* - i.e. a pointer to a patchwork struct.

Lets look at how this could be used:

void someFunc(create_patchwork_value_fct funcToCall, enum param)
{
    funcToCall(param);
}

struct patchwork* CreateAPatchworkValue(enum nature_primitif enumVal)
{
     struct patchwork* pwork = malloc(sizeof(struct patchwork));
     pwork->someVal = enumVal;
     return pwork;
}


void main()
{
    someFunc(CreateAPatchworkValue, <a valid nature_primitif enumeration value>)
}

in this example, main() calls someFunc(), passing it a pointer to CreateAPatchworkValue as the funcToCall parameter, and a value from the nature_primitif enum.

someFunc then calls funcToCall, which is actually a call to CreateAPatchworkValue.

How to use a function pointer properly

2 Answers2