C/GCC 4.6.3 中的联合填充值

Question

我的代码初始化了 6 个结构体、2 个联合体，并使用 'dump' 函数显示为它们分配的字节的地址，以及这些字节中的值。

短代码：

#include <stdio.h>
// #DEFINE PD = padding

void dump (void *p, int n);

/* (...) */

union U1
{
    int i;
    char c[5];
};

/*  has 8 bytes of information, organized as follows:
    | i/c[0] | i/c[1] | i/c[2] | i/c[3] | PD/c[4] | PD | PD | PD |                                      */

union U2
{
    short s;
    char c[5];
};

/*  has 6 bytes of information, organized as follows:
    | s/c[0] | s/c[1] | PD/c[2] | PD/c[3] | PD/c[4] | PD |                                          */



int main (void)
{
    int i;

    union U1 u1;
    union U2 u2;

    /* (...) */

         u1.i = 0x01020304;      // initializes int
    printf("\nu1 (int)\n");
        dump(&u1, sizeof(u1));
        for (i=0;i<5;i++)        // initializes char
            u1.c[i] = 0xcc;
    printf("u1 (char)\n");
        dump(&u1, sizeof(u1));

        u2.s = 0x0102;           // initializes short
    printf("\nu2 (short)\n");
        dump(&u2, sizeof(u2));   
        for (i=0;i<5;i++)        // initializes char
            u2.c[i] = 0xcc;
    printf("u2 (char)\n");
        dump(&u2, sizeof(u2));

    return 0;
} 

从所有结构和第一个联合中，我得到了预期的字节数和值 - 所有填充字节为 00 - 但从最后一个联合中，我得到了这个：

u2 (short)
0x7fff825a05a0 - 02
0x7fff825a05a1 - 01
0x7fff825a05a2 - 5A
0x7fff825a05a3 - 82
0x7fff825a05a4 - FF
0x7fff825a05a5 - 7F
u2 (char)
0x7fff825a05a0 - CC
0x7fff825a05a1 - CC
0x7fff825a05a2 - CC
0x7fff825a05a3 - CC
0x7fff825a05a4 - CC
0x7fff825a05a5 - 7F

short 的中间 2 个字节的值是随机的 - 可能是随机内存，每次运行都会发生变化 - 而 short 的最后 2 个和 char 数组的最后一个是固定的。

为什么我会得到这个值？不应该所有的填充字节都是 0x00 吗？ 即使第一个联合也很顺利，从 int 更改为 short 的事实改变了什么？ 为什么用短变量初始化联合上的部分内存垃圾和部分固定值？

我想这是一个理论上的答案，如果是这样，你能引用参考吗？那太好了。

请先原谅我可能的巨型帖子，我在这里的第一个。 :)

完整代码：

#include <stdio.h>
// #DEFINE PD = padding

void dump (void *p, int n)
{
     unsigned char *p1 = p;

     while (n--)
     {
          printf("%p - %02X\n",p1, *p1);
          p1++;
     }
}

struct X1
{
    char c1;
    int i;
    char c2;
} x1 = {0xc1, 0x01020304, 0xc2};

/*  possui 12 bytes de informação, organizados em:
    | c1 | PD | PD | PD | i | i | i | i | c2 | PD | PD | PD |                                       */

struct X2
{
    int i;
    char c;
} x2 = {0x01020304, 0xc2};

/*  possui 8 bytes de informação, organizados em:
    | i | i | i | i | c | PD | PD | PD |                                                            */

struct X3
{
    int i;
    char c1;
    char c2;
} x3 = {0x01020304, 0xc1, 0xc2};

/*  possui 8 bytes de informação, organizados em:
    | i | i | i | i | c1 | c2 | PD | PD |                                                           */

struct X4
{
    struct X2 x;
    char c;
} x4 = {{0x01020304, 0xc1}, 0xc2};

/*  possui 8 bytes de informação, organizados em:
    | X2.i | X2.i | X2.i | X2.i | X2.c | PD | PD | PD | c | PD | PD | PD |                          */

struct X5
{
    char c1;
    char c2;
    char c3;
} x5 = {0xc1, 0xc2, 0xc3};

/*  possui 3 bytes de informação, organizados em:
    | c1 | c2 | c3 |                                                                            */

struct X6
{
    short s1;
    int i;
    char c[3];
    short s2;
} x6 = {0x0102, 0x01020304, {0xc1, 0xc2, 0xc3}, 0x0102};

/*  possui 16 bytes de informação, organizados em:
    | s1 | s1 | PD | PD | i | i | i | i | c[0] | c[1] | c[2] | PD | s2 | s2| PD | PD |              */


union U1
{
    int i;
    char c[5];
};

/*  possui 8 bytes de informação, organizados em:
    | i/c[0] | i/c[1] | i/c[2] | i/c[3] | PD/c[4] | PD | PD | PD |                                      */

union U2
{
    short s;
    char c[5];
};

/*  possui 8 bytes de informação, organizados em:
    | s/c[0] | s/c[1] | PD/c[2] | PD/c[3] | PD/c[4] | PD | PD | PD |                                            */



int main (void)
{
    int i;

    union U1 u1;
    union U2 u2;

    printf("\nx1: \n");
        dump(&x1, sizeof(x1));
    printf("\nx2: \n");
        dump(&x2, sizeof(x2));
    printf("\nx3: \n");
        dump(&x3, sizeof(x3));
    printf("\nx4: \n");
        dump(&x4, sizeof(x4));
    printf("\nx5: \n");
        dump(&x5, sizeof(x5));
    printf("\nx6: \n");
        dump(&x6, sizeof(x6));

         u1.i = 0x01020304;
    printf("\nu1 (int)\n");
        dump(&u1, sizeof(u1));
        for (i=0;i<5;i++)
            u1.c[i] = 0xcc;
    printf("u1 (char)\n");
        dump(&u1, sizeof(u1));

        u2.s = 0x0102;
    printf("\nu2 (short)\n");
        dump(&u2, sizeof(u2));
        for (i=0;i<5;i++)
            u2.c[i] = 0xcc;
    printf("u2 (char)\n");
        dump(&u2, sizeof(u2));

    return 0;
    }

完整输出：

x1: 
0x601030 - C1
0x601031 - 00
0x601032 - 00
0x601033 - 00
0x601034 - 04
0x601035 - 03
0x601036 - 02
0x601037 - 01
0x601038 - C2
0x601039 - 00
0x60103a - 00
0x60103b - 00

x2: 
0x60103c - 04
0x60103d - 03
0x60103e - 02
0x60103f - 01
0x601040 - C2
0x601041 - 00
0x601042 - 00
0x601043 - 00

x3: 
0x601044 - 04
0x601045 - 03
0x601046 - 02
0x601047 - 01
0x601048 - C1
0x601049 - C2
0x60104a - 00
0x60104b - 00

x4: 
0x60104c - 04
0x60104d - 03
0x60104e - 02
0x60104f - 01
0x601050 - C1
0x601051 - 00
0x601052 - 00
0x601053 - 00
0x601054 - C2
0x601055 - 00
0x601056 - 00
0x601057 - 00

x5: 
0x601058 - C1
0x601059 - C2
0x60105a - C3

x6: 
0x601060 - 02
0x601061 - 01
0x601062 - 00
0x601063 - 00
0x601064 - 04
0x601065 - 03
0x601066 - 02
0x601067 - 01
0x601068 - C1
0x601069 - C2
0x60106a - C3
0x60106b - 00
0x60106c - 02
0x60106d - 01
0x60106e - 00
0x60106f - 00

u1 (int)
0x7fff825a0590 - 04
0x7fff825a0591 - 03
0x7fff825a0592 - 02
0x7fff825a0593 - 01
0x7fff825a0594 - 00
0x7fff825a0595 - 00
0x7fff825a0596 - 00
0x7fff825a0597 - 00
u1 (char)
0x7fff825a0590 - CC
0x7fff825a0591 - CC
0x7fff825a0592 - CC
0x7fff825a0593 - CC
0x7fff825a0594 - CC
0x7fff825a0595 - 00
0x7fff825a0596 - 00
0x7fff825a0597 - 00

u2 (short)
0x7fff825a05a0 - 02
0x7fff825a05a1 - 01
0x7fff825a05a2 - 5A
0x7fff825a05a3 - 82
0x7fff825a05a4 - FF
0x7fff825a05a5 - 7F
u2 (char)
0x7fff825a05a0 - CC
0x7fff825a05a1 - CC
0x7fff825a05a2 - CC
0x7fff825a05a3 - CC
0x7fff825a05a4 - CC
0x7fff825a05a5 - 7F

Answer 1

您的联合在堆栈上，而不是全局的，在您开始使用它们之前，对它们的初始化没有任何期望。正式地，您永远不应该阅读您没有首先编写的联合或任何变量。

对于结构或自然使用结构的联合或没有结构的联合中的填充量或填充状态（如果有），确实没有有效的期望。

如果你让它们成为全局变量，那么它们从零开始会有一些合理的期望，但我个人并不认同这种期望，并尝试总是在我第一次阅读之前明确设置一个变量（写入） .一旦你开始弄乱联合中的项目，那么所有的赌注都不会影响什么。

编辑

您的联合是非静态局部变量，因此它们位于堆栈上，因此在您开始访问它们之前不需要 C 编译器进行初始化。

联合中项目的唯一有效用途是回读您写入的最近访问的路径。

所以

union U1 u1;
union U2 u2;

/* (...) */

     u1.i = 0x01020304;      // initializes int

所以这里唯一有效的用例是回读 u1.i。此时您不应该对任何 u1.c[] 值抱有任何期望。并且您不应该对联合使用的整个内存中的任何其他填充有任何期望。 C 编译器唯一需要确保的是，如果你设置了 u1.i，那么当你读回它时假设你没有使用 u1.c 修改联合，你会得到你写的东西。

    for (i=0;i<5;i++)        // initializes char
        u1.c[i] = 0xcc;

同样的答案，此时唯一有效的联合读取是 u1.c[] 项目，读取 u1.i 没有有效的期望。同样，转储整个联合可以有填充，这样字符串才有意义，并且类似项目 (u1.c[n]) 的回读就是你写的。

u2.s = 0x0102;           // initializes short

然后访问 u2.c[] 没有意义，也没有有效的期望。转储联合唯一的期望是联合中某处的两个连续字节是该架构的字节序中的 0x01 和 0x02。

for (i=0;i<5;i++)        // initializes char
u2.c[i] = 0xcc;

然后访问 u2.s 没有意义，也没有有效的期望。转储联合唯一的期望是联合中的某处是字节 0xcc、0xcd、0xce、0xcf、0xd0 以正确的顺序排列，在联合中的哪个位置以及填充的值你不应该有任何期望。

现在说我经常能够不正确地使用联合来处理浮点数，并且它往往（到目前为止总是）工作，但我知道代码可能有一天会停止工作由相同编译器的不同版本、不同编译器或具有不同编译选项的相同编译器编译。我希望它有一天会失败。

Answer 2

来自 C99 标准，6.2.6.1p7：

当一个值存储在结构或联合类型的对象中时， 包括在成员对象中，对象表示的字节 对应于任何填充字节的值采用未指定的值。

Answer 3

您的联合 u1 和 u2 是自动并存储在堆栈中。默认情况下，自动变量在 C 中被初始化为垃圾。您在转储中看到的是堆栈上的旧值，它们在调用 main() 之前就在那里。它们是半随机的，取决于 C 运行时库在调用 main() 之前所做的工作。

您的代码中的结构x1-x6 是不同的，它们是静态的，静态变量被 C 标准初始化为零。

函数内部定义的变量是自动的（除非声明为静态），但函数外部的变量只能是静态。为了使答案更完整，还有另一个存储类，堆或动态内存，可以使用 malloc()/free() 访问。在整个程序运行期间，只有静态变量在内存中具有固定位置，其他位置在相应函数返回或释放堆块时失去意义。 这些都是 C 程序中常见的错误来源。