This question already has answers here:
How do you read C declarations?
(10 answers)
Closed 4 years ago.
I have this syntax:
double (*(f(double (*)(int))))(int);
Do I understand correctly syntax above that f is function that gets pointer to function that receive int and return a double?
No; it's actually even more complicated than that.
cdecl.org glosses this type definition as:
declare f as function (pointer to function (int) returning double) returning pointer to function (int) returning double
In other words, the function pointed to by f takes a function pointer as an argument, and returns a function pointer. Both of those function pointers must be to functions which take an int as an argument and return a double.
You could simplify this definition a bit using an intermediate typedef as follows:
typedef double (*int_to_double_function)(int);
int_to_double_function (*f)(int_to_double_function);
Related
This question already has answers here:
How do both of these function pointer calling syntax variations work?
(4 answers)
Closed 4 years ago.
I have a an array of int and I need to assign a function pointer,
f(tab[i]) and (*f)(tab[i])
What is the difference between those 2 syntax ??
Your code looks as if you are invoking a function via a function pointer, and you're seeking to pass one element of an array to that function. The pointer might be defined as:
void (*f)(int); // Function pointer — guessed argument and return types
The difference between the invocations (*f)(tab[i]) and f(tab[i]) is spelling and history — the result is the same.
The (*f)(tab[i]) notation was mandatory before the C90 standard; the f(tab[i]) notation was allowed by C90. The advantage of (*f)(tab[i]) is that you don't accidentally head off looking for a function f — you can see it's a function pointer immediately. (Of course, that assumes you don't have a colleague who delights in writing (*sqrt)((*sin)(x)*(*cos)(x)) or other similar valid but unconscionably obscure absurdities.)
If tab is an array of integer, then this below statement
(*f)(tab[i])
is invoking a function using function pointer, where f is a function pointer which can points to a function which takes argument as tab[i]. for e.g In below code block
void print_arr(int arr_ele_value) {
printf("%d\t",arr_ele_value);
}
int main(void) {
int arr[] = {1,2,3,4,5},ele;
ele = sizeof(arr)/sizeof(arr[0]);
void (*f)(int); /* function pointer declaration */
f = print_arr; /* fun-ptr initialization */
for(int row = 0; row < ele; row++) {
(*f)(arr[row]); /* calling a function through function pointer */
}
return 0;
}
This
void (*f)(int);
is function pointer declaration which says, f is a function pointer which can points to a function which takes input argument as int and returns void.
And here
f = function;
f is assigned with function which satisfies above condition of function-pointer declaration.
And this is how you can call a function using function pointer
(*f)(arr[row]);
There is no difference nowadays for the compiler; there is only a difference for the humans.
This question already has answers here:
Writing a function pointer in c
(3 answers)
How do you read C declarations?
(10 answers)
Closed 8 years ago.
Can anyone please explain what int ((*foo(int)))(int) in this does?
int (*fooptr)(int);
int ((*foo(int)))(int); // Can't understand what this does.
int main()
{
fooptr = foo(0);
fooptr(10);
}
.
int ((*foo(int)))(int);
This declares foo as a function that expects an int type argument and returns a pointer to a function that expects an int type argument and return an int.
To be more clear:
foo -- foo
foo( ) -- is a function
foo(int) -- taking an int argument
*foo(int) -- returning a pointer
(*foo(int))( ) -- to a function that
(*foo(int))(int) -- takes an int argument
int (*foo(int))(int) -- and returning an int
Here is a good explanation for the same.
foo
is what we declare.
foo(int)
It is a function that takes a single int argument
*foo(int)
and returns a pointer
((*foo(int)))(int)
to a function that takes a single int argument
int ((*foo(int)))(int)
and returns an int.
One pair of () is redundant. The same thing can be expressed as
int (*foo(int))(int)
There already answers to this, but I wanted to approach it in the opposite way.
A function declaration looks the same as a variable declaration, except that the variable name is replaced by the function name and parameters.
So this declares bar as a pointer to a function that takes an int and returns an int:
int (*bar)(int);
If, instead of a variable bar, it's a function foo(int) with that return value, you replace bar with foo(int) and get:
int (*foo(int))(int);
// ^^^^^^^^
// this was "bar" before
Add an unnecessary pair of parentheses and you get:
int ((*foo(int)))(int);
// ^ ^
// extra parentheses
According to cdecl, foo is:
declare foo as function (int) returning pointer to function (int) returning int
This question already has answers here:
How does dereferencing of a function pointer happen?
(5 answers)
Closed 8 years ago.
What is the difference in dereferencing a function pointer with and without parentheses.
both the mechanism are working same on linux Gnu Gcc.
void (*fp)(void); //function pointer
void func(void);
fp = func;
(*fp)(); //dereferencing with parentheses
fp(); // without parentheses
You need to know that
(*fp)() = fp()
The function pointer can be called in both the ways and both are valid and same.
Check the below link:
How does dereferencing of a function pointer happen?
This question already has answers here:
Function Returning Itself
(10 answers)
Closed 8 years ago.
Is it possible in C to have a pointer to a function that returns a pointer to the same type of function? i.e. a pointer to a function that returns a pointer to a function that returns a pointer to a function that... etc etc.
A function pointer with int return type is:
int (*fp)(void);
So I guess a function pointer with function pointer to that would be
typedef int (*fp)(void);
fp (*pfp)(void);
But a pointer to a function that returns a function of the same type would have... an infinite recursive declaration? i.e. one would never be able to write the first typedef.
Is that correct?
I'm thinking a workaround would be to actually return a void pointer then cast that to the function pointer type maybe? e.g.
typedef void * (*fp)(void)
void * stateWork(void) {return &nextStateWork}
machine () {
fp = &stateWork;
state = (fp)(*fp)();
}
You are right in the first part, you cannot have a directly recursive type in C.
But your workaround runs afoul of UB:
data-pointers and function-pointers are fundamentally different types, roundtrip-conversion is not guaranteed:
Just use any old function-type for function pointers, they are all mutually round-trip convertible.
Aside: Making void* and function-pointers compatible is a common extension mentioned in the standard.
POSIX, Windows and MacOS do it:
J.5.7 [common extensions] Function pointer casts
1 A pointer to an object or to void may be cast to a pointer to a function, allowing data to
be invoked as a function (6.5.4).
2 A pointer to a function may be cast to a pointer to an object or to void, allowing a
function to be inspected or modified (for example, by a debugger) (6.5.4).
This question already has answers here:
What is the difference between const int*, const int * const, and int const *?
(23 answers)
Closed 9 years ago.
I know that int* foo(int) prototype means that foo is a function that takes an integer argument and returns a pointer to an integer.But what does the following mean?
const int* foo(int);
I tried to reason but failed.My book doesn't say anything about this but I see stuff like this in library function prototypes.So please tell me what it means.
So that value pointed by returned address can't be change via address (useful when foo() returns address of const).
const int* p2c = foo(int);
*p2c=10; <-- "error"
from cdecl:
this means
declare foo as function (int) returning pointer to const int
const int* foo(int);
foo is a function that takes an integer argument and returns a pointer to an const integer.It means you are allowed to change pointer but not it's value.