What does a variable followed by parentheses ("ptr()") mean?
What does ptr() mean in this code?
#include<stdio.h>
#include<stdlib.h>
void PrintHello()
{
printf("Hello\n");
}
int Add(int a, int b)
{
return a+b;
}
int main ()
{
void (*ptr)();
ptr = PrintHello;
ptr(); //For this specific line of code, what does it mean?
}
2 answers
What does
ptr()mean in this code?
An expression like ptr followed by parentheses as in ptr() is a function call. In your example, ptr is a variable of type "pointer to function" because of the declaration void (*ptr)(). That is, ptr() will call the function that the variable ptr points to. And, due to the assignment ptr = PrintHello, the variable ptr contains the pointer to the function PrintHello.
For those not familiar with function pointers, the syntax appears strange, and some magic seems to happen. To make it a bit easier to understand, I have used your example code and added some alternative ways to write the assignment and function call.
int main ()
{
void (*ptr)(void); // ptr is a pointer to a function that
// returns void (first void in the line)
// and takes no arguments "(void)"
ptr = PrintHello; // PrintHello is implicitly converted to
// pointer to function - you could also write:
ptr = &PrintHello; // Some people prefer writing it like this to
// make it clear that a function pointer is used
ptr(); // Call the function. Could also be written as:
(*ptr)(); // Some people prefer writing it like this to
// make it clear that a function pointer is used
// Ignore the below part if you are not really interested in some
// background about how the C standard defines the stuff - which
// may be surprising, because it appears somehow upside-down...
PrintHello(); // Normal way of writing a function call, but:
(&PrintHello)(); // This is what the compiler makes of it.
// See C standard 6.5.2.2#1 with footnote and
// 6.3.2.1.#4
}
On a side note, to remember the function pointer declaration syntax, I always think about how the function call would look like. I come up with the expression (*ptr)(), because I think: "first dereference the function pointer to get the function, afterwards call it with the arguments". Then I am almost done, because the syntax for the call is similar to the syntax of the declaration.
0 comment threads
void (*ptr)() defines a function pointer. It says that ptr is a pointer to a function. But that function must have a void return type, and take an arbitrary number of parameters (that's what the empty parentheses defines).
Then, ptr = PrintHello assigns the PrintHello function to the ptr pointer (and it works because PrintHello matches the signature: it has a void return type). So, now ptr is pointing to PrintHello.
Finally, ptr() is calling the function that ptr points to (in this case, PrintHello). It has the same effect as calling PrintHello(), and the parentheses are needed because it's a function call. But the function takes no parameters, thus the empty parentheses.
2 comment threads
1 comment thread