这段C代码有什么问题

Question

我有一段代码试图返回 *ptr 指向的值的平方。

int square(volatile int *ptr)
{
  int a,b;
  a = *ptr;
  b = *ptr;
  return a * b;
}

  main()
  {
    int a=8,t;
    t=square(&a);
    printf("%d",t);
  }

它对我来说工作正常，但此代码的作者表示由于以下原因它可能无法工作：
由于 *ptr 的值可能会意外更改，因此 a 和 b 也可能不同。因此，此代码可能返回一个不是正方形的数字！。正确的做法是

long square(volatile int *ptr)
{
  int a;
  a = *ptr;
  return a * a;
}

我真的很想知道他为什么这么说？

Answer 1

volatile 关键字的目的正是向编译器指示标记为此类的变量在程序执行期间可能会以意想不到的方式发生变化。

然而，这并不使它成为“随机数”的来源 - 它只是建议编译器 - 负责实际更改变量内容的应该是另一个进程、线程、一些硬件中断 - 任何会写入进程内存的东西，但未内联到 易失性声明所在的函数中。在“旧时代”（魔法较少的编译器），它所做的一切都是阻止编译器将变量值缓存在 CPU 寄存器之一中。我不知道现代编译器触发的优化/去优化策略 - 但它至少会做到这一点。

在没有任何此类外部因素的情况下，“易失性”变量就像任何其他变量一样。实际上，它就像任何其他变量一样，因为未标记为 volatile 的变量也可以通过相同的外部原因进行更改（但在这种情况下，编译的 C 代码不会为此做好准备，这可能会导致使用不正确的值） 。

Answer 2

由于这个问题有一个被接受和正确的答案，我将简短地说：这是一个简短的程序，您可以运行它来查看自己发生的不正确行为。

#include <pthread.h>
#include <math.h>
#include <stdio.h>

int square(volatile int *p) {
    int a = *p;
    int b = *p;
    return a*b;
}

volatile int done;

void* call_square(void* ptr) {
    int *p = (int*)ptr;
    int i = 0;
    while (++i != 2000000000) {
        int res = square(p);
        int root = sqrt(res);
        if (root*root != res) {
            printf("square() returned %d after %d successful calls\n", res, i);
            break;
        }
    }
    done = 1;
}

int main() {
    pthread_t thread;
    int num = 0, i = 0;
    done = 0;
    int ret = pthread_create(&thread, NULL, call_square, (void*)&num);
    while (!done) {
        num = i++;
        i %= 100;
    }
    return 0;
}

main() 函数生成一个线程，并在一个循环中修改正在平方的数据，同时另一个循环使用易失性指针调用 square。相对而言，它并不经常失败，但在不到一秒的时间内就非常可靠地失败了：

square() returned 1353 after 5705 successful calls <<== 1353 = 33*41
square() returned 340 after 314 successful calls   <<== 340 = 17*20
square() returned 1023 after 5566 successful calls <<== 1023 = 31*33

Answer 3

首先了解什么是易失性：为什么 C 中需要易失性？

，然后尝试自己去寻找答案。

这是一个不稳定的硬件世界的游戏。 :-)

阅读 Chris Jester-Young 给出的答案：

易失性告诉编译器您的变量可以通过其他方式更改，而不是访问它的代码。例如，它可以是 I/O 映射的内存位置。如果在这种情况下没有指定，则可以优化某些变量访问，例如，可以将其内容保存在寄存器中，并且不会再次读回内存位置。

Answer 4

如果有多个线程，则指针指向的值可能会在语句“a = *ptr”和语句“b = *ptr”之间发生变化。另外：你想要一个值的平方，为什么要把它放入两个变量中？

Answer 5

在您提供的代码中，在 square 运行时，无法修改 main 中定义的变量 a 。

然而，考虑一个多线程程序。假设另一个线程修改了指针引用的值。并假设此修改发生在您在函数 sqaure 中分配 a 之后、分配 b 之前。

int square(volatile int *ptr)
{
  int a,b;
  a = *ptr;
  //the other thread writes to *ptr now
  b = *ptr;
  return a * b;
}

在这种情况下，a 和 b 将具有不同的值。

Answer 6

作者是正确的（如果*ptr会被其他线程改变）

int square(volatile int *ptr)
{
  int a,b;
  a = *ptr; 
  //between this two assignments *ptr can change. So it is dangerous to do so. His way is safer
  b = *ptr;
  return a * b;
}

Answer 7

因为指针 *ptr 的值可能会在第一个影响和第二个影响之间发生变化。

Answer 8

我认为除非出现极其不寻常（且不符合标准）的运行时环境，否则 *ptr 的值不会在这段代码中发生变化。

我们在这里查看整个 main() ，它没有启动其他线程。我们正在获取其地址的变量 a 是 main() 中的本地变量，并且 main() 不会通知任何其他函数该变量的地址。

如果您在 t=square(&a) 行之前添加了 mysterious_external_function(&a); 行，那么是的，mysterious_external_function 可以启动一个线程并异步调用 a 变量。但没有这样的行，所以编写的 square() 总是返回一个正方形。

（顺便问一下，OP 是一个巨魔帖子吗？）

Answer 9

我看到一些带有 *ptr 的答案可以被其他线程更改。但这不可能发生，因为 *ptr 不是静态数据变量。它是一个参数变量，局部变量和参数变量保存在堆栈内。每个线程都有自己的堆栈部分，如果 *ptr 已被另一个线程更改，则它不应影响当前线程的堆栈部分。

结果可能不给出平方的原因之一可能是在分配 b = *ptr; 之前可能发生硬件中断。操作如下：

int square(volatile int *ptr) {
    int a,b;
    a = *ptr; //assuming a is being kept inside CPU registers.

    //an HW interrupt might occur here and change the value inside the register which keeps the value of integer "a"

    b = *ptr;
    return a * b;
}