Correct syntax use function pointers in C

They are best understood from a syntactical perspective. Say you have the functions foo and bar, sharing a common prototype:

int foo(float a, double b);
int bar(float c, double d);

Now we can declare a function pointer of type int (*)(float, double):

int (*fptr)(float, double) = NULL;

Now, fptr can be assigned foo or bar:

fptr = foo;
...
fptr = bar;
fptr(2.0f, 3.0); /* indirect function call through the pointer */
(*fptr)(2.0f, 3.0); /* same */

For convenience, you can typedef that type to avoid having to type int (*)(float, double) all over the place:

typedef int (*fptr_t)(float, double);

After this, fptr_t will be a shorthand type for a function pointer with such a prototype.

But then, I read the firss answer about How do function pointers in C work?, and the syntax is:

type func1((*func0)(type0 arg0, ..., typen argn), another args){

//do something
(*func0)(type0 arg0, ..., typen argn);

return a_thing;
}

No, syntax for function call via the function pointer is invalid. You want to pass something to it, not de declare function pointer again. Also you miss the return type of the function in function pointer parameters declaration

 type func1(type1 (*func0)(type0 arg0, ..., typen argn), another args){

 func0(par1, ..., parn);

you can also use this form

 (*func0)(par1, ..., parn);

as they equivalent.

and I dont understand which info is correct. I have the code:

double *func1((*func0)(double), double *var){
    double *temp = malloc(some_size);

    for(int i = 0; i < some_cycles; ++i){    
         temp[i] = (*func)(var[i]);

    return temp;

Your function pointer parameter is called func0 and you use func. Also the function parameter declaration is invalid as it requires the return value too. The correct function definition:

#define some_cycles 10

double *func1(double (*func0)(double), double *var)
{
    double *temp = malloc(some_cycles * sizeof(*temp));

    for(int i = 0; i < some_cycles; ++i){
        temp[i] = func0(var[i]);
    }

    return temp;
}

How to make the question code executable

I have tested your code and made some changes to it so that it can be executed:

#include <stdlib.h>
#include <stdio.h>

int some_cycles = 10;

//*********************************************************
// I HAVE ADDED THIS FUNCTION TO PASS IT AS FIRST ARGUMENT
// OF YOUR FUNCTION func1
//*********************************************************
double f(double d) {
    d++;
    return d;
}

//*********************************************************
// THIS IS YOUR FUNCTION
//*********************************************************
double *func1(double (*func0)(double), double *var){
    double *temp = malloc(some_cycles * sizeof(double));

    for(int i = 0; i < some_cycles; ++i){
        temp[i] = (*func0)(var[i]);
    }

    // I HAVE ADDED THE FOLLOWING for loop WITH printf() TO THE BODY
    // OF YOUR FUNCTION TO SHOW THE CONTENT OF THE LOCAL ARRAY temp
    for(int i = 0; i < some_cycles; ++i){
        printf("%f\n", temp[i]);
    }

    return temp;
}


//*********************************************************
// THIS IS THE MAIN FUNCTION
//*********************************************************
int main (int argc, char **argv) {
    double var[] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
    func1(f, var);
    return 0;
}

The output of the code execution

If you compile and execute the previous code the output is:

1.000000
2.000000
3.000000
4.000000
5.000000
6.000000
7.000000
8.000000
9.000000
10.000000

Errors in the question code

I would like to highlight two errors in your code:

1. you have to use func0 in the body of your for loop (and not func which is not declared anywhere)

2. you missed the type double in the definition of the first argument of the function func1; so you have to use:

double (*func0)(double)

and not:

(*func0)(double)

Then for passing function pointers in another function is:

…
func0(type0 arg0, ..., typen argn);

No, to call a function, you use only the arguments, not the types:

func0(arg0, ..., argn);

Lastly, the first answer in [C function pointers invocation syntax][3] explain that the syntax can be:

&func
func
*func
**func

Any of these will work. The specified operand for a function call is a pointer to a function, so &func(arguments) is the “most direct” way to use the function call operator, (…). However, functions are automatically converted to pointers to functions. So func(arguments) works because it is automatically converted to &func(arguments).

The rule is that whenever a function is used in an expression other than has the operand of sizeof (which causes an error) or as the operand of unary &, it is converted to a pointer to the function (C 2018 6.3.2.1 4). This is also why you can use *func and **func. In (*func)(arguments), func is not the operand of sizeof or &, so it is converted to a pointer to the function. Then * takes the pointer and produces what it references, which is the function. Then this function is also not the operand of sizeof or &, so it is also converted to a pointer to the function. The result is as if the code were <code>&func(<i>arguments</i>)</code>, which is correct for a function call.

Similarly, in (**func)(arguments), this automatic conversion occurs three times. No matter how many times you apply *, the result will be automatically converted back to a pointer to the function.

I have the code:

double *func1((*func0)(double), double *var){

double *temp = malloc(some_size);

for(int i = 0; i < some_cycles; ++i){
temp[i] = (*func)(var[i]);

You have some mistake in posting this code, because there is no func declared before (*func)(var[i]), and there is a missing }. The error message you are getting looks like attempting to use some function declared to return double *, which func1 is declared to return. You will need to fix up the code in the question before the error can be explained.