这个问题是针对 C 专家的：
在 C 中，可以按照以下方式声明一个指针：
char (* p)[10];
这基本上表示该指针指向一个由10个字符组成的数组。使用这种方式声明指针的好处是，如果你试图将不同大小的数组指针分配给p，则会在编译时出错。它还会在您尝试将简单字符指针的值分配给p时导致编译时错误。我用gcc尝试过，并且似乎与ANSI、C89和C99兼容。
在我看来，像这样声明指针非常有用，特别是在传递指向函数的指针时。通常，人们会像这样编写这样一个函数的原型：
void foo(char * p, int plen);
如果您期望一个特定大小的缓冲区，那么您只需测试plen的值。但是，您无法保证将p传递给您的人确实会在该缓冲区中提供plen个有效的内存位置。您必须相信调用此函数的人正在做正确的事情。另一方面：
void foo(char (*p)[10]);
...将强制调用者提供指定大小的缓冲区。
这似乎非常有用，但我从来没有在我运行的任何代码中看到过像这样声明指针的方式。
我的问题是：为什么人们不这样声明指针？我是否忽略了一些显而易见的陷阱？
你在帖子中所说的是绝对正确的。我认为每个 C 开发者在达到一定的 C 语言熟练水平时都会做出完全相同的发现和结论。
当你的应用领域需要一个特定大小的数组（数组大小是编译时常量）时，传递这样的数组到函数中的唯一正确方式是使用指向数组的指针参数。
void foo(char (*p)[10]);
(在C++语言中，这也可以通过引用来实现)
void foo(char (&p)[10]);
这将启用语言级别的类型检查，确保作为参数提供了完全正确大小的数组。实际上，在许多情况下，人们会隐式地使用这种技术，甚至没有意识到将数组类型隐藏在typedef名称后面。
typedef int Vector3d[3];
void transform(Vector3d *vector);
/* equivalent to `void transform(int (*vector)[3])` */
...
Vector3d vec;
...
transform(&vec);
Vector3d 类型是数组还是 struct 无关。您可以随时从数组切换到 struct 的定义或者反过来，而不必更改函数声明。无论哪种情况，这些函数将通过引用接收聚合对象（在此讨论的上下文中，有一些例外情况，但这是真实的）。void foo(char p[], unsigned plen);
实际上，在许多情况下，能够处理运行时大小的数组非常有用，这也促进了该方法的流行。许多C开发人员根本没有遇到过（或从未意识到）需要处理固定大小数组的情况，因此对适当的固定大小技术一无所知。
然而，如果数组大小是固定的，那么将其作为元素的指针传递
void foo(char p[])
“指针数组”是一种常见的技术层面错误，但不幸的是这种错误目前比较普遍。在这种情况下，“指向数组的指针”技术是一个更好的选择。
导致固定大小数组传递技术难以被采用的另一个原因是，动态分配数组的简单类型化方法的占主导地位。例如，如果程序需要使用固定大小为char [10]的数组（就像你的例子中那样），普通开发人员会使用malloc来创建这样的数组。
char *p = malloc(10 * sizeof *p);
这个数组不能传递给声明为
void foo(char (*p)[10]);
这让普通开发人员感到困惑，并使他们在没有更深入思考的情况下放弃了固定大小参数声明。然而，实际上问题的根源在于幼稚的malloc方法。上面显示的malloc格式应该保留给运行时大小的数组。如果数组类型具有编译时大小，则更好的malloc方法如下所示。
char (*p)[10] = malloc(sizeof *p);
当然，这可以轻松地传递给上述声明的foo
foo(p);
编译器将执行适当的类型检查。但是，这对于没有经验的C开发人员来说过于复杂，这就是为什么您在“典型”的日常代码中很少看到它的原因。
const属性。
一个 const char (*p)[N] 参数似乎与 char table[N] 的指针不兼容;
相比之下，一个简单的 char* 指针仍然与 const char* 参数兼容。 - Cyan(*p)[i]而不是*p[i]。后者会跳过数组的大小，这几乎肯定不是你想要的。至少对于我来说，学习这种语法引起了错误，而不是预防它；只需传递一个float*指针就可以更快地得到正确的代码。 - Andrew Wagnerconst指针。
而且，这与指向不可变元素数组的指针完全不同。 - Cyang中调用g。你还没有测试任何东西。这里是一个真正的版本的测试：https://godbolt.org/z/doYhGnsxq - AnT stands with Russia我想在AndreyT的回答上补充一些内容（假设有人查找此主题时会进入这个页面）：
当我开始更多地使用这些声明时，我意识到在C语言中存在一个重大缺陷（显然C++中不存在）。在某些情况下，您可能希望为调用者提供指向您已写入的缓冲区的const指针。但是，在C语言中像这样声明指针是不可能的。换句话说，在C标准（6.7.3 - 第8段）与这种情况相冲突：
int array[9];
const int (* p2)[9] = &array; /* Not legal unless array is const as well */
在C++中似乎没有这种约束，因此这些类型的声明变得更加有用。但是，在C语言中，当您想要对固定大小的缓冲区使用const指针时（除非缓冲区本身已经被声明为const），必须回退到常规指针声明。您可以在此邮件线程中找到更多信息：链接文本
在我看来，这是一种严格的限制，这可能是人们通常不会在C语言中声明指针的主要原因之一。另一个原因是大多数人甚至不知道您可以像AndreyT所指出的那样声明指针。
我也希望使用这种语法来实现更多的类型检查。
但我也同意，使用指针的语法和思维模型更简单、更容易记忆。
以下是我遇到的一些障碍。
Accessing the array requires using (*p)[]:
void foo(char (*p)[10])
{
char c = (*p)[3];
(*p)[0] = 1;
}
It is tempting to use a local pointer-to-char instead:
void foo(char (*p)[10])
{
char *cp = (char *)p;
char c = cp[3];
cp[0] = 1;
}
But this would partially defeat the purpose of using the correct type.
One has to remember to use the address-of operator when assigning an array's address to a pointer-to-array:
char a[10];
char (*p)[10] = &a;
The address-of operator gets the address of the whole array in &a, with the correct type to assign it to p. Without the operator, a is automatically converted to the address of the first element of the array, same as in &a[0], which has a different type.
Since this automatic conversion is already taking place, I am always puzzled that the & is necessary. It is consistent with the use of & on variables of other types, but I have to remember that an array is special and that I need the & to get the correct type of address, even though the address value is the same.
One reason for my problem may be that I learned K&R C back in the 80s, which did not allow using the & operator on whole arrays yet (although some compilers ignored that or tolerated the syntax). Which, by the way, may be another reason why pointers-to-arrays have a hard time to get adopted: they only work properly since ANSI C, and the & operator limitation may have been another reason to deem them too awkward.
When typedef is not used to create a type for the pointer-to-array (in a common header file), then a global pointer-to-array needs a more complicated extern declaration to share it across files:
fileA:
char (*p)[10];
fileB:
extern char (*p)[10];
extern void foo(char (*p)[10]);
void bar() {
char p[10];
foo(p);
}
数组的默认升级为未限定指针。
还可以参见这个问题，使用foo(&p)应该可以工作。
foo(&p)。 - AnT stands with Russia简单来说，C语言不是这样做的。类型为T的数组被传递时，只会传递指向数组中第一个T的指针。
这种方式可以实现一些很酷、优雅的算法，例如使用表达式遍历数组：
*dst++ = *src++
缺点是大小的管理取决于您。不幸的是，没有认真对待这一点也导致了 C 代码中数百万个错误和/或恶意利用机会。
C 中最接近您所要求的方法是传递一个结构体（按值）或指向一个结构体的指针（按引用）。只要在此操作的两侧使用相同的结构体类型，分发引用的代码和使用它的代码都同意处理的数据的大小。
您的结构可以包含任何您想要的数据;它可以包含您定义好大小的数组。
尽管如此，没有什么能阻止您或不称职或恶意的程序员使用强制转换来欺骗编译器，以便将您的结构体视为不同大小的结构体之一。这种几乎无拘束的能力是 C 设计的一部分。
你可以以多种方式声明字符数组：
char p[10];
char* p = (char*)malloc(10 * sizeof(char));
以值传递数组的函数的原型是：
void foo(char* p); //cannot modify p
或者通过引用：
void foo(char** p); //can modify p, derefernce by *p[0] = 'f';
或者通过数组语法：
void foo(char p[]); //same as char*
char (*p)[10] = malloc(sizeof *p)。 - AnT stands with Russia我不建议使用这个解决方案
typedef int Vector3d[3];
这会掩盖Vector3D具有必须了解的类型的事实。程序员通常不希望具有相同类型的变量具有不同的大小。考虑：
void foo(Vector3d a) {
Vector3d b;
}
当a的大小不等于b的大小时
sizeof(a) 和 sizeof(b) 不一样呢？ - sherrellbcvoid foo(Vector3d *a)。 - Smiley1000void foo(char p[10], int plen); 吗？ type (*)[];
// points to an array e.g
int (*ptr)[5];
// points to an 5 integer array
// gets the address of the array
type *[];
// points to an array of pointers e.g
int* ptr[5]
// point to an array of five integer pointers
// point to 5 adresses.
char (*p)[10]视为字符指针的数组，就好像没有括号一样，即使我将其编译为C文件。编译器是否支持这种"变量"？如果是的话，那就是不使用它的一个主要原因。
10可以被作用域内的任何变量替换。 - M.M