What does a variable followed by parentheses ("ptr()") 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.
1 comment thread