“char (*p)[5];”是什么意思？

Question

我试图掌握这三个声明之间的差异：

char p[5];
char *p[5];
char (*p)[5];

我试图通过做一些测试来找出这一点，因为到目前为止，每份阅读声明和类似内容的指南都没有帮助我。我写了这个小程序，但它不起作用（我尝试了第三个声明的其他类型的使用，但我已经没有选择了）：

#include <stdio.h>                                                              
#include <string.h>                                                             
#include <stdlib.h>                                                             
                                                                                
int main(void) {                                                                
        char p1[5];                                                             
        char *p2[5];                                                            
        char (*p3)[5];                                                          
                                                                                
        strcpy(p1, "dead");                                                     
                                                                                
        p2[0] = (char *) malloc(5 * sizeof(char));                              
        strcpy(p2[0], "beef");                                                  
                                                                                
        p3[0] = (char *) malloc(5 * sizeof(char));                              
        strcpy(p3[0], "char");                                                  
                                                                                
        printf("p1 = %s\np2[0] = %s\np3[0] = %s\n", p1, p2[0], p3[0]);          
                                                                                
        return 0;                                                               
}

第一个和第二个工作正常，我已经理解了它们的作用。第三个声明的含义是什么以及正确的使用方法？

谢谢你！

Answer 1

第三个是一个指向 5 个字符的数组的指针，而第二个是一个包含 5 个字符的指针的数组。

想象一下这样的情况：

________          _____________________
|0x7777| -------> | H | e | l | l | o |
|______|          |_0_|_1_|_2_|_3_|_4_|
    p             ^
                  |
                  0x7777  

而第二个看起来像这样：

   "abc"  "def"  "ghi"  "jkl"  "mno"
    ^      ^      ^      ^      ^
    |      |      |      |      |
____________________________________
|0x9999|0x7777|0x3333|0x2222|0x6666|
|___0__|___1__|___2__|___3__|___4__|
                  p

这是理解指针和数组之间的差异至关重要的情况之一。数组是一个对象，其大小是其每个元素的大小乘以计数，而指针只是一个地址。

在第二种情况下，sizeof(p) 将产生 5 * the_size_of_a_pointer。

在第三种情况下，sizeof(p) 将产生 the_size_of_a_pointer，通常为 4 或 8，具体取决于目标机器。

Answer 2

它是一个指向字符数组的指针。 C 常见问题解答中对此进行了解释。以后，当你不理解某个声明时，请使用 cdecl 或 <代码>cdecl(1)。

Answer 3

char p[5];      // p is a 5-element array of char
char *p[5];     // p is a 5-element array of pointer to char
char (*p)[5];   // p is a pointer to a 5-element array of char

C 声明语法是围绕表达式的类型构建的，而不是对象。这个想法是声明的形式与代码中出现的表达式的形式相匹配。

在上面的例子中，我们处理的是数组。在第一种情况下，p 是一个 char 数组；要访问特定字符值，我们只需对数组进行索引：

val = p[i];

表达式 p[i] 的类型是 char，因此声明 p< /code> 是 char p[5]。

在下一个例子中，p 是一个指向 char 的指针数组；为了访问该值，我们对数组进行索引并取消引用结果：

val = *p[i];

像 [] 这样的后缀运算符比像 * 这样的一元运算符具有更高的优先级，因此上面的内容被解析为

val = *(p[i]);

表达式*p[i]的类型是char，因此p的声明是char *p[5]< /代码>。

在最后一种情况下，p 是一个指向 char 数组的指针，因此要访问 char 值，我们必须取消引用该数组指针，然后将下标放入结果中：

val = (*p)[i];

因为 [] 的优先级高于一元 *，我们必须使用括号将 * 与 p 显式分组（而不是 p[我]）。同样，表达式 (*p)[i] 的类型为 char，因此 p 的声明为 char (* p)[5]。

编辑

指向数组的指针出现在以下上下文中：

1. 您显式获取 N 维数组的地址：

   int x[10] ;
   int (*px)[10] = &x;
   

   请注意，虽然表达式 x 和 &x 产生相同的值（第一个元素的地址）数组），它们具有不同的类型（int * 与 int (*)[10]）。

2. 您正在动态分配数组类型对象：

   int (*px)[10] = malloc(sizeof *px);
   

3. N 维数组表达式“衰减”为指向 (N-1) 维数组的指针：

   int x[10][20];
   foo(x);
   ...
   无效 foo(int (*px)[20]){...}
   

Answer 4

char (*p3)[5];

实际上声明了一个指向 5 个字符数组的指针。这意味着它应该指向一个指向 5 个字符数组的指针。它不会分配任何 5 个字符，而只是分配一个指针，并且它应该指向指向 5 个 char 的内容。

因此，正确的用法是：

#include <stdio.h>                                                              
#include <string.h>                                                             
#include <stdlib.h>                                                             

int main(void) {                                                                
        char p1[5];                                                             
        char *p2[5];                                                            
        char (*p3)[5];                                                          

        strcpy(p1, "dead");                                                     

        p2[0] = (char *) malloc(5 * sizeof(char));                              
        strcpy(p2[0], "beef");                                                  

        p3 = &p1;                                                               

        printf("p1 = %s\np2[0] = %s\np3 = %s\n", p1, p2[0], *p3);               

        return 0;                                                               
}

例如，如果您想使用 p3 来访问 p1 字符串的单个位置，则必须执行 (*p3)[2] 。它将进入第三个位置。这是因为您首先必须将 p3 转换为 p1（在进行位置算术之前 (*p3) 取消引用），然后访问该地址的第三个位置（由取消引用的指针指向）。