这个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

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

Answer 3

先了解什么是挥发性：Why is volatile needed in C?

，然后尝试着自己找到答案。

这是一个易变和硬件世界的游戏。通过克里斯小丑，杨给出 :-)

阅读答案：

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

Answer 4

在你目前的代码，那么有没有办法，在您main定义，同时square运行被修改为变量a。

但是，考虑一个多线程程序。假设另一个线程修改了你的指针引用的值。并且假设此修改发生在您分配了a之后，但在分配b之前发生在功能sqaure中。

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 5

因为指针* ptr的值可能会在第一个情感和第二个情感之间改变。

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

由于问题具有可接受的正确答案，因此我将简要介绍一下：这里是一个简短的程序，您可以运行该程序查看自己发生的不正确行为。

#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 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; 
}