求证函数参数定义与普通变量声明一致性的书面依据

Great question! This consistency isn’t just a happy accident—it’s explicitly spelled out in the C standard, which is the definitive written proof you’re seeking. Let’s break this down with clear examples, including your function pointer array scenario.

The Core Rule from the C Standard #

At the heart of this is C’s unified declaration syntax. The C11 standard (and its predecessors like C99) states that function parameter declarations follow the exact same grammar rules as regular variable declarations.

Specifically, section 6.7.6 (Declarators) outlines that declarators (the part of a declaration that names the variable/parameter and specifies its type) work identically whether you’re declaring a variable in a block scope or a parameter in a function’s parameter list.

For array and function parameters, there’s an adjustment rule (section 6.7.6.3p7 and 6.7.6.3p8) that converts array declarations to pointer declarations, and function declarations to function pointer declarations—but the written syntax you use to declare them remains identical to regular variables.

Basic Example: Simple Parameters vs. Regular Variables #

Let’s start with a straightforward case to see the parity:

• Regular variable declaration: int my_var;
• Function parameter declaration: void my_func(int my_var) { ... }

The int my_var part is exactly the same in both contexts. In the function, the parameter is just a variable declared in the function’s parameter scope, following the same syntax as any other variable.

Complex Scenario: Function Pointer Arrays #

Now let’s tackle your more advanced example—function pointer arrays.

Regular Variable Declaration (Function Pointer Array) #

First, here’s how you declare a regular variable that’s an array of function pointers:

// An array of 5 pointers to functions that take an int and return void
void (*fp_array[5])(int);

As a Function Parameter #

When you use this as a function parameter, you write exactly the same syntax:

// Function parameter with the same declaration syntax as the regular variable
void process_fp_array(void (*fp_array[5])(int)) {
    // Note: Behind the scenes, the compiler adjusts the array parameter to a pointer
    // So fp_array is actually of type void (*(*fp_array))(int) (pointer to function pointer)
    // But the written declaration matches the regular variable exactly
}

To make this even clearer, we can use a typedef to simplify the function pointer type:

typedef void (*FuncPtr)(int);

// Regular variable: array of FuncPtr
FuncPtr fp_array[5];

// Function parameter: same syntax as the regular variable
void process_func_ptrs(FuncPtr fp_array[5]) { ... }

This consistency is intentional. The C standard’s design prioritizes making declaration syntax uniform across all contexts, so you don’t have to learn separate rules for variables vs. function parameters.

内容的提问来源于stack exchange，提问作者ynn