這些指針的含義，pointer-to-pointer，function指針和數組指針

Question

我是一名大學生，我們的老師讓我們說出這些指針的含義，但我只能弄清楚其中的一些：

1. int *p1;
2. int *p2[10];
3. int (*p3)[10];
4. int (*p4)();
5. int **p5();
6. int (**p6)[10];
7. int (**p7)();
8. int *(*p8)();
9. int (*p9[10])();
10. int **p10[10];

這是我到目前為止所知道的：

• p1 是一個指向 int 的指針
• p2 是一個包含 10 個 int 指針的數組
• p3 是指向具有 10 個元素的靜態數組的指針
• p4 是一個 function 指針
• p5 根本不是指針，而是返回 int 的 function 的原型**
• p6 是一個包含 10 個指針的數組
• p7 是指向 function 指針的指針

你們能幫幫我嗎？ 因為我們的老師告訴我們這些將在考試中

Answer 1

cdecl.org可用於破譯混亂的聲明，如您的示例：

int (*p9[10])(); => 將 p9 聲明為指向 function 返回 int 的指針的數組 10

如果做不到這一點，您可以使用順時針/螺旋規則手動打磨它們。

Answer 2

所有 7 個指針都正確確定，但您應該指定參數類型和返回類型。

例如：

5. int **p5(); - function 沒有 arguments，返回指向int的指針的指針。

---

8. int *(*p8)(); - 指向沒有 arguments 的 function 的指針，返回指向int的指針。
9. int (*p9[10])(); - 指向 function 的 10 個指針數組，沒有 arguments，返回int 。
10. int **p10[10]; - 10 個指向int指針的數組。

---

如果我是編譯器，我可以提示空參數列表，就像 fe clang 所做的那樣：

“警告：這個 function 聲明不是原型 [-Wstrict-prototypes] ”

在實踐中使用這些構造時，使用(void)而不是() 。

---

請注意，如果您正在參加考試，請考慮大衛安德森的順時針/螺旋規則，如圖所示。

Answer 3

1>指向integer的指針

int *p1;
```````````````````````````````````````
2>array of 10 pointer which point to integer
`````````````````````````````````
int *p2[10];
`````````````````````````````````
3> pointer to an array of 10 integers
```````````````````````
int (*p3)[10]
``````````````````````````````````````
4> pointer to function that takes void argument and return integer
`````````````
int (*p4)();
```````````````
5>> is a prototype(deceleration)  of a function which called p5 and returns int** 
````````````
int **p5();
``````````
6>> is an array of 10 pointer-to-pointer which point to integer values
`````````
 int (**p6)[10]
````````
7>>is pointer to pointer to function that takes void argument and return int
``````````````
int (**p7)();
````````````````
8>>pointer to function that takes void argument and return address or pointer
`````````````````
int *(*p8)();
`````````````
9>>array of 10 pointers to functions that take void argument and return an integer
``````````````````
 int (*p9[10])();
```````````````
10>> it indicate to the first element in an array of 10 pointers which point to integer values 
```````````
int **p10[10];
```````````

Answer 4

有一些技巧可以閱讀和理解復雜的聲明。 有一種稱為“順時針螺旋規則”的技巧，您從標識符開始，然后從右邊的任何內容開始向外螺旋。 例如，給定聲明

int *(*a[N])(void);

我們將其追蹤為：

                 +-----------------------+
                 | +-----------+         |
                 | | +-------+ |         |
                 | | | +-+   | |         |
                 | | | | |   | |         |
             int * ( * a [N] ) ( void )  |
             ^   | | |   |   | |         |
             |   | | +---+   | |         |
             |   | +---------+ |         |
             |   +-------------+         |
             +---------------------------+

或者

                   a                -- a
                   a[N]             -- is an N-element array
                  *a[N]             -- of pointers
                 (*a[N])(    )      -- to functions taking
                 (*a[N])(void)      --   no parameters
                *(*a[N])(void)      -- returning pointer to
            int *(*a[N])(void);     -- int

請記住，后綴下標[]和 function call ()運算符的優先級高於一元解引用*運算符，因此*a[i]和*f()之類的表達式被解析為*(a[i])和*(f()) - 我們取消引用a[i]和f()的結果。 如果a指向一個數組，那么我們需要對*a的結果進行索引，因此我們需要使用括號將*與a - (*a)[i]顯式分組。 同樣，如果f指向一個 function，那么我們需要調用*f的結果，所以我們必須寫(*f)() 。

這是一個具有多個間接的示例：

int **foo(void);

分解為

      foo             -- foo
      foo(    )       -- is a function taking
      foo(void)       --   no parameters
     *foo(void)       -- returning a pointer
    **foo(void)       -- to a pointer
int **foo(void);      -- to int

您將遞歸地將這些規則應用於任何 function 參數。 這是來自標准庫的signal function 的聲明：

void (*signal(int sig, void (*func)(int)))(int);

讀作

       signal                                    -- signal
       signal(                          )        -- is a function taking
       signal(    sig                   )        --   parameter sig
       signal(int sig                   )        --     is an int
       signal(int sig,        func      )        --   parameter func
       signal(int sig,       *func      )        --     is a pointer
       signal(int sig,      (*func)(   ))        --     to a function taking
       signal(int sig,      (*func)(int))        --       parameter unnamed is 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)))(   )  -- to a function taking
     (*signal(int sig, void (*func)(int)))(int)  --   unnamed parameter is an int
void (*signal(int sig, void (*func)(int)))(int); -- returning void

您還可以使用一些替代技巧。 如果您需要弄清楚如何聲明一個指向函數的指針數組，該數組返回指向其他函數的指針，返回指向指向int的指針的 arrays 的指針，請從T的數組開始：

T a[N];   // a is an array of T

這將是一個指向某物的指針數組，因此將T替換為指針類型P ：

P *a[N];  // a is an array of pointer to P

每個a[i]將是一個指向 function 的指針，因此將P替換為 function 類型F ：

F (*a[N])( );

這些函數中的每一個都返回一個指針，因此將F替換為另一個指針類型P ：

P *(*a[N])( );

這些指針中的每一個都指向另一個 function，所以

F (*(*a[N])( ))( );

這些函數返回指針，因此我們將F替換為另一個指針類型P ：

P *(*(*a[N])( ))( );

將P替換為數組類型A ：

A (*(*(*a[N])( ))( ))[M];

從這里我們可以直接跳到最后：

int *(*(*(*a[N])( ))( ))[M];