为什么C和C ++编译器从不强制执行函数签名中的数组长度？

这是我在学习期间发现的：

#include<iostream>
using namespace std;
int dis(char a[1])
{
    int length = strlen(a);
    char c = a[2];
    return length;
}
int main()
{
    char b[4] = "abc";
    int c = dis(b);
    cout << c;
    return 0;
}  

因此，在变量中int dis(char a[1])，[1]似乎无法执行任何操作，并且根本不起作用
，因为我可以使用a[2]。就像int a[]还是char *a。我知道数组名称是一个指针以及如何传达一个数组，所以我的难题与这部分无关。

我想知道的是为什么编译器允许这种行为（int a[1]）。还是还有我不知道的其他含义？

这是将数组传递给函数的语法的怪癖。

实际上，不可能在C中传递数组。如果编写的语法看起来像应该传递该数组，则实际发生的是改为传递了指向数组第一个元素的指针。

由于指针不包含任何长度信息，因此您[]在函数形式参数列表中的内容实际上将被忽略。

允许使用这种语法的决定是在1970年代做出的，此后就引起了很多混乱。

第一维的长度被忽略，但是其他尺寸的长度对于允许编译器正确计算偏移量是必需的。在下面的示例中，该foo函数被传递一个指向二维数组的指针。

#include <stdio.h>

void foo(int args[10][20])
{
    printf("%zd\n", sizeof(args[0]));
}

int main(int argc, char **argv)
{
    int a[2][20];
    foo(a);
    return 0;
}

第一维的大小将[10]被忽略；编译器不会阻止您从末尾开始编制索引（请注意，正式语句只需要10个元素，而实际只提供2个元素）。但是，第二维的大小[20]用于确定每一行的步幅，这里，形式必须与实际匹配。同样，编译器也不会阻止您索引第二维的结尾。

从数组基部到元素的字节偏移量由以下args[row][col]方式确定：

sizeof(int)*(col + 20*row)

请注意，如果为col >= 20，则实际上将索引到下一行（或整个数组的末尾）。

sizeof(args[0])，80在我的机器上返回sizeof(int) == 4。但是，如果尝试使用，则会sizeof(args)收到以下编译器警告：

foo.c:5:27: warning: sizeof on array function parameter will return size of 'int (*)[20]' instead of 'int [10][20]' [-Wsizeof-array-argument]
    printf("%zd\n", sizeof(args));
                          ^
foo.c:3:14: note: declared here
void foo(int args[10][20])
             ^
1 warning generated.

在这里，编译器警告说，它只会给出数组已衰减到的指针的大小，而不是数组本身的大小。

这个问题以及如何在C ++中克服

这个问题已经由pat和Matt广泛解释。编译器基本上是在忽略数组大小的第一维，实际上是在忽略传递的参数的大小。

另一方面，在C ++中，您可以通过两种方式轻松克服此限制：

• 使用参考
• 使用std::array（C ++ 11起）

参考资料

如果您的函数仅尝试读取或修改现有数组（而不是复制数组），则可以轻松使用引用。

例如，假设您想要一个函数来重置一个10 ints 数组，将每个元素设置为0。您可以使用以下函数签名轻松地做到这一点：

void reset(int (&array)[10]) { ... }

这不仅可以正常工作，还可以增强数组的维数。

您还可以使用模板使上述代码通用：

template<class Type, std::size_t N>
void reset(Type (&array)[N]) { ... }

最后，您可以利用const正确性。让我们考虑一个输出10个元素的数组的函数：

void show(const int (&array)[10]) { ... }

通过应用const限定符，我们防止了可能的修改。

数组的标准库类

如果您认为上述语法既丑陋又不必要，就像我一样，我们可以将其放在罐中并std::array改为使用（自C ++ 11起）。

这是重构的代码：

void reset(std::array<int, 10>& array) { ... }
void show(std::array<int, 10> const& array) { ... }

这不是很好吗？更不用说我之前教过的通用代码技巧仍然有效：

template<class Type, std::size_t N>
void reset(std::array<Type, N>& array) { ... }

template<class Type, std::size_t N>
void show(const std::array<Type, N>& array) { ... }

不仅如此，您还可以免费获得复制和移动语义。:)

void copy(std::array<Type, N> array) {
    // a copy of the original passed array 
    // is made and can be dealt with indipendently
    // from the original
}

那你还在等什么？去使用std::array。

这是C的一项有趣功能，如果您这样倾斜，就可以有效地用脚射击自己。

我认为原因是C只是汇编语言之上的一步。删除了大小检查和类似的安全功能，以实现最佳性能，如果程序员非常勤奋，这不是一件坏事。

同样，为函数参数分配大小有一个好处，就是当另一个程序员使用该函数时，他们有可能会注意到大小限制。仅使用指针不会将该信息传达给下一个程序员。

首先，C从不检查数组范围。无论它们是局部的，全局的，静态的，参数还是什么都没有关系。检查数组边界意味着更多的处理，并且C应该被认为非常有效，因此数组边界检查由程序员在需要时完成。

其次，有一个技巧可以将数组按值传递给函数。也可以从函数按值返回数组。您只需要使用struct创建一个新的数据类型。例如：

typedef struct {
  int a[10];
} myarray_t;

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

您必须访问以下元素：foo.a [1]。多余的“ .a”可能看起来很奇怪，但是这个技巧为C语言增加了强大的功能。

告诉编译器myArray指向至少10个整数的数组：

void bar(int myArray[static 10])

如果您访问myArray [10]，那么好的编译器应该给您警告。如果没有“ static”关键字，则10毫无意义。

这是C的众所周知的“功能”，因为C ++应该正确地编译C代码，所以传递给C ++。

问题来自多个方面：

1. 数组名称应该完全等同于指针。
2. C应该被认为是快速的，最初被开发为一种“高级汇编器”（特别是为了编写第一个“便携式操作系统”：Unix而设计），所以它不是应该插入“隐藏”代码。因此，“运行时范围检查”是“禁止的”。
3. 生成用于访问静态数组或动态数组（在堆栈中或已分配）的机器代码实际上是不同的。
4. 由于被调用函数无法知道作为参数传递的数组的“种类”，因此所有内容都应视为指针，并按原样对待。

您可能会说C并没有真正支持数组（就像我之前所说的那样，这不是真的，但这是一个很好的近似）。数组实际上被视为指向数据块的指针，并使用指针算法进行访问。由于C没有任何形式的RTTI，因此您必须在函数原型中声明数组元素的大小（以支持指针运算）。对于多维数组，这甚至更“真实”。

无论如何，以上不再是真的：p

大多数现代C / C ++编译器都支持边界检查，但是标准要求默认情况下将其关闭（以实现向后兼容）。例如，合理的最新版本的gcc会使用“ -O3 -Wall -Wextra”进行编译时范围检查，并使用“ -fbounds-checking”进行完整的运行时范围检查。

C不仅将类型的参数转换int[5]为*int；给定声明typedef int intArray5[5];，它将把类型的参数转换intArray5为*int为好。在某些情况下，这种行为虽然很奇怪，但还是很有用的（尤其是对于像中va_list定义的东西stdargs.h，某些实现将其定义为数组）。允许将定义为int[5]（忽略维）的类型作为参数但不允许int[5]直接指定类型是不合逻辑的。

我发现C对数组类型的参数的处理是荒谬的，但这是努力采用一种即席语言的结果，该语言中的大部分不是特别明确定义或深思熟虑，并试图提出行为与现有实现对现有程序所做的操作一致的规范。从这种角度来看，许多C的怪癖是有道理的，特别是如果人们认为当他们中的许多发明了时，我们今天所知道的语言的大部分还不存在。据我了解，在C的前身BCPL中，编译器并没有很好地跟踪变量类型。声明int arr[5];等同于int anonymousAllocation[5],*arr = anonymousAllocation;; 一旦分配被搁置。编译器既不知道也不在乎arr是指针或数组。当以arr[x]或方式访问时*arr，无论如何声明，它都将被视为指针。

尚未解决的一件事是实际问题。

已经给出的答案说明，数组不能通过值传递给C或C ++中的函数。他们还解释说，声明为的参数将int[]被视为具有type int *，而类型为变量int[]可以将传递给此类函数。

但是他们没有解释为什么从来没有出错以明确提供数组长度。

void f(int *); // makes perfect sense
void f(int []); // sort of makes sense
void f(int [10]); // makes no sense

为什么最后一个不是错误？

其原因是它导致typedef问题。

typedef int myarray[10];
void f(myarray array);

如果在函数参数中指定数组长度是错误的，则将无法在函数参数中使用myarray名称。并且由于某些实现将数组类型用于标准库类型，例如和va_list，并且所有实现都需要创建jmp_buf数组类型，因此，如果没有使用这些名称声明函数参数的标准方法，那就很成问题：没有这种能力，不是可移植的功能实现，如vprintf。

允许编译器检查传递的数组大小是否与预期的大小相同。如果不是这种情况，编译器可能会发出警告。