Declaring an array of functions of type void C++

Question

I have a few functions that return void. I made pointers to these functions and wanted to have an array of these functions:

Why does this code work:

#include <cstdio>
using std::puts;

void tell() {
  puts("hi");
};

void slap() {
  puts("goodbye");
}

int main(int argc, char *argv[])
{

  void (*tp)() = tell;
  void (*sp)() = slap;

  void(*funcs[])() = {tp, sp};
  for (auto point:funcs) {
    point();
  }
  return 0;
}

When I try this code with out specifying a pointer in funcs (i.e. void(funcs[])() = {tp, sp}; I get " error: 'funcs' declared as array of functions of type 'void ()' " Which is exactly what they are - so why is that an error?

I also don't get the syntax, wouldn't the () at the end of void(*funcs[])() indicate actually calling a function?

Answer 1

C++ Standard 8.3.5/10 says:

There shall be no arrays of functions, although there can be arrays of pointers to functions.

The declaration of "funcs" must be read using the "spiral rule":

funcs[]: funcs is an array

*funcs[]: funcs is an array of pointers

(*funcs[])(): funcs is an array of pointers to functions with no parameters

void (*funcs[])(): funcs is an array of pointers to functions with no parameters returning void.

Answer 2

Well you can declare it explicitly like this:

void (*actions[5])();

But this is nearly unreadable.
To make it more readable use a typedef.

typedef void(*Action)();    // Action is the typename for a pointer
                            // to a function return null and taking
                            // no parameters.

Action   actions[5];        // An array of 5 Action objects.

Or for your purposes:

int main()
{
     Action   actions[] = {&tell, &slap};
}

Answer 3

Without the asterisk, void (funcs[])() declares an array of functions rather than array of pointers to functions. The latter is allowed in the C++ grammar while the former is not.

[dcl.array]/p1:

T is called the array element type; this type shall not be a reference type, the (possibly cv-qualified) type void, a function type or an abstract class type.

The contents of the initializer-list ({tp, sp}) are functions but they are converted to pointers via the function-to-pointer conversion:

[conv.func]/p1

An lvalue of function type T can be converted to a prvalue of type “pointer to T.” The result is a pointer to the function.

Note that C++ also doesn't allow an array of references.

---

I also don't get the syntax, wouldn't the () at the end of void(*funcs[])() indicate actually calling a function?

No, this is a declaration of an array type. The () is part of the construction of the type which specifies the argument list of the function. The entire type indicates "an array of pointers to functions which take zero arguments (()) and return void". It may become clearer with the use of a type alias:

using void_f = void (*)();
void_f funcs[] = {tp, sp};