Question

我尝试声明两个变量，一个是类型int *，另一个是double *类型，并为每个变量分配了地址，但是通过去参考和打印进行分配会显示int的正确值但是打印0.0为double。为什么？

#include <stdio.h>

int main(void)
{
    int *x;
    x = (int *)&x;
    *x = 3;
    //print val of pointer
    printf("%d\n", x);

    double *y;
    y = (double *)&y;
    *y = 4.0;
    printf("%lf\n", y);
    return 0;
}

Answer 1

我得到4.0。

您所做的是将分配给存储地址（x和y）的内存分别重新解释为int和double。

这样做两次：将数据值分配给重新解释的内存时，以及打印它的副本时。这两个案例是截然不同的。

通过不兼容类型的指针写入内存是未定义的行为，并且像gcc这样的编译器在这种情况下会做有趣的事情（陷阱或忽略代码）。有关于此的蜿蜒讨论，包括Linus Torvalds的着名咆哮。它可能会也可能不会起作用。如果它有效，它可能会做预期的事情。（对于正确的代码，您必须使用union或执行memcpy。）

它的一个工作条件是您的数据类型不需要比指针更多的空间。在32位架构上（可能是64位Intel CPU的32位编译器），double将比4字节地址长（IEEE 754 double有8个字节）。 *y = 4.0;写入y的内存，覆盖堆栈上的其他数据。（请注意y指向自身，因此分配给*y会覆盖y自己的记忆。）
将指针值作为参数传递给printf，转换规范为%d。 %lf也未定义。（实际上，如果转换规范为%p并且指针值未转换为void *，则它已经未定义;但这常常被忽略并且与常见体系结构无关。）printf将只需将堆栈中的内存（这是参数的副本）解释为int resp。作为双人。

为了理解发生了什么，让我们看一下main堆栈上的内存布局。我写了一个详细介绍它的程序;来源如下。在我的64位Windows上，4.0的双倍值打印正常;指针变量y足够大以容纳double的字节，并且所有8个字节都被复制到printf的堆栈中。但是如果指针大小只有4个字节，则只有那4个字节将被复制到printf的堆栈，它们都是0，超出该堆栈的字节将包含来自先前操作的内存或任意值，例如0 ;-)，printf将读取以尝试解码双精度。

这是在各个步骤中对64位架构上的堆栈的检查。我用两个标记变量declStart和declEnd括起了指针声明，以便我可以看到内存的位置。我认为该程序也可以在32位架构上进行微小的更改。试试吧，告诉我们你看到了什么！

更新：它在ideone上运行，它似乎有4个字节的地址。双版本不打印0.0但是有些任意值，因为4个地址字节后面的堆栈垃圾。参看https://ideone.com/TJAXli

上面输出的程序在这里：

#include <stdio.h>

void dumpMem(void *start, int numBytes)
{
    printf("memory at %p:", start);
    char *p = start;
    while((unsigned long)p%8){ p--;  numBytes++;}   // align to 8 byte boundary
    for(int i=0; i<numBytes; i++) 
    {
        if( i%8 == 0 ) printf("\nAddr %p:", p+i);
        printf(" %02x", (unsigned int) (p[i] & 0xff));
    }
    putchar('\n');
}

int len;        // static allocation, protect them from stack overwrites
char *from, *to;

int main(void)
{
    unsigned int    declStart = 0xaaaaaaaa; // marker
    int             *x = (int *)   0xbbbbbbbbbbbbbbbb;
    double          *y = (double *)0xcccccccccccccccc;
    unsigned int    declEnd = 0xdddddddd;   // marker

    printf("Addr. of x: %p,\n      of y: %p\n", &x, &y);

    // This is all UB because the pointers are not
    // belonging to the same object. But it should
    // work on standard architectures.
    // All calls to dumpMem() therefore are UB, too.

    // Thinking of it, I'd be hard-pressed to find 
    // any defined behavior in this program.
    if( &declStart < &declEnd ) 
    {
        from = (char *)&declStart;
        to = (char *)&declEnd + sizeof(declEnd);
    }
    else
    {
        from = (char *)&declEnd;
        to = (char *)&declStart + sizeof(declStart);
    }
    len = to - from;

    printf("len is %d\n", len);
    printf("Memory after initializations:\n");
    dumpMem(from, len);

    x = (int *)&x;
    printf("\nMemory after assigning own address %p to x/*x: \n", &x);
    dumpMem(from, len);

    *x = 3;
    printf("\nMemory after assigning 3 to x/*x: \n");
    dumpMem(from, len);

    //print val of pointer
    printf("x as long: %d\n", (unsigned long)x);

    y = (double *)&y;
    *y = 4.0;
    printf("\nMemory after assigning 4.0 to y/*y: \n");
    dumpMem(from, len);

    printf("y as float: %f\n", y);
    printf("y as double: %lf\n", y);
    printf("y as unsigned int: 0x%x\n", y);
    printf("y as unsigned long: 0x%lx\n", y);

    return 0;
}

Answer 2

男孩，这是我最近看到的最奇怪的代码......

无论如何，如果你真的想弄清楚整个代码中发生了什么，那么最好的方法是使用调试器逐步完成它。以下是它在我的机器上的工作方式：

(gdb) break main
Breakpoint 1 at 0x400535: file test.c, line 6.
(gdb) run
...

Breakpoint 1, main () at test.c:6
warning: Source file is more recent than executable.
6           x = (int *)&x;
(gdb) n
7           *x = 3;
(gdb) p x
$1 = (int *) 0x7fffffffdab0
(gdb) n
9           printf("%d\n", x);
(gdb) p x
$2 = (int *) 0x7fff00000003
(gdb) n
3
12          y = (double *)&y;
(gdb) n
13          *y = 4.0;
(gdb) p y
$3 = (double *) 0x7fffffffdab8
(gdb) n
14          printf("%lf\n", y);
(gdb) p y
$4 = (double *) 0x4010000000000000
(gdb) n
0.000000
15          return 0;
(gdb)

基本上你正在做的是通过在过程中使用自己搞乱指针值。在执行*x = 3;时，您可以看到通过写入0x00000003来消除x的最低位32位。之后，执行*y = 4.0;时，用4.0的内部双重表示覆盖整个指针值。直观地说，第二个printf应该打印4.0，所以我猜问题本身就在printf内。如果你这样做：

double test;
memcpy(&test, &y, sizeof(double));
printf("%lf\n", test);

这将输出4.000000。

printf（）打印写入指针的正确int值，但不会写入写入另一个值的正确double值。这是为什么？

2 个答案: