Cはそれほど難しくありません：void（*（* f []）（））（）

今日は写真を見ただけで説明をいただければと思います。だからここに写真があります：

私はこれを混乱させ、そのようなコードがこれまでに実用的であるかどうか疑問に思いました。私は写真をグーグルで検索して、この redditエントリに別の写真を見つけました。ここにその写真があります。

それで、この「螺旋状に読む」は有効なものですか？これはCコンパイラの解析方法ですか？
この奇妙なコードについて、より簡単な説明があればすばらしいでしょう。
すべてのほかに、これらの種類のコードは役に立ちますか？もしそうなら、いつ、どこで？

「スパイラルルール」についての質問がありますが、私はそれがどのように適用されるのか、またはそのルールで式がどのように読み取られるのかを尋ねているだけではありません。私はそのような表現の使用法とスパイラルルールの妥当性についても質問しています。これらについては、いくつかの良い答えがすでに投稿されています。

複雑な宣言の意味を見つけるのに役立つ「時計回り/らせん規則」と呼ばれる規則があります。

c-faqから：

次の3つの簡単な手順があります。

1. 未知の要素から始めて、らせん/時計回りに移動します。次の要素に遭遇すると、それらを対応する英語のステートメントで置き換えます。

   [X]または[]
   =>配列Xのサイズ...または配列未定義のサイズ...

   (type1, type2)
   => type1とtype2を渡す関数が返す...

   *
   =>へのポインタ...

2. すべてのトークンがカバーされるまで、これをらせん/時計回りの方向に続けます。

3. 常に最初に括弧内のものを解決してください！

上記のリンクで例を確認できます。

また、あなたを助けるために呼ばれるウェブサイトがあることにも注意してください：

http://www.cdecl.org

C宣言を入力すると、英語の意味が与えられます。ために

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

それは出力します：

voidを返す関数へのポインタを返す関数へのポインタの配列としてfを宣言します

編集：

Random832のコメントで指摘されているように、スパイラルルールは配列の配列に対応しておらず、これらの宣言（のほとんど）で誤った結果を導きます。たとえばint **x[1][2];、スパイラルルールの場合、[]よりも優先順位が高いという事実は無視され*ます。

配列の配列の前にある場合、スパイラルルールを適用する前に、最初に明示的な括弧を追加できます。例：int **x[1][2];はint **(x[1][2]);優先順位が高いため（これも有効なC）と同じであり、スパイラルルールはそれを「英語の宣言である "xはintへのポインターへのポインターの配列2の配列1"として正しく読み取ります。

この問題はJames Kanzeによってこの回答でもカバーされていることに注意してください（コメントでハックによって指摘されました）。

「スパイラル」ルールは、次の優先ルールには含まれていません。

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

この時点で、ほとんどの人は「use typedefs」と言っていますが、これは確かにオプションです。

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

innerfunc *f[N];

だが...

式でどのように使用 fしますか？あなたはそれがポインタの配列であることを知っていますが、正しい関数を実行するためにどのように使用しますか？typedefを調べ、正しい構文を理解する必要があります。対照的に、「ネイキッド」バージョンはかなり目立たないですが、式での使用 方法を正確に示しますf（つまり、(*(*f[i])())();どちらの関数も引数を取らないと仮定して）。

Cでは、宣言は使用法を反映しています。それが標準での定義方法です。宣言：

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

式(*(*f[i])())()がtypeの結果を生成するという表明ですvoid。つまり：

• f インデックスを作成できるため、配列である必要があります。

  f[i]

• の要素はf逆参照できるため、ポインタでなければなりません。

  *f[i]

• これらのポインタは、呼び出すことができるため、引数を取らない関数へのポインタでなければなりません。

  (*f[i])()

• それらを逆参照できるので、これらの関数の結果もポインタでなければなりません。

  *(*f[i])()

• これらのポインターは、呼び出すことができるため、引数を取らない関数へのポインターでもある必要があります。

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

• これらの関数ポインタは返される必要があります void

「スパイラルルール」は、同じことを異なる方法で理解するためのニーモニックです。

それで、この「螺旋状に読む」は有効なものですか？

スパイラルルールの適用またはcdeclの使用は常に有効であるとは限りません。どちらも失敗する場合があります。スパイラルルールは多くの場合に機能しますが、一般的ではありません。

複雑な宣言を解読するには、次の2つの単純な規則を覚えておいてください。

• 常に宣言を裏返しに読み取る：ある場合は、最も内側の括弧から始めます。宣言されている識別子を見つけ、そこから宣言の解読を開始します。

• 選択肢がある場合は、常に好む[]と()オーバー*：Ifは*、識別子の前にして[]、それを次の、識別子は、配列ではなくポインタを表します。同様に、*識別子の前と()後にある場合、識別子はポインタではなく関数を表します。（括弧は、常に通常の優先順位オーバーライドするために使用することができる[]と()オーバー*）。

このルールには、実際には、識別子の一方の側からもう一方の側へジグザグに移動することが含まれます。

簡単な宣言を解読する

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`"  
^^^^

ここにあなたが行く方法を示すGIFがあります（拡大するには画像をクリックしてください）：

_{ここで言及されているルールは、KN KING著のCプログラミングAモダンアプローチから引用しています。}

この宣言では、各レベルの括弧内の両側に1つの演算子しかないため、これは「スパイラル」にすぎません。「らせん状に」進んでいると主張するとint ***foo[][][]、実際にはすべての配列レベルがどのポインターレベルよりも前にある場合でも、宣言で配列とポインターを交互に使用することをお勧めします。

このような構造は、実生活で使用できるとは思えません。私はそれらを通常の開発者へのインタビューの質問としても嫌いです（おそらくコンパイラー作成者には大丈夫です）。代わりにtypedefを使用する必要があります。

ランダムな雑学の事実として、Cの宣言がどのように読み取られるかを説明する実際の英語の単語があることを知っているとおもしろいかもしれません。

参考：リンデン、1994デア・ヴァン - ページ76

これの有用性については、シェルコードを操作するときに、この構成がたくさん見られます：

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

構文的にはそれほど複雑ではありませんが、この特定のパターンはよく出てきます。

この SO質問のより完全な例。

したがって、元の図の範囲での有用性は疑わしいものですが（プロダクションコードは大幅に簡略化する必要があることをお勧めします）、かなりの構文構文があります。

宣言

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

あいまいな言い方です

Function f[]

と

typedef void (*ResultFunction)();

typedef ResultFunction (*Function)();

実際には、ResultFunctionおよびFunctionではなく、より説明的な名前が必要になります。可能であれば、パラメータリストをとして指定することもできますvoid。

Bruce Eckelによって記述された方法が役に立ち、従うのが簡単であることがわかりました。

関数ポインターの定義

引数も戻り値もない関数へのポインターを定義するには、次のようにします。

void (*funcPtr)();

このような複雑な定義を見ている場合、それを攻撃する最善の方法は、途中から始めて、解決することです。「途中から開始する」とは、変数名であるfuncPtrから開始することを意味します。「問題を解決する」とは、最も近いアイテムを右に見て（この場合は何もない。右のかっこで短くなる）、次に左（アスタリスクで示されたポインタ）を見て、次に右（an引数を取らない関数を示す空の引数リスト）、次に左方向（関数には戻り値がないことを示すvoid）を探します。この左右の動きはほとんどの宣言で機能します。

復習するには、「真ん中から始めて」（「funcPtrは...」）、右に移動し（そこには何もない-右括弧で止められています）、左に移動して「*」を見つけます（「 ...へのポインタ...））、右側に移動して空の引数リストを検索し（「...引数を取らない関数...」）、左側に移動してvoid（「funcPtr is引数を取らず、voidを返す関数へのポインター」）。

なぜ* funcPtrに括弧が必要なのか不思議に思うかもしれません。それらを使用しなかった場合、コンパイラーは次のように表示します。

void *funcPtr();

変数を定義するのではなく、関数（void *を返す）を宣言します。コンパイラは、宣言または定義が何であるかを理解するときに行うのと同じプロセスを経ていると考えることができます。右に続けて空の引数リストを見つけるのではなく、左に戻って「*」を見つけるため、「ぶつかる」にはこれらの括弧が必要です。

複雑な宣言と定義

余談ですが、CおよびC ++の宣言構文がどのように機能するかを理解したら、はるかに複雑なアイテムを作成できます。例えば：

//: C03:ComplicatedDefinitions.cpp

/* 1. */     void * (*(*fp1)(int))[10];

/* 2. */     float (*(*fp2)(int,int,float))(int);

/* 3. */     typedef double (*(*(*fp3)())[10])();
             fp3 a;

/* 4. */     int (*(*f4())[10])();


int main() {} ///:~ 

それぞれについて説明し、左右のガイドラインを使用して理解します。番号1は、「fp1は整数の引数を取り、10個のvoidポインターの配列へのポインターを返す関数へのポインターです。」と述べています。

番号2は、「fp2は3つの引数（int、int、float）を取り、整数の引数を取り、floatを返す関数へのポインターを返す関数へのポインターです。」

複雑な定義をたくさん作成している場合は、typedefを使用することをお勧めします。番号3は、typedefが毎回複雑な説明を入力する手間を省く方法を示しています。「fp3は、引数を取らず、引数を取らずdoubleを返す関数への10個のポインターの配列へのポインターを返す関数へのポインターです。」次に、「aはこれらのfp3タイプの1つです」と表示されます。typedefは通常、単純な記述から複雑な記述を構築するのに役立ちます。

番号4は、変数定義ではなく関数宣言です。「f4は、整数を返す関数への10個のポインターの配列へのポインターを返す関数です。」

このような複雑な宣言と定義が必要になることはめったにありません。しかし、それらを理解する練習をすれば、実際の生活で遭遇するかもしれない少し複雑なものに少しでも邪魔されることはありません。

引用元：C ++ボリューム1、第2版、第3章、ブルースエッケルによる「関数アドレス」のセクションでの考え方。

これらのC宣言の規則を覚えておいてください。
優先順位が疑われることはありません。
接尾辞から始めて、接頭辞を進め、
両方のセットを内側から外側に向かって読みます。
-私、1980年代半ば

もちろん、括弧で変更されている場合を除きます。また、これらを宣言するための構文は、その変数を使用して基本クラスのインスタンスを取得するための構文を正確に反映していることに注意してください。

真剣に、これは一目で行うことを学ぶのは難しくありません。あなたはスキルを練習するためにいくらかの時間を費やすことをいとわない必要があります。あなたが他の人によって書かれたCコードを維持または適応するつもりなら、それはだ間違いなく投資その時間の価値。また、それを学んでいない他のプログラマーを驚かせるための楽しいパーティートリックでもあります。

あなた自身のコードの場合：いつものように、何かがワンライナーとして記述できるという事実は、それが標準のイディオムになった非常に一般的なパターン（文字列コピーループなど）でない限り、そうである必要があることを意味しません。これらの「1つのスウェルグループ」を生成して解析する能力に依存するのではなく、レイヤー化されたtypedefと段階的な逆参照から複雑なタイプを構築する場合、あなたとあなたに従う人ははるかに幸せになります。パフォーマンスも同様に良好になり、コードの可読性と保守性が大幅に向上します。

もっと悪くなるかもしれませんね。次のようなもので始まる合法的なPL / Iステートメントがありました。

if if if = then then then = else else else = if then ...

私はたまたま何年も前に（髪がたくさんあったとき）書いたスパイラルルールの元の作者であり、cfaqに追加されたときに光栄でした。

私のスパイラルルールは、生徒や同僚が「頭の中で」Cの宣言を読みやすくするための方法として作成しました。つまり、cdecl.orgなどのソフトウェアツールを使用する必要はありません。スパイラルルールがC式を解析するための標準的な方法であることを宣言するつもりはありませんでした。しかし、このルールが長年にわたって文字通り何千ものCプログラミングの学生や実務家を助けてきたことを嬉しく思います！

記録のために、

Linus Torvalds（私が非常に尊敬している人）を含め、多くのサイトで何度も「正しく」識別されており、私のスパイラルルールが「破綻」する状況があります。最も一般的な存在：

char *ar[10][10];

このスレッドで他の人が指摘しているように、配列に遭遇したときは、次のようにすべてのインデックスを消費するようにルールを更新できます。

char *(ar[10][10]);

今、スパイラルルールに従って、私は得ます：

「arは、charへのポインタの10x10 2次元配列です」

スパイラルルールがCの学習に役立つことを願っています！

PS：

「Cは難しくない」画像が大好きです:)

• ボイド (*(*f[]) ()) ()

解決中void>>

• (*(*f[]) ()) （）= void

安心()>>

• （* (*f[]) ()）=関数が返す（void）

解決中*>>

• (*f[]) （）=（（voidを返す関数）へのポインタ）

解決中()>>

• （* f[]）=関数の戻り値（（関数の戻り値（void）へのポインタ））

解決中*>>

• f[] =（関数の戻り値へのポインター（（関数の戻り値（void）へのポインター）））

解決中[ ]>>

• f =（ポインタから（関数の戻り値（ポインタから（関数の戻り値（void）））））の配列）