---
title: "volatile (C++) | Microsoft Docs"
ms.custom: ""
ms.date: "11/04/2016"
ms.reviewer: ""
ms.suite: ""
ms.technology:
- "cpp-language"
ms.tgt_pltfrm: ""
ms.topic: "language-reference"
f1_keywords:
- "volatile_cpp"
- "volatile"
dev_langs:
- "C++"
helpviewer_keywords:
- "interrupt handlers and volatile keyword"
- "volatile keyword [C++]"
- "volatile objects"
- "objects [C++], volatile"
ms.assetid: 81db4a85-ed5a-4a2c-9a53-5d07a771d2de
caps.latest.revision: 43
author: "mikeblome"
ms.author: "mblome"
manager: "ghogen"
translation.priority.ht:
- "cs-cz"
- "de-de"
- "es-es"
- "fr-fr"
- "it-it"
- "ja-jp"
- "ko-kr"
- "pl-pl"
- "pt-br"
- "ru-ru"
- "tr-tr"
- "zh-cn"
- "zh-tw"
---
# volatile (C++)
A type qualifier that you can use to declare that an object can be modified in the program by the hardware.
## Syntax
```
volatile declarator ;
```
## Remarks
You can use the [/volatile](../build/reference/volatile-volatile-keyword-interpretation.md) compiler switch to modify how the compiler interprets this keyword.
Visual Studio interprets the `volatile` keyword differently depending on the target architecture. For ARM, if no **/volatile** compiler option is specified, the compiler performs as if **/volatile:iso** were specified. For architectures other than ARM, if no **/volatile** compiler option is specified, the compiler performs as if **/volatile:ms** were specified; therefore, for architectures other than ARM we strongly recommend that you specify **/volatile:iso**, and use explicit synchronization primitives and compiler intrinsics when you are dealing with memory that is shared across threads.
You can use the `volatile` qualifier to provide access to memory locations that are used by asynchronous processes such as interrupt handlers.
When `volatile` is used on a variable that also has the [__restrict](../cpp/extension-restrict.md) keyword, `volatile` takes precedence.
If a `struct` member is marked as `volatile`, then `volatile` is propagated to the whole structure. If a structure does not have a length that can be copied on the current architecture by using one instruction, `volatile` may be completely lost on that structure.
The `volatile` keyword may have no effect on a field if one of the following conditions is true:
- The length of the volatile field exceeds the maximum size that can be copied on the current architecture by using one instruction.
- The length of the outermost containing `struct`—or if it's a member of a possibly nested `struct`—exceeds the maximum size that can be copied on the current architecture by using one instruction.
Although the processor does not reorder un-cacheable memory accesses, un-cacheable variables must be marked as `volatile` to guarantee that the compiler does not reorder the memory accesses.
Objects that are declared as `volatile` are not used in certain optimizations because their values can change at any time. The system always reads the current value of a volatile object when it is requested, even if a previous instruction asked for a value from the same object. Also, the value of the object is written immediately on assignment.
## ISO Compliant
If you are familiar with the C# volatile keyword, or familiar with the behavior of `volatile` in earlier versions of Visual C++, be aware that the C++11 ISO Standard `volatile` keyword is different and is supported in Visual Studio when the [/volatile:iso](../build/reference/volatile-volatile-keyword-interpretation.md) compiler option is specified. (For ARM, it's specified by default). The `volatile` keyword in C++11 ISO Standard code is to be used only for hardware access; do not use it for inter-thread communication. For inter-thread communication, use mechanisms such as [std::atomic\