为什么C会有“假数组”？ [关闭]

Question

我正在阅读The Unix haters handbook，在第 9 章中有些东西我不太明白：

C 也没有真正的数组。它有一些看起来像数组的东西 但实际上是一个指向内存位置的指针。

除了使用指向索引内存位置的指针之外，我真的无法想象有任何方法可以将数组存储在内存中。无论如何，C 如何实现“假”数组？这种说法是否属实？

Answer 1

我认为作者的意思是，C 数组实际上只是指针运算的薄薄的一层。下标运算符被简单地定义为a[b] == *(a + b)，因此您可以轻松地使用5[a] 而不是a[5] 并执行其他可怕的操作，例如访问数组超过最后一个索引。

与此相比，“真正的数组”将是一个知道自己的大小、不允许您进行指针运算、访问最后一个索引而不会出错或使用不同的项类型访问其内容的数组。换句话说，“真正的数组”是一种严格的抽象，它不会将您束缚在单一的表示上——例如，它可以是一个链表。

PS。为了省点麻烦：我对此没有意见，我只是解释书中的引述。

Answer 2

C数组和指针是有区别的，从sizeof()表达式的输出可以看出。例如：

void sample1(const char * ptr)
{
   /* s1 depends on pointer size of architecture */
   size_t s1 = sizeof(ptr); 
}
size_t sample2(const char arr[])
{
   /* s2 also depends on pointer size of architecture, because arr decays to pointer */
   size_t s2 = sizeof(arr); 
   return s2;
}
void sample3(void)
{
   const char arr[3];
   /* s3 = 3 * sizeof(char) = 3 */
   size_t s2 = sizeof(arr); 
}
void sample4(void)
{
   const char arr[3];
   /* s4 = output of sample2(arr) which... depends on pointer size of architecture, because arr decays to pointer */
   size_t s4 = sample2(arr); 
}

sample2 和 sample4 可能是人们倾向于将 C 数组与 C 指针混为一谈的原因，因为在其他语言中，您可以简单地将数组作为参数传递给函数并让它“以同样的方式”工作就像在调用者函数中所做的那样。同样，由于 C 的工作方式，您可以传递指针而不是数组，这是“有效的”，而在其他语言中，数组和指针之间有更清晰的区别，则不会。

您还可以查看 sizeof() 输出作为 C 的按值传递语义的结果（因为 C 数组衰减为指针）。

另外，一些编译器也支持这种 C 语法：

void foo(const char arr[static 2])
{
   /* arr must be **at least** 2 elements in size, cannot pass NULL */
}

Answer 3

您引用的陈述实际上是不正确的。 C 中的数组不是指针。

在 B 和 BCPL 语言（C 的祖先）中使用了将数组实现为指针的想法，但它在向 C 的过渡中没有幸存下来。在 C 的早期，与 B 和 BCPL 的“向后兼容性”被认为有点很重要，这就是为什么 C 数组非常模仿 B 和 BCPL 数组的行为（即 C 数组很容易“衰减”为指针）。然而，C 数组并不是“指向内存位置的指针”。

这本书的引用完全是假的。这种误解在 C 新手中相当普遍。但它是如何进入一本书的却是我无法想象的。

Answer 4

作者可能的意思是，从程序员的角度来看，数组受到限制，使它们感觉像是二等公民。比如两个函数，一个可以，一个不行：

int finefunction() {
    int ret = 5;
    return ret;
}

int[] wtffunction() {
    int ret[1] = { 5 };
    return ret;
}

您可以通过将数组包装在结构中来解决这个问题，但这只是强调数组是不同的，它们与其他类型不同。

struct int1 {
    int a[1];
}

int[] finefunction2() {
    struct int1 ret = { { 5 } };
    return ret;
}

这样做的另一个影响是，您无法在运行时获取数组的大小：

int my_sizeof(int a[]) {
    int size = sizeof(a);
    return size;
}

int main() {
    int arr[5];
    // prints 20 4, not 20 20 as it would if arrays were 1st class things
    printf("%d %d\n", sizeof(arr), my_sizeof(arr)); 
}

作者所说的另一种表达方式是，在 C（和 C++）术语中，“数组”的含义与大多数其他语言不同。

---

那么，您的标题问题是，如何将“真正的数组”存储在内存中。好吧，没有一种单一的“真正的数组”。如果您想要 C 中的真正数组，您基本上有两种选择：

1. 使用 calloc 分配缓冲区，并在此处存储指针和项计数

   struct intarrayref {
     size_t count;
     int *data;
   }
   

   这个结构基本上是对数组的引用，你可以很好地将它传递给函数等。你需要编写函数来对其进行操作，例如创建实际数据的副本。

2. 使用flexible array member，并使用单个 calloc 分配整个结构

   struct intarrayobject {
       size_t count;
       int data[];
   }
   

在这种情况下，您可以一次性分配元数据 (count) 和数组数据空间，但代价是，您不能再将此结构作为值传递，因为那样会留下额外数据的背后。您必须将指向此结构的指针传递给函数等。因此，是否将其视为“真正的数组”或只是略微增强的普通 C 数组，这是一个意见问题。

Answer 5

就像整本书一样，这是一个拖钓案例，具体来说，这种拖钓类型涉及陈述几乎正确但错误的内容，以征求对其错误原因的愤怒回应。 C 肯定有实际的数组/数组类型，正如指向数组类型（和多维数组）的工作方式所证明的那样。