int * array [32]是指向32个int的数组的指针，还是指向int的32个指针的数组？有关系吗？

If I write

如果我写

int *columns[32];

am I defining an array with 32 pointers to ints?
Or is it a pointer to an array of 32 ints?

我是否定义了一个包含32个指针的数组？或者它是一个指向32个int数组的指针？

How do I differentiate between the two? Is there a difference?

我如何区分这两者？有区别吗？

8 个解决方案

#1

When in doubt - ask cdecl

如有疑问 - 请询问cdecl

$> cdecl 
Type `help' or `?' for help
cdecl> explain int *columns[32]
declare columns as array 32 of pointer to int

EDIT In response to comments: I found cdecl source on Google Code Search. It requires GNU readline library. I think it shouldn't be a problem to compile it on Mac OS X or Windows.

编辑回复评论：我在Google Code Search上找到了cdecl源代码。它需要GNU readline库。我认为在Mac OS X或Windows上编译它应该不是问题。

#2

Expanding on a comment to another answer:

将评论扩展到另一个答案：

There's a fairly straightforward procedure for reading C declarations. Start with the leftmost identifier in the declarator and work your way out, remembering that [] and () bind before *. Given the declaration

读取C声明有一个相当简单的过程。从声明器中最左边的标识符开始，然后解决问题，记住*之前的[]和（）绑定。鉴于声明

int *columns[32];

break it down as

打破它

     columns                  -- columns
     columns[32]              -- is a 32-element array
    *columns[32]              -- of pointers
int *columns[32]              -- to int.

If the declaration had been

如果声明已经

int (*columns)[32];

then it would break down as

然后就会崩溃了

      columns                 -- columns
    (*columns)                -- is a pointer
    (*columns)[32]            -- to a 32-element array
int (*columns)[32]            -- of int.

This will also help you build up complex declarations. Suppose you wanted to declare an array of pointers to functions returning pointers to arrays of char:

这也将帮助您构建复杂的声明。假设您要声明一个指向函数的指针数组，这些函数返回指向char数组的指针：

          f                     -- f
          f[N]                  -- is an N-element array
         *f[N]                  -- of pointers
        (*f[N])()               -- to functions
       *(*f[N])()               -- returning pointers
      (*(*f[N])())[M]           -- to M-element arrays
     *(*(*f[N])())[M]           -- of pointers
char *(*(*f[N])())[M];          -- to char

cdecl is a nice tool, but after you'd done this exercise a few times, you shouldn't need it.

cdecl是一个很好的工具，但是在你完成这个练习几次后，你不应该需要它。

#3

You are defining an array of 32 pointers.

您正在定义一个包含32个指针的数组。

To define a pointer to an array of 32 ints you have to do

要定义一个指向32个int数组的指针，您必须这样做

int (*columns)[32];

The former declaration instantiates an array with space for 32 * sizeof(int). On the other hand, the latter instantiates a single uninitialized pointer which you can then use as follows:

前一个声明实例化一个空格为32 * sizeof（int）的数组。另一方面，后者实例化一个未初始化的指针，然后您可以按如下方式使用它：

int myintegers[32] = {0, 1, 2, ..., 31};
int (*columns)[32];

columns = &myintegers;

printf("%d\n", (*columns)[2]);

I hope I made the difference a little bit clear.

我希望我能有所改善。

#4

It is an array of 32 pointers to int and yes it does matter.

它是一个由32个指向int的数组，是的，它确实很重要。

The C grammar rules specify that array access ([]) binds tighter than dereference (*) and declarations mirror usage.

C语法规则指定数组访问（[]）比解除引用（*）和声明镜像使用更紧密。

The declaration int *columns[32]; means that the expression *columns[n] (where n is a number between 0 and 31) is an int. This expression is the same as *(columns[n]). The declaration allocates the space for 32 pointers, but there are no ints allocated and (assuming that this is a function local declaration) none of the pointers are initialized.

声明int * columns [32];表示* columns [n]（其中n是介于0和31之间的数字）的表达式是int。该表达式与*（columns [n]）相同。声明为32个指针分配空间，但没有分配整数和（假设这是一个函数本地声明）没有指针被初始化。

Had the declaration been int (*columns)[32]; then the expression (*columns)[n] would have been an int, meaning that the * dereference happens before the array access, so columns would have been a pointer to an array of 32 ints. The declaration would have allocated one pointer, but no arrays of ints.

如果声明是int（* columns）[32];然后表达式（* columns）[n]将是一个int，意味着* dereference在数组访问之前发生，因此列将是一个指向32个int的数组的指针。声明将分配一个指针，但没有整数数组。

#5

A test program is illustrative, especially to those of us who aren't language lawyers:

测试程序是说明性的，特别是对于我们这些非语言律师的人：

$ gcc -x c -
#include <stdio.h>

int main(void) 
{
    int *columns[32];
    printf("%lu\n%lu\n", sizeof(columns), sizeof(columns[0]));
    return 0;
}
$ ./a.out
128
4
$

It appears to be an array of pointers.

它似乎是一个指针数组。

#6

Here are some fun declarations for you:

以下是一些有趣的声明：

int *arrayOfIntP[32];
int (*pointerToArrayOf32)[32];

For more fun with multidimensional arrays look at these posts:

有关多维数组的更多乐趣，请查看以下帖子：

Array of pointers to multidimensional arrays

指向多维数组的指针数组

How do I declare a 2d array using new?

如何使用new声明二维数组？

#7

One trick is to read from right to left.

一个技巧是从右到左阅读。

Given int* cols[32];

给定int * cols [32];

You first see cols[32] : this is an array of size 32.
你首先看到cols [32]：这是一个大小为32的数组。
Next you see int*: this is a pointer
接下来你看到int *：这是一个指针

All that left of array is the type of the elements in the array. So we read it as array of pointers to int (and of count 32).

数组剩下的就是数组中元素的类型。所以我们把它读作指向int（和计数32）的指针数组。

#8

Refer to Question #5 of A 'C' Test: The 0x10 Best Questions for Would-be Embedded Programmers by Nigel Jones*

参考A'C'测试的问题＃5：Nigel Jones *将要成为嵌入式程序员的0x10最佳问题*

a) int a; // An integer

a）int a; //一个整数

b) int *a; // A pointer to an integer

b）int * a; //指向整数的指针

c) int **a; // A pointer to a pointer to an integer

c）int ** a; //指向整数的指针

d) int a[10]; // An array of 10 integers

d）int a [10]; //一个包含10个整数的数组

e) int *a[10]; // An array of 10 pointers to integers

e）int * a [10]; //一个包含10个整数指针的数组

f) int (*a)[10]; // A pointer to an array of 10 integers

f）int（* a）[10]; //指向10个整数数组的指针

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

g）int（* a）（int）; //一个指向函数a的指针，它接受一个整数参数并返回一个整数

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

h）int（* a [10]）（int）; //一个包含10个指向函数的数组，这些函数接受一个整数参数并返回一个整数

*Alas, the original article on embedded.com can no longer be found on their website.

*唉，在他们的网站上找不到embedded.com上的原始文章。

#1