C语言结构体里的成员数组和指针

淩亂°似流年 2023-08-17 16:23 99阅读 0赞

[https://coolshell.cn/articles/11377.html][https_coolshell.cn_articles_11377.html]

单看这文章的标题，你可能会觉得好像没什么意思。你先别下这个结论，相信这篇文章会对你理解C语言有帮助。这篇文章产生的背景是在微博上，看到[@Laruence][Laruence]同学出了一个关于C语言的题，[微博链接][Link 1]。微博截图如下。我觉得好多人对这段代码的理解还不够深入，所以写下了这篇文章。

[![zero\_array][zero_array]][Link 1]

为了方便你把代码copy过去编译和调试，我把代码列在下面：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> 
    <div>
      16 
    </div> 
    <div>
      17 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>#include &lt;stdio.h&gt;</code> 
     </div> 
     <div> 
      <code>struct</code> 
      <code>str{ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>len;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>s[0];</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>struct</code> 
      <code>foo { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>struct</code> 
      <code>str *a;</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>int</code> 
      <code>main(</code> 
      <code>int</code> 
      <code>argc, </code> 
      <code>char</code> 
      <code>** argv) { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>struct</code> 
      <code>foo f={0};</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>if</code> 
      <code>(f.a-&gt;s) { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>printf</code> 
      <code>( f.a-&gt;s);</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

你编译一下上面的代码，在VC++和GCC下都会在14行的printf处crash掉你的程序。[@Laruence][Laruence] 说这个是个经典的坑，我觉得这怎么会是经典的坑呢？上面这代码，你一定会问，为什么if语句判断的不是f.a？而是f.a里面的数组？写这样代码的人脑子里在想什么？还是用这样的代码来玩票？不管怎么样，看过原微博的回复，我个人觉得大家主要还是对C语言理解不深，如果这算坑的话，那么全都是坑。

接下来，你调试一下，或是你把14行的printf语句改成：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>printf</code> 
      <code>(</code> 
      <code>"%x\n"</code> 
      <code>, f.a-&gt;s);</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

你会看到程序不crash了。程序输出：4。 这下你知道了，访问0x4的内存地址，不crash才怪。于是，你一定会有如下的问题：

**1）为什么不是 13行if语句出错？f.a被初始化为空了嘛，用空指针访问成员变量为什么不crash？**

**2）为什么会访问到了0x4的地址？靠，4是怎么出来的？**

**3）代码中的第4行，char s\[0\] 是个什么东西？零长度的数组？为什么要这样玩？**

让我们从基础开始一点一点地来解释C语言中这些诡异的问题。

#### 结构体中的成员 ####

首先，我们需要知道——**所谓变量，其实是内存地址的一个抽像名字罢了**。在静态编译的程序中，所有的变量名都会在编译时被转成内存地址。机器是不知道我们取的名字的，只知道地址。

所以有了——栈内存区，堆内存区，静态内存区，常量内存区，我们代码中的所有变量都会被编译器预先放到这些内存区中。

有了上面这个基础，我们来看一下结构体中的成员的地址是什么？我们先简单化一下代码：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>struct</code> 
      <code>test{ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>i;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>*p;</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

上面代码中，test结构中i和p指针，在C的编译器中保存的是相对地址——也就是说，他们的地址是相对于struct test的实例的。如果我们有这样的代码：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>struct</code> 
      <code>test t;</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

我们用gdb跟进去，对于实例t，我们可以看到：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code># t实例中的p就是一个野指针</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p t</code> 
     </div> 
     <div> 
      <code>$1 = {i = 0, c = 0 </code> 
      <code>'\000'</code> 
      <code>, d = 0 </code> 
      <code>'\000'</code> 
      <code>, p = 0x4003e0 </code> 
      <code>"1\355I\211\..."</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code># 输出t的地址</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p &amp;t</code> 
     </div> 
     <div> 
      <code>$2 = (struct </code> 
      <code>test</code> 
      <code>*) 0x7fffffffe5f0</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>#输出(t.i)的地址</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p &amp;(t.i)</code> 
     </div> 
     <div> 
      <code>$3 = (char **) 0x7fffffffe5f0</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>#输出(t.p)的地址</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p &amp;(t.p)</code> 
     </div> 
     <div> 
      <code>$4 = (char **) 0x7fffffffe5f4</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

我们可以看到，t.i的地址和t的地址是一样的，t.p的址址相对于t的地址多了个4。说白了，**t.i 其实就是(&t + 0x0)**, **t.p 的其实就是 (&t + 0x4)**。0x0和0x4这个偏移地址就是成员i和p在编译时就被编译器给hard code了的地址。于是，你就知道，**不管结构体的实例是什么——访问其成员其实就是加成员的偏移量**。

下面我们来做个实验：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>struct</code> 
      <code>test{ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>i;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>short</code> 
      <code>c;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>*p;</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>int</code> 
      <code>main(){ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>struct</code> 
      <code>test *pt=NULL;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

编译后，我们用gdb调试一下，当初始化pt后，我们看看如下的调试：（我们可以看到就算是pt为NULL，访问其中的成员时，其实就是在访问相对于pt的内址）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p pt</code> 
     </div> 
     <div> 
      <code>$1 = (struct </code> 
      <code>test</code> 
      <code>*) 0x0</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p pt-&gt;i</code> 
     </div> 
     <div> 
      <code>Cannot access memory at address 0x0</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p pt-&gt;c</code> 
     </div> 
     <div> 
      <code>Cannot access memory at address 0x4</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p pt-&gt;p</code> 
     </div> 
     <div> 
      <code>Cannot access memory at address 0x8</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

注意：上面的pt->p的偏移之所以是0x8而不是0x6，是因为内存对齐了（我在64位系统上）。关于内存对齐，可参看《[深入理解C语言][C]》一文。

好了，现在你知道为什么原题中会访问到了0x4的地址了吧，因为是相对地址。

相对地址有很好多处，其可以玩出一些有意思的编程技巧，比如把C搞出面向对象式的感觉来，你可以参看我正好11年前的文章《[用C写面向对像的程序][C 1]》（用指针类型强转的危险玩法——相对于C++来说，C++编译器帮你管了继承和虚函数表，语义也清楚了很多）

#### 指针和数组的差别 ####

有了上面的基础后，你把源代码中的struct str结构体中的char s\[0\];改成char \*s;试试看，你会发现，在13行if条件的时候，程序因为Cannot access memory就直接挂掉了。为什么声明成char s\[0\]，程序会在14行挂掉，而声明成char \*s，程序会在13行挂掉呢？**那么char \*s 和 char s\[0\]有什么差别呢**？

在说明这个事之前，有必要看一下汇编代码，用GDB查看后发现：

*  对于char s\[0\]来说，汇编代码用了lea指令，lea 0x04(%rax), %rdx
 *  对于char\*s来说，汇编代码用了mov指令，mov 0x04(%rax), %rdx

lea全称load effective address，是把地址放进去，而mov则是把地址里的内容放进去。所以，就crash了。

从这里，我们可以看到，**访问成员数组名其实得到的是数组的相对地址，而访问成员指针其实是相对地址里的内容**（这和访问其它非指针或数组的变量是一样的）

换句话说，**对于数组 char s\[10\]来说，数组名 s 和 &s 都是一样的**（不信你可以自己写个程序试试）。在我们这个例子中，也就是说，都表示了偏移后的地址。这样，如果我们访问 指针的地址（或是成员变量的地址），那么也就不会让程序挂掉了。

正如下面的代码，可以运行一点也不会crash掉（你汇编一下你会看到用的都是lea指令）：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>struct</code> 
      <code>test{ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>i;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>short</code> 
      <code>c;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>*p;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>s[10];</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>int</code> 
      <code>main(){ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>struct</code> 
      <code>test *pt=NULL;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>printf</code> 
      <code>(</code> 
      <code>"&amp;s = %x\n"</code> 
      <code>, pt-&gt;s); </code> 
      <code>//等价于 printf("%x\n", &amp;(pt-&gt;s) );</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>printf</code> 
      <code>(</code> 
      <code>"&amp;i = %x\n"</code> 
      <code>, &amp;pt-&gt;i); </code> 
      <code>//因为操作符优先级，我没有写成&amp;(pt-&gt;i)</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>printf</code> 
      <code>(</code> 
      <code>"&amp;c = %x\n"</code> 
      <code>, &amp;pt-&gt;c);</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>printf</code> 
      <code>(</code> 
      <code>"&amp;p = %x\n"</code> 
      <code>, &amp;pt-&gt;p);</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

**看到这里，你觉得这能算坑吗？不要出什么事都去怪语言，大家要想想是不是问题出在自己身上。**

#### 关于零长度的数组 ####

首先，我们要知道，**0长度的数组在ISO C和C++的规格说明书中是不允许的**。这也就是为什么在VC++2012下编译你会得到一个警告：“arning C4200: 使用了非标准扩展 : 结构/联合中的零大小数组”。

那么为什么gcc可以通过而连一个警告都没有？那是因为gcc 为了预先支持C99的这种玩法，所以，让“零长度数组”这种玩法合法了。关于GCC对于这个事的文档在这里：“[Arrays of Length Zero][]”，文档中给了一个例子（我改了一下，改成可以运行的了）：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> 
    <div>
      16 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>#include &lt;stdlib.h&gt;</code> 
     </div> 
     <div> 
      <code>#include &lt;string.h&gt;</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>struct</code> 
      <code>line { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>length;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>contents[0]; </code> 
      <code>// C99的玩法是：char contents[]; 没有指定数组长度</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>int</code> 
      <code>main(){ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>this_length=10;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>struct</code> 
      <code>line *thisline = (</code> 
      <code>struct</code> 
      <code>line *)</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>malloc</code> 
      <code>(</code> 
      <code>sizeof</code> 
      <code>(</code> 
      <code>struct</code> 
      <code>line) + this_length);</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>thisline-&gt;length = this_length;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>memset</code> 
      <code>(thisline-&gt;contents, </code> 
      <code>'a'</code> 
      <code>, this_length);</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

上面这段代码的意思是：我想分配一个不定长的数组，于是我有一个结构体，其中有两个成员，一个是length，代表数组的长度，一个是contents，代码数组的内容。后面代码里的 this\_length（长度是10）代表是我想分配的数据的长度。（这看上去是不是像一个C++的类？）这种玩法英文叫：Flexible Array，中文翻译叫：柔性数组。

我们来用gdb看一下：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p thisline</code> 
     </div> 
     <div> 
      <code>$1 = (struct line *) 0x601010</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p *thisline</code> 
     </div> 
     <div> 
      <code>$2 = {length = 10, contents = 0x601010 </code> 
      <code>"\n"</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) p thisline-&gt;contents</code> 
     </div> 
     <div> 
      <code>$3 = 0x601014 </code> 
      <code>"aaaaaaaaaa"</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

我们可以看到：在输出\*thisline时，我们发现其中的成员变量contents的地址居然和thisline是一样的（偏移量为0x0??!!）。但是当我们输出thisline->contents的时候，你又发现contents的地址是被offset了0x4了的，内容也变成了10个‘a’。（我觉得这是一个GDB的bug，VC++的调试器就能很好的显示）

我们继续，如果你sizeof(char\[0\])或是 sizeof(int\[0\]) 之类的零长度数组，你会发现sizeof返回了0，这就是说，零长度的数组是存在于结构体内的，但是不占结构体的size。你可以简单的理解为一个没有内容的占位标识，直到我们给结构体分配了内存，这个占位标识才变成了一个有长度的数组。

看到这里，你会说，为什么要这样搞啊，把contents声明成一个指针，然后为它再分配一下内存不行么？就像下面一样。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>struct</code> 
      <code>line { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>length;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>*contents;</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>int</code> 
      <code>main(){ </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>this_length=10;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>struct</code> 
      <code>line *thisline = (</code> 
      <code>struct</code> 
      <code>line *)</code> 
      <code>malloc</code> 
      <code>(</code> 
      <code>sizeof</code> 
      <code>(</code> 
      <code>struct</code> 
      <code>line));</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>thisline-&gt;contents = (</code> 
      <code>char</code> 
      <code>*) </code> 
      <code>malloc</code> 
      <code>( </code> 
      <code>sizeof</code> 
      <code>(</code> 
      <code>char</code> 
      <code>) * this_length );</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>thisline-&gt;length = this_length;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>memset</code> 
      <code>(thisline-&gt;contents, </code> 
      <code>'a'</code> 
      <code>, this_length);</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

这不一样清楚吗？而且也没什么怪异难懂的东西。是的，这也是普遍的编程方式，代码是很清晰，也让人很容易理解。即然这样，那为什么要搞一个零长度的数组？有毛意义？！

这个事情出来的原因是——**我们想给一个结构体内的数据分配一个连续的内存！**这样做的意义有两个好处：

**第一个意义是，方便内存释放**。如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。（读到这里，你一定会觉得C++的封闭中的析构函数会让这事容易和干净很多）

**第二个原因是，这样有利于访问速度**。连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

我们来看看是怎么个连续的，用gdb的x命令来查看：(我们知道，用struct line \{\}中的那个char contents\[\]不占用结构体的内存，所以，struct line就只有一个int成员，4个字节，而我们还要为contents\[\]分配10个字节长度，所以，一共是14个字节)

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) x </code> 
      <code>/14b</code> 
      <code>thisline</code> 
     </div> 
     <div> 
      <code>0x601010:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 10&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97</code> 
     </div> 
     <div> 
      <code>0x601018:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

从上面的内存布局我们可以看到，前4个字节是 int length，后10个字节就是char contents\[\]。

如果用指针的话，会变成这个样子：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) x </code> 
      <code>/16b</code> 
      <code>thisline</code> 
     </div> 
     <div> 
      <code>0x601010:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0</code> 
     </div> 
     <div> 
      <code>0x601018:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 32&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 16&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 96&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0</code> 
     </div> 
     <div> 
      <code>(</code> 
      <code>gdb</code> 
      <code>) x </code> 
      <code>/10b</code> 
      <code>this-&gt;contents</code> 
     </div> 
     <div> 
      <code>0x601020:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97</code> 
     </div> 
     <div> 
      <code>0x601028:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 97</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

上面一共输出了四行内存，其中，

*  第一行前四个字节是 int length，第一行的后四个字节是对齐。
 *  第二行是char\* contents，64位系统指针8个长度，他的值是0x20 0x10 0x60 也就是0x601020。
 *  第三行和第四行是char\* contents指向的内容。

从这里，我们看到，**其中的差别——数组的原地就是内容，而指针的那里保存的是内容的地址**。

#### 后记 ####

好了，我的文章到这里就结束了。但是，请允许我再唠叨两句。

**1）看过这篇文章，你觉得C复杂吗？我觉得并不简单。某些地方的复杂程度不亚于C++。**

**2）那些学不好C++的人一定是连C都学不好的人。连C都没学好，你们根本没有资格鄙视C++。**

**3）当你们在说有坑的时候，你得问一下自己，是真有坑还是自己的学习能力上出了问题。**

如果你觉得你的C语言还不错，欢迎你看看《[C语言的谜题][C 2]》还有《[谁说C语言很简单？][C 3]》还有《[语言的歧义][Link 2]》以及《[深入理解C语言][C]》一文。

（全文完）

转载于:https://www.cnblogs.com/focus-z/p/11397340.html

[https_coolshell.cn_articles_11377.html]: https://coolshell.cn/articles/11377.html
[Laruence]: http://weibo.com/laruence
[Link 1]: /images/20230810/f7a3a8b4682742558a74bae8e0242181.png
[zero_array]: https://coolshell.cn/wp-content/uploads/2014/03/zero_array.png
[C]: https://coolshell.cn/articles/5761.html
[C 1]: http://blog.csdn.net/haoel/article/details/2864
[Arrays of Length Zero]: http://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html
[C 2]: https://coolshell.cn/articles/945.html
[C 3]: https://coolshell.cn/articles/873.html
[Link 2]: https://coolshell.cn/articles/830.html