Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
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
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.
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.
1 comment thread