为什么数组不能作为函数参数传递？

Question

为什么不能将数组作为函数参数传递？

我一直在阅读这本 C++ 书，上面说“你不能将数组作为函数参数传递”，但它从未解释过原因。此外，当我在网上查找时，我发现了类似“你为什么要这样做？”之类的 cmets。不是我会做，我只是想知道你为什么做不到。

Answer 1

为什么不能将数组作为函数参数传递？

他们可以：

void foo(const int (&myArray)[5]) {
   // `myArray` is the original array of five integers
}

用技术术语来说，foo 的参数类型是“引用数组 5 constints”；通过引用，我们可以在 周围传递 实际 对象（免责声明：术语因抽象级别而异）。

你不能做的是按值传递，因为由于历史原因我们不会复制数组。相反，尝试将数组按值传递给函数（或者，传递数组的副本）会导致其名称衰减为指针。 (some resources get this wrong!)

---

数组名称衰减为按值传递的指针

这意味着：

void foo(int* ptr);

int ar[10]; // an array
foo(ar);    // automatically passing ptr to first element of ar (i.e. &ar[0])

还有一种极具误导性的“语法糖”，看起来就像您可以按值传递任意长度的数组：

void foo(int ptr[]);

int ar[10]; // an array
foo(ar);

但是，实际上，您仍然只是传递一个指针（指向ar 的第一个元素）。 foo 和上面一样！

虽然我们正在这样做，但以下函数也实际上并没有它看起来的签名。看看当我们尝试调用这个函数而不定义它时会发生什么：

void foo(int ar[5]);
int main() {
   int ar[5];
   foo(ar);
}

// error: undefined reference to `func(int*)'

所以foo 实际上是int*，不是 int[5]！

(Live demo.)

---

但你可以解决它！

You can hack around this 通过将数组包装在struct 或class 中，因为默认的复制运算符将复制数组：

struct Array_by_val
{
  int my_array[10];
};

void func (Array_by_val x) {}

int main() {
   Array_by_val x;
   func(x);
}

这有点令人困惑。

---

或者，更好的是通用的传递引用方法

在 C++ 中，通过一些模板魔法，我们可以使函数既可重用又能够接收数组：

template <typename T, size_t N>
void foo(const T (&myArray)[N]) {
   // `myArray` is the original array of N Ts
}

但是我们仍然不能通过值传递一个。需要记住的东西。

---

未来……

由于 C++11 刚刚出现，并且 C++0x 支持在主流工具链中得到很好的支持，您可以使用继承自 Boost 的可爱的std::array！我将把研究留给读者作为练习。

Answer 2

所以我看到答案解释，“为什么编译器不允许我这样做？”而不是“是什么导致标准指定这种行为？”答案就在 C 的历史中。本文摘自 Dennis Ritchie 的“The Development of the C Language”（source）。

在原始 C 语言中，内存被划分为“单元”，每个单元包含一个单词。这些可以使用最终的一元 * 运算符取消引用——是的，这些本质上是无类型语言，就像今天的一些玩具语言，如 Brainf_ck。语法糖允许人们假装一个指针是一个数组：

a[5]; // equivalent to *(a + 5)

然后，添加了自动分配：

auto a[10]; // allocate 10 cells, assign pointer to a
            // note that we are still typeless
a += 1;     // remember that a is a pointer

在某些时候，auto 存储说明符行为成为默认行为——您可能还想知道 auto 关键字的意义到底是什么，就是这样。由于这些增量更改，指针和数组的行为方式有些古怪。如果语言是从鸟瞰的角度设计的，那么这些类型的行为可能会更加相似。就目前而言，这只是 C/C++ 的另一个问题。

Answer 3

数组在某种意义上是二等类型，C++ 继承自 C。

在the C99 standard 中引用 6.3.2.1p3：

除非它是 sizeof 运算符的操作数或一元 & 运算符，或者是用于初始化数组的字符串文字， 类型为“type 的数组”的表达式被转换为 类型为“pointer to type”的表达式，指向初始 数组对象的元素并且不是左值。如果数组对象 有注册存储类，行为未定义。

C11 standard 中的相同段落基本相同，只是添加了新的_Alignof 运算符。 （两个链接都指向非常接近官方标准的草案。（更新：这实际上是 N1570 草案中的一个错误，已在已发布的 C11 标准中更正。_Alignof 无法应用到一个表达式，只到一个带括号的类型名称，所以 C11 只有与 C99 和 C90 相同的 3 个例外。（但我离题了。）））

我手边没有相应的 C++ 引用，但我相信它非常相似。

所以如果arr 是一个数组对象，并且你调用了一个函数func(arr)，那么func 将收到一个指向arr 的第一个元素的指针。

到目前为止，这或多或少是“它是这样工作的，因为它是这样定义的”，但它有历史和技术原因。

允许数组参数不会带来太大的灵活性（无需进一步更改语言），因为例如，char[5] 和 char[6] 是不同的类型。即使通过引用传递数组也无济于事（除非我缺少一些 C++ 功能，否则总是有可能的）。传递指针给了你极大的灵活性（也许太多了！）。指针可以指向任意大小数组的第一个元素——但您必须使用自己的机制来告诉函数数组有多大。

设计一种语言以使不同长度的数组在某种程度上兼容但仍然不同实际上是相当棘手的。例如，在 Ada 中，char[5] 和 char[6] 的等价物是相同的类型，但不同的子类型。更多动态语言使长度成为数组对象值的一部分，而不是其类型。 C 仍然与显式指针和长度，或指针和终止符一起混淆。 C++ 继承了 C 的所有包袱。它主要关注整个数组并引入向量，因此没有太多需要将数组设为一等类型。

TL;DR：这是 C++，无论如何你都应该使用向量！ （嗯，有时。）

Answer 4

数组不是按值传递的，因为数组本质上是连续的内存块。如果您有一个想要按值传递的数组，您可以在一个结构中声明它，然后通过该结构访问它。

这本身会对性能产生影响，因为这意味着您将在堆栈上锁定更多空间。传递指针更快，因为要复制到堆栈的数据包络要少得多。

Answer 5

我相信 C++ 这样做的原因是，当它被创建时，它可能占用了太多资源来发送整个数组而不是内存中的地址。这只是我对此事的想法和假设。

Answer 6

这是由于技术原因。参数在堆栈上传递；数组可以有很大的大小，兆字节等等。在每次调用时将数据复制到堆栈不仅会更慢，而且会很快耗尽堆栈。

您可以通过将数组放入结构体（或使用 Boost::Array）来克服该限制：

struct Array
{
    int data[512*1024];
    int& operator[](int i) { return data[i]; }
};
void foo(Array byValueArray) { .......... }

尝试对该函数进行嵌套调用，看看会发生多少堆栈溢出！