volatile 类型限定符

C 类型系统中每一个独立的类型在都有数个该类型的限定版本，对应 const 、 volatile 及限定对于指向对象指针的 restrict 限定符中的一个、两个或全部三个。此页面描述 volatile 限定符的效果。

每一个通过对 volatile 限定类型左值表达式的访问（读与写），对于优化意图都被认为是可观副效应，从而访问会严格按照抽象机的规则求值（即所有写入会在下一个序点之前的某时完成）。这表明在执行的单个线程内，volatile 访问不能被优化掉，亦不能与另一个被顺序点分隔了 volatile 访问的可观副效应重排。

一个非 volatile 值到 volatile 值的转换是无效果的。欲使用 volatile 语义访问非 volatile 对象，必须先将其地址转换成指向 volatile 类型的指针，再通过该指针访问该对象。

任何通过非 volatile 左值结果，对拥有 volatile 限定类型的对象尝试读或写会导致未定义行为：

volatile int n = 1; // volatile 限定类型
int* p = (int*)&n;
int val = *p; // 未定义行为

volatile 限定的结构体或联合体类型，其成员会获取其所属类型的限定（当通过 . 或 -> 运算符时）：

struct s { int i; const int ci; } s;
// s.i 类型是 int，s.ci 的类型是 const int
volatile struct s vs;
// vs.i 和 vs.ci 的类型各是 volatile int 和 const volatile int

若数组类型声明具有 volatile 类型限定符（通过使用 typedef），则数组类型本身不是 volatile 限定的，但其元素类型是 volatile 限定。若函数类型声明具有 volatile 类型限定（通过使用 typedef ），则行为未定义。

typedef int A[2][3];
volatile A a = {{4, 5, 6}, {7, 8, 9}}; // volatile int 的数组的数组
int* pi = a[0]; // 错误：a[0] 拥有 volatile int* 类型

void f(double x[volatile], const double y[volatile]);
void f(double * volatile x, const double * volatile y);

指向非 volatile 类型的指针可以隐式转换成指向同一或兼容类型的 volatile 限定版本的指针。逆向转换可以由类型转换表达式进行。

int* p = 0;
volatile int* vp = p; // OK：添加限定符（ int 到 volatile int）
p = vp; // 错误：丢弃限定符（ volatile int 到 int）
p = (int*)vp; // OK：类型转换

注意指向T的二重不可转换成指向volatile T的二重指针；对于要兼容的两个类型，它们的限定必须相同：

char *p = 0;
volatile char **vpp = &p; // 错误： char* 和 volatile char* 不是兼容类型
char * volatile *pvp = &p; // OK，添加限定符（ char* 到 char* volatile ）

volatile 的用法

volatile short *ttyport = (volatile short*)TTYPORT_ADDR;
for(int i = 0; i < N; ++i)
    *ttyport = a[i]; // *ttyport 是 volatile short 类型的左值

注意 volatile 变量不适合线程间交流；它们不提供原子性、同步或内存顺序。读取一个被另一线程未经同步地修改的 volatile 变量，或两个未同步的线程的共时修改，对于一些数据竞争是未定义行为。

关键词

volatile

示例

#include <stdio.h>
#include <time.h>
 
int main(void)
{
    clock_t t = clock();
    double d = 0.0;
    for (int n = 0; n < 10000; ++n)
        for (int m = 0; m < 10000; ++m)
            d += d * n * m; // 读写非 volatile 对象
    printf("Modified a non-volatile variable 100m times. "
           "Time used: %.2f seconds\n",
           (double)(clock() - t)/CLOCKS_PER_SEC);
 
    t = clock();
    volatile double vd = 0.0;
    for (int n = 0; n < 10000; ++n)
        for (int m = 0; m < 10000; ++m) {
            double prod = vd * n * m; // 读 volatile 对象
            vd += prod; // 读写 volatile 对象
        } 
    printf("Modified a volatile variable 100m times. "
           "Time used: %.2f seconds\n",
           (double)(clock() - t)/CLOCKS_PER_SEC);
}

Modified a non-volatile variable 100m times. Time used: 0.00 seconds
Modified a volatile variable 100m times. Time used: 0.79 seconds

引用