C不是那么难:void(*(*f [])())()

我今天刚看了一张照片,觉得我很感激解释.所以这是图片:

我发现这令人困惑,并想知道这些代码是否实用.我用Google搜索了这张照片,并在此 reddit条目中找到了另一张照片,这是照片:

那么"螺旋式阅读"是有效的吗？这是C编译器解析的方式吗？
如果对这个奇怪的代码有更简单的解释,那就太好了.
除此之外,这些代码是否有用？如果是这样,何时何地？

有一个关于"螺旋规则"的问题,但我不只是询问它是如何应用的,或者是如何用该规则读取表达式的.我也质疑这种表达方式的使用和螺旋规则的有效性.关于这些,已经发布了一些很好的答案.

有一个称为"顺时针/螺旋规则"的规则来帮助找到复杂声明的含义.

来自c-faq:

有三个简单的步骤:

从未知元素开始,以螺旋/顺时针方向移动; 在制定以下元素时,用相应的英语声明替换它们:

[X]或[]
=>数组X大小...或数组未定义大小...

(type1, type2)
=>函数传递type1和type2返回...

*
=>指针到......

继续以螺旋/顺时针方向执行此操作,直到所有令牌都被覆盖.

始终先解决括号中的任何内容!

您可以查看上面的链接以获取示例.

另请注意,为了帮助您,还有一个名为的网站:

http://www.cdecl.org

您可以输入C声明,它将赋予其英语含义.对于

void (*(*f[])())()

它输出:

声明f为指向函数的指针数组,返回指向函数返回void的指针

编辑:

正如Random832的评论中所指出的,螺旋规则不会解决数组数组,并且会导致(大多数)这些声明中的错误结果.例如,int **x[1][2];螺旋规则忽略了[]优先级高的事实*.

当在数组数组前面时,可以在应用螺旋规则之前首先添加显式括号.例如:由于优先级而与(也是有效的C)int **x[1][2];相同,int **(x[1][2]);然后螺旋规则正确地将其读作"x是指向int的指针的数组2的数组1",这是正确的英语声明.

请注意,这个问题也被包括在本答案由詹姆斯·甘孜(中指出haccks在评论).

"螺旋"规则类型不符合以下优先规则:

T *a[]    -- a is an array of pointer to T
T (*a)[]  -- a is a pointer to an array of T
T *f()    -- f is a function returning a pointer to T
T (*f)()  -- f is a pointer to a function returning T

下标[]和函数调用()操作符的优先级高于一元*,因此*f()被解析为*(f())和*a[]解析为*(a[]).

因此,如果您需要指向数组的指针或指向函数的指针,那么您需要*使用标识符显式地对其进行分组,如(*a)[]或(*f)().

然后你意识到这一点,a并且f可以是比标识符更复杂的表达式; in T (*a)[N],a可以是一个简单的标识符,或者它可以是一个函数调用,如(*f())[N](a- > f()),或者它可以是一个数组,如(*p[M])[N](a- > p[M]),或者它可以是一个指向函数的指针数组,如(*(*p[M])())[N](a- > (*p[M])()),等等

如果间接运算符*是后缀而不是一元,这将是很好的,这将使声明从左到右更容易阅读(void f[]*()*();肯定流量更好void (*(*f[])())()),但事实并非如此.

当你遇到像这样的毛茸茸的声明时,首先找到最左边的标识符并应用上面的优先规则,递归地将它们应用于任何函数参数:

         f              -- f
         f[]            -- is an array
        *f[]            -- of pointers  ([] has higher precedence than *)
       (*f[])()         -- to functions
      *(*f[])()         -- returning pointers
     (*(*f[])())()      -- to functions
void (*(*f[])())();     -- returning void

signal标准库中的函数可能是这种疯狂的类型标本:

       signal                                       -- signal
       signal(                          )           -- is a function with parameters
       signal(    sig,                  )           --    sig
       signal(int sig,                  )           --    which is an int and
       signal(int sig,        func      )           --    func
       signal(int sig,       *func      )           --    which is a pointer
       signal(int sig,      (*func)(int))           --    to a function taking an int                                           
       signal(int sig, void (*func)(int))           --    returning void
      *signal(int sig, void (*func)(int))           -- returning a pointer
     (*signal(int sig, void (*func)(int)))(int)     -- to a function taking an int
void (*signal(int sig, void (*func)(int)))(int);    -- and returning void

此时大多数人都说"使用typedefs",这当然是一个选择:

typedef void outerfunc(void);
typedef outerfunc *innerfunc(void);

innerfunc *f[N];

但...

你会如何在表达中使用 f？你知道它是一个指针数组,但你如何使用它来执行正确的函数？你必须查看typedef并解开正确的语法.相比之下,"裸"版本非常引人注目,但它确切地告诉你如何在表达式中使用 f(即(*(*f[i])())();,假设两个函数都没有参数).

在C中,声明镜像用法 - 它是如何在标准中定义的.声明:

void (*(*f[])())()

断言表达式(*(*f[i])())()产生类型的结果void.意思是:

f 必须是一个数组,因为你可以索引它:

f[i]

f必须是指针的元素,因为你可以取消引用它们:

*f[i]

那些指针必须是不带参数的函数的指针,因为你可以调用它们:

(*f[i])()

这些函数的结果也必须是指针,因为你可以取消引用它们:

*(*f[i])()

那些指针也必须是不带参数的函数的指针,因为你可以调用它们:

(*(*f[i])())()

那些函数指针必须返回 void

"螺旋规则"只是一种助记符,提供了一种理解同一事物的不同方式.

int *a[10];

int *a[10];      "a is"  
     ^  

int *a[10];      "a is an array"  
      ^^^^ 

int *a[10];      "a is an array of pointers"
    ^

int *a[10];      "a is an array of pointers to `int`".  
^^^      

void ( *(*f[]) () ) ();  

void ( *(*f[]) () ) ();        "f is"  
          ^  

void ( *(*f[]) () ) ();        "f is an array"  
           ^^ 

void ( *(*f[]) () ) ();        "f is an array of pointers" 
         ^    

void ( *(*f[]) () ) ();        "f is an array of pointers to function"   
               ^^     

void ( *(*f[]) () ) ();        "f is an array of pointers to function returning pointer"
       ^   

void ( *(*f[]) () ) ();        "f is an array of pointers to function returning pointer to function" 
                    ^^    

void ( *(*f[]) () ) ();        "f is an array of pointers to function returning pointer to function returning `void`"  
^^^^

int (*ret)() = (int(*)())code;
ret();

void (*(*f[])())()

Function f[]

typedef void (*ResultFunction)();

typedef ResultFunction (*Function)();