为嵌入式开发，我有一个循环，检查可以在中断处理程序中更改的变量。如果没有“volatile”，循环就变成了noop——就编译器所知，变量永远不会改变，所以它优化了检查。

同样的事情也适用于在更传统的环境中可能在不同线程中更改的变量，但在那里我们经常进行同步调用，因此编译器在优化方面没有那么自由。

我想引用Herb Sutter在GotW #95中的一句话，这有助于理解volatile变量的含义:

C++ volatile variables (which have no analog in languages like C# and Java) are always beyond the scope of this and any other article about the memory model and synchronization. That’s because C++ volatile variables aren’t about threads or communication at all and don’t interact with those things. Rather, a C++ volatile variable should be viewed as portal into a different universe beyond the language — a memory location that by definition does not obey the language’s memory model because that memory location is accessed by hardware (e.g., written to by a daughter card), have more than one address, or is otherwise “strange” and beyond the language. So C++ volatile variables are universally an exception to every guideline about synchronization because are always inherently “racy” and unsynchronizable using the normal tools (mutexes, atomics, etc.) and more generally exist outside all normal of the language and compiler including that they generally cannot be optimized by the compiler (because the compiler isn’t allowed to know their semantics; a volatile int vi; may not behave anything like a normal int, and you can’t even assume that code like vi = 5; int read_back = vi; is guaranteed to result in read_back == 5, or that code like int i = vi; int j = vi; that reads vi twice will result in i == j which will not be true if vi is a hardware counter for example).

你的程序似乎工作，即使没有挥发关键字?也许这就是原因:

如前所述，volatile关键字有助于以下情况

volatile int* p = ...;  // point to some memory
while( *p!=0 ) {}  // loop until the memory becomes zero

但是，一旦调用外部函数或非内联函数，似乎几乎没有任何影响。例如:

while( *p!=0 ) { g(); }

然后无论是否使用volatile都会产生几乎相同的结果。

只要g()可以完全内联，编译器就可以看到正在发生的一切，因此可以进行优化。但是，当程序调用一个编译器看不到发生什么的地方时，编译器再做任何假设就不安全了。因此，编译器生成的代码总是直接从内存中读取。

但是要注意，当函数g()变成内联(由于显式更改或由于编译器/链接器的聪明)时，如果您忘记volatile关键字，那么您的代码可能会崩溃!

因此，我建议添加volatile关键字，即使您的程序似乎没有它也可以工作。它使意图在未来的变化方面更加清晰和强大。

如果你正在从内存中的某个点(比如说，一个完全独立的进程/设备/任何东西)读取数据，则需要使用Volatile。

我曾经在纯c的多处理器系统中使用双端口ram。我们使用硬件管理的16位值作为信号量，以知道另一个家伙什么时候完成。基本上我们是这样做的:

void waitForSemaphore()
{
   volatile uint16_t* semPtr = WELL_KNOWN_SEM_ADDR;/*well known address to my semaphore*/
   while ((*semPtr) != IS_OK_FOR_ME_TO_PROCEED);
}

没有volatile，优化器认为循环是无用的(这家伙从不设置值!他疯了，删掉那代码吧!)，我的代码会在没有获得信号量的情况下继续运行，从而在以后造成问题。

除了按预期使用它，volatile还用于(模板)元编程。它可以用来防止意外重载，因为volatile属性(如const)参与了重载解析。

template <typename T> 
class Foo {
  std::enable_if_t<sizeof(T)==4, void> f(T& t) 
  { std::cout << 1 << t; }
  void f(T volatile& t) 
  { std::cout << 2 << const_cast<T&>(t); }

  void bar() { T t; f(t); }
};

这是合法的;这两个重载都可能是可调用的，并且执行几乎相同的操作。在volatile重载中的强制转换是合法的，因为我们知道bar无论如何都不会通过一个非volatile T。不过，volatile版本严格来说更糟糕，所以如果非volatile f可用，则永远不要在重载分辨率中选择。

注意，代码实际上从不依赖于volatile内存访问。

在开发嵌入式系统或设备驱动程序时，需要使用Volatile，因为在这些驱动程序中需要读写内存映射的硬件设备。特定设备寄存器的内容随时都可能改变，所以你需要volatile关键字来确保这样的访问不会被编译器优化。