指向引用函数的指针数组的指针，如何更改指针值和调用函数？

Question

int *(*(*functions_array)[4](); 
int *function() { /*code */ };

I know that with a Pointer referencing a function int *(*func)(); I can just assign pointer value of a function to func func = &function; and then call with func(); .

What's the closest I could get to this behavior but with addition of arrays ?

Answer 1

You probably want this:

#include <stdio.h>

int function1(void)
{
  printf("function 1\n");
  return 1;
};

int function2(void)
{
  printf("function 2\n");
  return 2;
};

int(*FunctionPointer)(void);             // a function pointer
int(*ArrayOfFunctionPointers[4])(void);  // an array of 4 function pointers


int main()
{
  FunctionPointer = function1;
  FunctionPointer();                     // will call function1

  FunctionPointer = function2;
  FunctionPointer();                     // will call function2

  ArrayOfFunctionPointers[0] = function1;
  ArrayOfFunctionPointers[1] = function2;

  for (int i = 0; i < 2; i++)
  {
    ArrayOfFunctionPointers[i]();
  }
}

Output:

function 1
function 2
function 1
function 2

Answer 2

First thing's first, the declaration you show is ill-formed. Not surprisingly, given how hard the declarator syntax in C can be. If you wanted an array of function pointers (something I strongly suspect), then the raw spelling is like this:

int *(*functions_array[4])();

Not much more readable, but at least syntactically correct. You can now index into it to obtain a function pointer for your use. Eg:

functions_array[0] = function; 
functions_array[0](); // Call the function

But if you really wanted a pointer to an array (for reasons I can't fathom), the raw declarator is this:

int *(*(*functions_array_p)[4])();

With the now less appealing indexing to match:

(*functions_array_p)[0] = function; 
(*functions_array_p)[0](); // Call the function

The parenthesis are required due to the regular precedence of * and [] .

But the way to make working with it and defining it easier, is by introducing some type aliases. Primarily, for the function type:

typedef int* function_type();

Now the array declaration takes this far more readable form:

function_type* functions_array[4];

The asterisk in plain sight is inline with the generally good practice of not hiding away pointer semantics.

And for a pointer to an array:

function_type* (*functions_array)[4];

The declarator is still fairly regular looking.

---

_{1. As an aside, an empty parameter list in a C function declaration does not mean the function takes no arguments. It's an obsolescent feature providing a function with no prototype. The way forward is (void) .}