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

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

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

zero_array

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

#include <stdio.h>
struct str{
    int len;
    char s[0];
};

struct foo {
    struct str *a;
};

int main(int argc, char** argv) {
    struct foo f={0};
    if (f.a->s) {
        printf( f.a->s);
    }
    return 0;
}

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

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

printf("%x\n", f.a->s);

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

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

2)为什么会访问到了0x4的地址?靠,4是怎么出来的?

3)代码中的第4行,char s[0] 是个什么东西?零长度的数组?为什么要这样玩?

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

结构体中的成员

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

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

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

struct test{
    int i;
    char *p;
};

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

struct test t;

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

# t实例中的p就是一个野指针
(gdb) p t
$1 = {i = 0, c = 0 '\000', d = 0 '\000', p = 0x4003e0 "1\355I\211\..."}

# 输出t的地址
(gdb) p &t
$2 = (struct test *) 0x7fffffffe5f0

#输出(t.i)的地址
(gdb) p &(t.i)
$3 = (char **) 0x7fffffffe5f0

#输出(t.p)的地址
(gdb) p &(t.p)
$4 = (char **) 0x7fffffffe5f4

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

下面我们来做个实验:

struct test{
    int i;
    short c;
    char *p;
};

int main(){
    struct test *pt=NULL;
    return 0;
}

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

(gdb) p pt
$1 = (struct test *) 0x0
(gdb) p pt->i
Cannot access memory at address 0x0
(gdb) p pt->c
Cannot access memory at address 0x4
(gdb) p pt->p
Cannot access memory at address 0x8

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

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

相对地址有很好多处,其可以玩出一些有意思的编程技巧,比如把C搞出面向对象式的感觉来,你可以参看我正好11年前的文章《用C写面向对像的程序》(用指针类型强转的危险玩法——相对于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指令):

struct test{
    int i;
    short c;
    char *p;
    char s[10];
};

int main(){
    struct test *pt=NULL;
    printf("&s = %x\n", pt->s); //等价于 printf("%x\n", &(pt->s) );
    printf("&i = %x\n", &pt->i); //因为操作符优先级,我没有写成&(pt->i)
    printf("&c = %x\n", &pt->c);
    printf("&p = %x\n", &pt->p);
    return 0;
}

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

关于零长度的数组

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

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

#include <stdlib.h>
#include <string.h>

struct line {
   int length;
   char contents[0]; // C99的玩法是:char contents[]; 没有指定数组长度
};

int main(){
    int this_length=10;
    struct line *thisline = (struct line *)
                     malloc (sizeof (struct line) + this_length);
    thisline->length = this_length;
    memset(thisline->contents, 'a', this_length);
    return 0;
}

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

我们来用gdb看一下:

(gdb) p thisline
$1 = (struct line *) 0x601010

(gdb) p *thisline
$2 = {length = 10, contents = 0x601010 "\n"}

(gdb) p thisline->contents
$3 = 0x601014 "aaaaaaaaaa"

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

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

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

struct line {
   int length;
   char *contents;
};

int main(){
    int this_length=10;
    struct line *thisline = (struct line *)malloc (sizeof (struct line));
    thisline->contents = (char*) malloc( sizeof(char) * this_length );
    thisline->length = this_length;
    memset(thisline->contents, 'a', this_length);
    return 0;
}

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

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

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

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

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

(gdb) x /14b thisline
0x601010:       10      0       0       0       97      97      97      97
0x601018:       97      97      97      97      97      97

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

如果用指针的话,会变成这个样子:

(gdb) x /16b thisline
0x601010:       1       0       0       0       0       0       0       0
0x601018:       32      16      96      0       0       0       0       0
(gdb) x /10b this->contents
0x601020:       97      97      97      97      97      97      97      97
0x601028:       97      97

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

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

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

后记

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

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

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

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

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

(全文完)


关注CoolShell微信公众账号可以在手机端搜索文章

(转载本站文章请注明作者和出处 酷 壳 – CoolShell ,请勿用于任何商业用途)

——=== 访问 酷壳404页面 寻找遗失儿童。 ===——
好烂啊有点差凑合看看还不错很精彩 (61 人打了分,平均分: 4.80 )
Loading...

C语言结构体里的成员数组和指针》的相关评论

  1. “结构体中的成员”在人民邮电出版社的《C语言专家编程》中有过类似的介绍,这篇文章看下来更加有助于理解。

    “关于零长度的数组” 介绍的Flexible Array用法实际编码中用到过。是看日本人的代码学会的,第一次看到后觉得很扯,但后来想想后发现的确是挺方便的(至少不用去调两次free)。所以以后的编码中一直在使用。

    耗子的C语言功底的确是很厉害,这是真正见功夫的。不明白为什么现在很多人对C语言不感兴趣。

  2. 很敬业,不只是讲理论,还做了很多实验来验证。
    学习必须要理论结合实际才能来得影响深刻

  3. struct str{int i, char *s}, 指针变量s是一个变量,变量的内容是指针指向内容的地址,而访问指针时,(汇编)代码实际上做了一个操作,将所指向内容的首地址移入某个寄存器中,作为基址。《C专家编程》中探讨指针和数组的区别时,特别指出了这点。

    还有f.a->s是直接计算s的地址,再访问s;而不是(*(f.a)).s,这是指针的便捷之处,但也跳过了对f.a的检查。

  4. 感觉这篇文章写得很绕。还是直接查看标准文档来得方便直接。

    标准文档 6.3.2.1 里:除非作为 sizeof 和单目 & 的操作数,类型为「array of type」的表达式都会退化为「pointer to type」。

    因为表达式 f.a->s 是 array of char 类型的,所以会被转换为 pointer to char,即指向 s 的指针类型;也就是说,if (f.a->s) 判断的是 f.a->s 的地址。而因为 f.a 是 0,所以 f.a->s 是 4。

    其实就是指针退化。

  5. 我发现用clang/llvm 编译后会自动优化,我是按照两次malloc来进行的

    (lldb) x line
    0x1001039d0: 0a 00 00 00 00 00 00 00 e0 39 10 00 01 00 00 00 ……..�9……
    0x1001039e0: 61 61 61 61 61 61 61 61 61 61 00 00 00 00 00 00 aaaaaaaaaa……
    (lldb) x line->contents
    0x1001039e0: 61 61 61 61 61 61 61 61 61 61 00 00 00 00 00 00 aaaaaaaaaa……
    0x1001039f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….

  6. C11的标准对->运算符的语义是这样定义的:“A postfix expression followed by the -> operator and an identifier designates a member of a structure or union object. The value is that of the named member of the object to which the first expression points, and is an lvalue.” 但是,并没有说如果x本身是非法指针的情况下会有什么后果。我理解为,这个是“未定行为”。既然是“未定行为”,那么发生任何事情都是有可能的,比如编译器编译出让屏幕上打印出“FUCK YOU\n”的程序,也是“正确”的编译器行为。

    另一方面,C11倒是明确说了*运算符用于非法指针的情况:“If an invalid value has been assigned to the pointer, the behavior of the unary * operator is undefined.”其中invalid pointer包括null指针.

    参考:6.5.2.3和6.5.3.2两节
    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

  7. 其实C语言之所以复杂,就是因为一些模棱两可的写法或者说不同的写法有相同的语义。个人感觉如果是C语言中遇到了问题,不妨从汇编角度分析(反汇编的结果)。

  8. Fangzhen :
    顶一个。
    对于使用0地址访问结构体成员的使用方式之前还是遇到过的:
    #define OFFSET(type, f) ((int)&(((type*)0)->f))
    还是第一次遇到0长度数组的情况,涨姿势啦

    可以试试stddef.h里的offsetof宏。这个是真的做你认为它应该做的事的工具。对于某些编译器(如gcc),这是用intrinsic来实现的。Wikipedia说这是ANSI C定义的,我没有论证过,但起码C11是规定了这个宏的行为的。

  9. c比c++好的地方是:简洁明了,所以坑少
    但是,这个例子,其实是c的坑,而不是大家学得不够
    坑是歧义,如果要靠汇编代码来解释、理解,其实就已经是坑了!
    好(没坑)的语言,应该语法说怎么做,就真的是怎么做,步骤也是明确的,而不应该是 不同编译器有不同的实现
    社会学里:民众是 法无禁止 皆可为;政府是 法无允许 皆不可为。
    编程语言,也应该:语法没规定的,皆不可为。
    如果都能这样,c的很多怪异写法、技巧就直接是编译报错了。
    比如那个switch的怪异技巧。

    1)为什么不是 13行if语句【if (f.a->s) 】出错?f.a被初始化为空了嘛,用空指针访问成员变量为什么不crash?
    不能说疑问者水平不够,而是编译器没按语言规定的步骤执行了,看汇编代码来解释,也只说明这个编译器是这样做,但是仍然是违反了语言自己规定步骤。

  10. 耗叔真没道理,上次也说C++坑比C少啥的,这次一大群人都傻逼了还需要你再写文章解释,仍然说不是坑!
    我是C/C++经验很足,但如果我在review别人的代码中看到这样的写法,是会仔细想想才会说不会crash…
    如果每个现象能解释得通就不叫坑,那么有什么语言特性是翻出生成的汇编码、翻出解释器源码后解释不通的吗?
    我认为这样容易让人迷惑的特性就叫坑!而这种需要专家C程序员来公开解惑的特性就叫坑!
    当然,就这个用法而言,如果不算坑,只能说太少有人会这样写,而不是说它不够反直觉!

    最后你解释这么做的优点:
    “第二个原因是,这样有利于访问速度。连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)”

    那个括号有问题,寻址是不一样的。

    struct中嵌变长数组,与指针相比:
    1. 主要优点,只需要一次内存分配,struct的其他字段与访问数组是在连续内存上,spatial locality更好。至于说malloc、free的次数,因为是同时分配、释放,封装过后在易用性上没区别。
    2. 另外一个影响不大的性能优势,访存次数。给你struct的指针p,访问p->a[i],只需要一次访存,从”p+offset a + i * sizeof(a[0])”处取sizeof(a[0])个字节就是;而如果a是指针的话,需要两次访存,先从”p + offset a”处取4/8个字节得到地址q,再从”q + i * sizeof(a[0])”处取sizeof(a[0])个字节得到元素值。这既是说,如果改用指针的话,哪怕恰好指针指向的内存紧跟在struct后,内存连续,但p->a[i]的指针声明仍然会比数组声明多一次访存。
    3. 当然struct后缀变长数组的方法也有限制,即struct需要多个长度不同的变长数组时,只有一个能作为后缀,分配多块内存变得不可避免。

  11. switch的怪异技巧:
    http://coolshell.cn/articles/10975.html#more-10975
    case 1居然位于case 0里面的一个for语句块里!简直是“乱伦”了

    int function(void) {
      static int i, state = 0;
      switch (state) {
        case 0: /* start of function */
        for (i = 0; i < 10; i++) {
          state = 1; /* so we will come back to "case 1" */
          return i;
          case 1:; /* resume control straight after the return */
        }
      }
    }
  12. haitao :
    c比c++好的地方是:简洁明了,所以坑少
    但是,这个例子,其实是c的坑,而不是大家学得不够
    坑是歧义,如果要靠汇编代码来解释、理解,其实就已经是坑了!
    好(没坑)的语言,应该语法说怎么做,就真的是怎么做,步骤也是明确的,而不应该是 不同编译器有不同的实现
    社会学里:民众是 法无禁止 皆可为;政府是 法无允许 皆不可为。
    编程语言,也应该:语法没规定的,皆不可为。
    如果都能这样,c的很多怪异写法、技巧就直接是编译报错了。
    比如那个switch的怪异技巧。
    1)为什么不是 13行if语句【if (f.a->s) 】出错?f.a被初始化为空了嘛,用空指针访问成员变量为什么不crash?
    不能说疑问者水平不够,而是编译器没按语言规定的步骤执行了,看汇编代码来解释,也只说明这个编译器是这样做,但是仍然是违反了语言自己规定步骤。

    赞。

    另一方面理解,编程语言的“标准”就是程序员和编译器之间的“契约”。按照标准写的程序,符合标准的编译器必须生成符合标准的目标码。但是,如果程序员写出了标准里没有规定的程序,那么,他就等于超出了契约的规定范围,编译器如何处理都是编译器的自由(比如打印”FUCK YOU\n”)。

  13. @wks
    一般而言,设计语言、开发编译器的人,比使用编译器的人要牛。
    所以,他的语法、标准应该是足够严谨的,最后一条总是:不符合以上规则,均属于错误代码。
    如上面的switch例子,如果严格核对switch该有的模式,编译器首先就报错了:
    switch (表达式) { 重复【case 常量: 无或代码块;】 },那么case 1出现在case 0的代码块里,就应该被认为case 0的代码块里有一个switch,但是漏掉了switch直接出现case了
    编译时就把关卡住,绝对好过 编译通过,但行为无法预期,运行了n久才遇到满足逻辑分支才发生。

    揣测一下这些 非预期 代码 为什么会被编译器通过?
    编译器为了方便实现、编译速度,而放弃了严格的语法模式的匹配?

  14. printf(“%x\n”, f.a->s); // 没 (unsigned int) 直接 UB

    所以有了——栈内存区,堆内存区,静态内存区,常量内存区,我们代码中的所有变量都会被编译器预先放到这些内存区中。 // 寄存器是不是“内存”?

    换句话说,对于数组 char s[10]来说,数组名 s 和 &s 都是一样的(不信你可以自己写个程序试试)。 // 还特意加粗了,这是找抽么。

    第一个意义是,方便内存释放。 // 无视语义了么?

    第二个原因是,这样有利于访问速度。 // 结论是对的,解释是错的。倒腾下 cache 试试看?

  15. @haitao

    haitao :
    @wks
    一般而言,设计语言、开发编译器的人,比使用编译器的人要牛。
    所以,他的语法、标准应该是足够严谨的,最后一条总是:不符合以上规则,均属于错误代码。
    如上面的switch例子,如果严格核对switch该有的模式,编译器首先就报错了:
    switch (表达式) { 重复【case 常量: 无或代码块;】 },那么case 1出现在case 0的代码块里,就应该被认为case 0的代码块里有一个switch,但是漏掉了switch直接出现case了
    编译时就把关卡住,绝对好过 编译通过,但行为无法预期,运行了n久才遇到满足逻辑分支才发生。
    揣测一下这些 非预期 代码 为什么会被编译器通过?
    编译器为了方便实现、编译速度,而放弃了严格的语法模式的匹配?

    至于为什么会有“未定行为”并且让它编译通过,很多未定行为是运行时的,编译时一般检查不出来。比如对空指针访问,数组越界……如果将这些情况规定为“未定行为”,可以使得运行时的检查量降低,使得“正确”的代码执行更快。

    比如,数组越界,某些语言里数组越界必须抛出异常。这样的语言,一般要对每次数组访问判断一下越界(庆幸的是对于现代的计算机,这样的判断代价并不高),或者在能够推断出“肯定不会越界”的情况下将这样的判断消除。

    在另一些语言里,数组越界是未定行为。这样,编译器永远不用加入对数组越界的判断。如果程序员的算法能够保证自己的访问永远不越界,那么写出来的程序就是正确的而且高效。反之要是程序员不能保证,那么要么自己每次检查一下,要么就期待编译器能干出任何事(比如打印”FUCK YOU!\n”)。

    另外,switch语句的语法不是你想像的那样有若干个case或default。C11是这样定义的:

    selection-statement:
    if ( expression ) statement
    if ( expression ) statement else statement switch ( expression ) statement
    switch ( expression ) statement

    statement:
    labeled-statement
    compound-statement
    expression-statement
    selection-statement
    iteration-statement
    jump-statement

    labeled-statement:
    identifier : statement
    case constant-expression : statement
    default : statement

    compound-statement:
    { block-item-listopt }

    block-item-list:
    block-item
    block-item-list block-item

    block-item:
    declaration
    statement

    说明里面只是一个statement,而statement可以是compound-statement(也就是{ stmt1 stmt2 stmt3 …}),而里面的每个stmt都可以是任何语句。其中case xxx:、default:以及some_label:全都属于label-statement。所以,从语法上,那种到处插入case的switch并没有错误。

    switch的语义:

    A switch statement causes control to jump to, into, or past the statement that is the switch body, depending on the value of a controlling expression, and on the presence of a defaultlabelandthevaluesofanycaselabelsonorintheswitchbody. Acaseor default label is accessible only within the closest enclosing switch statement.

    既然是jump,那么就和goto有异曲同工之妙了。所以switch可以用得和goto一样肮脏。

  16. @haitao
    净扯淡。
    有谁告诉你数组和指针是一样的了。

    用asm只是为了很明确的告诉你这俩不一样且给你举个例子而已。

  17. guoshun :
    按struct str{
    int len;
    char s[0];
    }的定义,s在大尾序的机器上偏移量会不会是0×0呢?

    你想多了,这是俩概念。单一变量才有这个说法,struct是复合变量。

  18. 貌似Java这些什么都看不到吧 – – @KiingCode
    PS:今天就收货了这篇“唠叨”,希望博主以后继续“唠叨” – –
    PPS:建议添加个针对每篇文章生成二维码的功能

  19. 文中说到访问数组名是访问该数组的地址,我写了一段代码
    char test[] = “hello”;
    printf(“%x”, test);//输出地址
    printf(“%s”, test);//输出“hello”
    printf(test);//输出“hello”
    第一个输出能理解,但是后面两个是为什么呀?

  20. :

    guoshun :
    按struct str{
    int len;
    char s[0];
    }的定义,s在大尾序的机器上偏移量会不会是0×0呢?

    你想多了,这是俩概念。单一变量才有这个说法,struct是复合变量。

  21. @Jeff

    这也部分解释了为什么linux必须用gcc编译(clang通过努力也可以编译linux了,哎,一个编译器反过来适应一个程序……)

  22. @Jeff
    GCC扩展了C语言,规定了零长度数组。 http://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

    但clang有意地不提供这项扩展。“clang does not support the gcc extension that allows variable-length arrays in structures. This is for a few reasons: one, it is tricky to implement, two, the extension is completely undocumented, and three, the extension appears to be rarely used. Note that clang does support flexible array members (arrays with a zero or unspecified size at the end of a structure).”见:http://clang.llvm.org/docs/UsersManual.html

    另一方面,可以发现,Lua不用修改地就可以在另一个操作系统上跑。Lua的作者是一个很严谨的C程序员。为了兼容性,宁可使用3个int的结构表示Value,也不愿意使用高效的tagged pointer,因为ansi C没有“和指针一样长的整数”类型。这一点可以找找Lua作者的论文。 下面这一页说Lua可以直接在这个新操作系统上编译:https://github.com/klange/toaruos

  23. 皓哥,你说char *s 和 char s[0] 的区别在于

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

    可是我用GDB调试汇编代码是这样的?就没有看见lea指令?求指教?
    char s[0] 的汇编:
    0x000000000040150f : callq 0x4026d0
    0x0000000000401514 : movq $0x0,-0x10(%rbp)
    0x000000000040151c : mov -0x10(%rbp),%rax
    0x0000000000401520 : add $0x4,%rax
    0x0000000000401524 : test %rax,%rax
    0x0000000000401527 : je 0x401539
    char * s的汇编:
    0x000000000040150f : callq 0x4026d0
    0x0000000000401514 : movq $0x0,-0x10(%rbp)
    0x000000000040151c : mov -0x10(%rbp),%rax
    => 0x0000000000401520 : mov 0x8(%rax),%rax
    0x0000000000401524 : test %rax,%rax
    0x0000000000401527 : je 0x401539
    0x0000000000401529 : mov -0x10(%rbp),%rax
    0x000000000040152d : mov 0x8(%rax),%rax

  24. 看完鸟哥@Laruence的回应,确实觉得这篇文章啰嗦了,皓哥还是该冷静冷静,对事不对人吧

  25. 俺又来冒个泡,觉得这事搞复杂了。
    if (f.a->s) 不会crash,是因为s是一个数组类型,仅仅取了个地址,没有取这个地址里的了内容。
    如果将它改成 if (*(f.a->s)),它也会crash。同样如果将 if (f.a->s)改成 if (f.a->len)也会crash,因为len是int变量,这样是取值,不是取地址,将它改成 if (&(f.a->len)),也不会crash。
    对于printf,第一个参数类型是const char *,正常情况下,期望传入的是格式化字符串,然后去解析这个格式化字符串,遇到非格式化字符直接输出,遇到格式化字符,就根据格式化类型,去读取相应变量的值或者地址。而printf(f.a->s); 这样用,printf就把f.a->s当做格式化字符串去解析,这里也不会报错,因为s是char []类型,满足,printf函数第一个参数的要求。f.a->s的值为4,所以printf就去读这个地址值里的内容,也就crash了。将它改为printf(“%x”,f.a->s);
    不会crash,因为现在格式化字符串是%x,这个%x是存在某个地址处,内容是%x,是合法的,而%x解析出来,又是取地址,所以就去栈里相应的地方取变量的地址值。而将它改为printf(“%s”,f.a->s); 同样也会crash,但是这两个chash的原因是有区别的,前者是将f.a->s当做格式化字符串去解析,去读不合法格式化字符地址里的内容crash,而后者是格式化字符串地址是合法的,去读相应的变量地址里的内容的时候,crash了。
    printf本身是有缺陷的:
    对于 char *ptr=”Hello\n”;
    printf(ptr);
    char arr[]=”hello world\n”;
    printf(arr);
    都没有问题,它将传递给它的字符串,当做格式化字符串去解析,没有遇到格式字符就将内容直接输出。但是如果
    char arr[]=”hello world %s \n”;
    printf(arr);
    那它先输出hello world,然后就在栈里不合理的地址处去读内容值了,这个地址处放的是什么,没人知道,也许它会让你的程序crash掉。
    在代码里尽量不要使用printf,更不要像printf(arr);这种不合理的使用。printf不仅低效,而且因为自己的缺陷,给有恶意的人制造了机会。他们可以修改printf格式化字符串里的内容,让它去执行任何一个地址处的恶意程序,最简单的就是提升系统权限,在机器上想干什么就干什么。
    另外,使用柔性数组,主要是提高访问速度,结构里的柔性数组,分配的空间,和结构里的其它变量空间是连续的。
    用指针,分配的空间,基本上和其它变量的空间是不连续的。CPU读取数据的时候,是按照行读取的,也就是每次从内存里读取cache line大小的数据,然后放在缓存里。比如这里,如果CPU读取len的时候,顺便将数组s的内容一起读到cache line里,当cpu需要s的内容的时候,不许要再去读内存,甚至是硬盘。因为len和s的内存空间是连续的,所以,它们被放到一个cache line的可能性特别大,如果s的内容被顺便读进去,那访问速度比从内存里访问高出一到两个数量级。从代码本身来说,微观角度,高效代码遵守两个原则,1、空间连续性,2、时间连续性。

  26. 个人意见, 其实zero-array最大的目的在于空间节约,因为你不需要多使用一个指针作间接索引,不要小看这一个pointer,如果你系统里面很多地方都需要挂接类似的数据结构,那么它的空间节约也是很明显的,至于side-effect,那就是牺牲了使用指针的灵活性—如果你需要扩充你的数组空间,你唯一能做的就是两个a) realloc b) malloc new and free old.
    第一个看系统,不是每一次realloc都能成功,第二个问题在于如果你原始的数据指针被其他地方引用(比如hash),那么你就必须de-reference,更新所有对原来的地址引用–这个cost也是需要考虑的.但是你直接采用指针,虽然付出了8个字节,但是获得了更多空间重置的灵活性—-在这一点上来看,每一次间接引用(指针)都会带来更多的灵活性,代价是开销.

  27. @neo
    同意。
    其实也不需要反汇编。
    具体到这个例子,用纸和笔模拟一下变量在内存中对应位置的值就可以了。

  28. @lgf2002
    赞!!!!!!!!!!!!!
    char p[0],和char *p的区别,看了你的回复才看明白。
    如果是char *p的话,if(f.a->s)是到0x04这个地址中取指针值,所以会崩溃的。
    而char p[0]的话,就直接取0+4为返回值了。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*