C声明符理解

Question

我正在阅读 C99 ISO 标准中的声明符，我正在努力理解以下段落：

5 如果在声明“ T D1 ”中， D1的形式为

标识符

那么为ident指定的类型是T 。

6 如果在声明“ T D1 ”中， D1的形式为

( D )

然后ident具有声明“ TD ”指定的类型。 因此，括号中的声明符与未括号的声明符相同，但复杂声明符的绑定可能会被括号改变。

Answer 1

在引用的定义中， T是一个类型（例如int或double或struct foo或任何 typedef 名称），而D1是一个声明符。

声明符可以是任意复杂的，但由少量的简单步骤构成。 他们提到它是归纳定义的，这是另一种说法，它具有递归定义。

最简单的声明符只是一个标识符名称，例如x或foo 。 所以T可能是int而D1可能是x 。

然后继续说声明符可以用括号括起来，例如(x)或((x))等。这些是退化的情况，并且都等价于x ，但有时需要括号来产生所需的分组。 例如，声明符*x[10]和(*x)[10]含义完全不同。 前者等价于*(x[10]) ，是一个指针数组，而后者是一个指向数组的指针。

还有更多（数组、指针、函数等），但这涵盖了问题中引用的部分。

Answer 2

您省略了前一段重要的内容：

4 在以下子条款中，考虑声明

T D1

其中T包含指定类型T （例如int ）的声明说明符，而D1是包含标识符ident的声明符。 在各种形式的声明符中为标识符ident指定的类型使用这种表示法进行归纳描述。

因此，当我们到达第 5 和第 6 段时，我们知道我们正在考虑的声明包含在我们标记为ident 的某个标识符中。 例如，在int foo(void) ， ident是foo 。

第 5 段说，如果声明“ T D1 ”只是“ T ident ”，则它声明ident为T类型。

第 6 段说，如果声明“ T D1 ”只是“ T ( ident ) ”，它也声明ident是T类型。

这些只是为声明的递归规范建立基本情况。 第 6.7.5.1 节继续说，如果声明“ T D1 ”是“ T * some-qualifiers D ”并且没有*和限定符的相同声明，“ T D ”将声明ident为“ some-derived-类型T ”（如“数组T ”或“指向T指针”），然后带有*和限定符的声明将ident * 声明为“指向T某些派生类型的某些限定符指针”。

例如， int x[3] x声明为“3 个int数组”，因此 6.7.5.1 中的这条规则告诉我们“ int * const x[3] x声明为“ 3 个 const 指向int指针的数组” - 它需要先前必须派生的“3 的数组”，并将“const 指针”附加到它。

类似地，条款 6.7.5.2 和 6.7.5.3 告诉我们将数组和函数类型附加到带有括号（用于下标）和后缀括号的声明符。

Answer 3

在long int *ident[4]; （指向long int的指针的数组 (4) ） long int是说明符列表， *ident[4]是声明符。 您可以将声明符放在括号中而不改变语义： long int (*ident[4]); ，但在更复杂的声明中，例如long int (*ident[4])[5]; （指向 long int 数组（5）的指针数组（4） ），括号影响绑定，因为没有它们， long int *ident[4][5]; 将被解释为指向 long int 的指针的数组 (5) 的数组 (4) 。

它以这种方式工作，因为声明符部分可以递归地包含另一个声明符等等。

来自旧的 C 手册（在后来的标准化 C 中它变得更加间接，但基本原理是相同的）：

declarator:
   identifier
   * declarator
   declarator ( )
   declarator [ constant-expression opt ]
   ( declarator )

换句话说，C 声明符是一种将指向指针/函数返回/数组的前缀添加到某个说明符列表（例如long int ）的方法，并且可以将它们组合起来创建一个链。

通常，在该链的创建过程中，后缀 ( () =function returns, [] =array of) 比* /指向前缀的指针绑定得更紧密。 您可以使用括号来覆盖这个和力* （或几个）结合现在没有它有个人被制服[] / ()后缀。

例如：

 long int *ident[4][5]; //array (4) of array (5) of pointer to long int
 //the suffixes win over the `*` prefix


 long int (*ident[4])[5]; //array (4) of pointer to array (5) of long int
 //the parens force `pointer to` right after `array (4)` 
 //without letting the `[]` suffix overpower the pointer-to/`*` declarator prefix

PS：

1. C 不允许函数数组和返回函数或数组的函数。 这些在语法中都可以很好地表达，但是 C 的语义检查会希望您在那里添加一个指向链接的指针来防止这些。
2. 如果你想玩这些， cdecl.org可能会很有帮助，也许更有用，因为它不做语义检查，因此甚至允许你使用int foo[]()();东西int foo[]()(); （返回 int 的函数数组），它很好地展示了语法是如何工作的，即使 C 编译器会拒绝它们。

Answer 4

...复杂声明符的绑定

这是规范中非常好的提示。

规则本身真的很难分析，因为它是递归的。 声明和声明符的关系和部分也是相关的。

结果是：

• ()和[]是最里面的直接声明符部分，在左边声明（直接通过符号）函数和数组名称
• *将名称声明为右侧的指针
• (...) 需要...复杂的情况，以更改默认关联。

分组括号引导您从内部（标识符）到外部（左侧的类型说明符，例如“int”）。

最后，一切都是关于指针符号*及其所指的内容。 重新制定的（括号表示可选，而不是数组！）语法是：

declarator: [* [qual]] direct-declarator
direct-declarator: (declarator)

foo()是一个 DD（直接声明符）

*foo是一个声明符。 （通过演绎“间接”）

*foo()是 *(foo())。 foo 保持函数，() 和 [] 绑定最强。 * 是返回类型。

(*foo)()使 foo 成为一个指针。 一个函数。

顺便说一句，这也解释了为什么在声明符列表中。

int const * a, b

两者都是 const int，但只有a是指针

const 属于 int 而星号仅属于 a。 这样就更清楚了，

const int x, *pi

但这已经是边缘混淆了。 像现代诗。 适合某些场合。

---

即使没有括号，解析也会有轻微的掉头。 但这很自然：

3   2 0  1
int *foo()

这种标准情况（和类似情况）必须很简单。 还有著名的 multidim 数组，如 int a[10][10][10]。

3    1 0  2
int (*foo)()

这里括号强制“foo”成为左侧的内容（指针）。

---

复杂声明在 K&R C 书中有自己的章节。

这是一种最简单的复杂声明：

int (*(*foo)[])() 

它调试为抽象类型：

int (*(*)[])() 

用(*)替换：

int (*F[])() 

缺少的数组大小给编译器警告——“假设一个元素”。

作为抽象类型：

int (*[])()

但：

int *G[]()

--> 错误：将“G”声明为函数数组

是的，你甚至可以递归，但使用*间接和括号。 这将制作一个圆括号洋葱，中间是标识符，左边是星星，右边是 [] 和 ()。

---

C11 规格有这个怪物。 ...声明可变参数参数：

int (*fpfi(int (*)(long), int))(int, ...)

删除所有参数后：

int (*fpfi())()

只是一个返回指针的函数。 一个到返回 int 的函数。

但是 fpfi 的第一个参数是一个函数本身——一个指向具有返回类型和它自己的参数的函数的指针：

int (*)(long)

非抽象：

int (*foo)(long)

一个指向将 long 正式“转换”为 int 的函数的指针。

这就是参数。 仅有的。 返回值也是一个函数指针，指向函数的参数和返回类型在最外层。 删除整个内部函数的东西(int (*)(long), int) ：

int (*pfi)(int, ...)

或更通用/不完整：

int (*pfi)()

“T（D）”洋葱规则

所以这个洋葱游戏会重演。 在[] 、 ()和*之间由内而外和右-左-右-左。 语法不是问题，而是语义。