意外的静态变量地址行为

Question

这是 C 代码快照：

int* f(int x) {
    static int y;
    y = x * x;
    return &y;
}

float* g(float x) {
    static float y;
    y = x * x;
    return &y;
}

int main(void) {
    printf("*f(1)=%d\n", *f(1));
    printf("*f(2)=%d\n", *f(2));
    printf("*f(1) + *f(2)=%d\n", *f(1) + *f(2));
    printf("*g(1.0)=%f\n", *g(1.0));
    printf("*g(2.0)=%f\n", *g(2.0));
    printf("*g(1.0) + *g(2.0)=%f\n", *g(1.0) + *g(2.0));
    return 0;
}

输出是：

*f(1)=1
*f(2)=4
*f(1) + *f(2)=5
*g(1.0)=1.000000
*g(2.0)=4.000000
*g(1.0) + *g(2.0)=8.000000

而且我并不真正理解 f() 和 g() 的双重行为。首先，我怀疑这是编译器问题，但 BCC 或 GCC 提供相同的输出。

*f(1) + *f(2) 的输出不应该等于*g(1.0) + g(2.0) 吗？ （55.0 或88.0）

Answer 1

我相信奥利是正确的。更明确地说，这将取决于在加法发生之前如何存储值。如果你执行*g(1.0)，那么*g(2.0)在存储值之前，你会添加4.0 + 4.0 = 8.0（记住，每个指针指向同一个静态变量的地址）。否则，如果您执行*g(1.0) 并将其值存储在寄存器中，然后执行*g(2.0) 并将结果相加，您将得到1.0 + 4.0 = 5.0。

所以，实际上，这取决于编译器如何将其写入机器代码。考虑以下伪 x86 程序集（为简单起见，我们使用 int 而不是 float）：

push 1 
call g ; First call to g(1);
add esp, 4 ; Pop value 1
mov ebx, eax ; Save our pointer
push 2
call g ; Call to g(2)
add esp, 4 ; Pop value 2 -- Remember that eax == ebx, now (they point to same address)
mov eax, [eax] ; Forget the pointer, store the value (4).
mov ebx, [ebx] ; Do the same thing, value is 4 since they point to same place
add eax, ebx   ; Add our two values. 4 + 4 = 8
ret

反过来，考虑以下

push 1 
call g ; First call to g(1);
add esp, 4 ; Pop value 1
mov ebx, [eax] ; Save the value at the pointer (1).
push 2
call g ; Call to g(2)
add esp, 4 ; Pop value 2 -- Remember that eax == ebx, now (they point to same address)
mov eax, [eax] ; Forget the pointer, store the value (4).
add eax, ebx   ; Add our two values. 4 + 1 = 5
ret

因此，当使用这样的共享变量而不显式存储其值时，指令的顺序真的很重要。通常，指令顺序将取决于编译器以及是否打开或关闭某些优化标志。此外，任何一个结果都可以被认为是一个合理的假设，没有硬语义来控制这一点，因为它没有真正违反标准（更多信息：请参阅下面的 Eric 回复）：它是取消引用每个函数的返回值并添加结果。因此，如果编译器优化重新排序事情的完成方式，这会导致意想不到的结果。