In C programming, the keyword indicating that a variable may change independently of ordinary code is `volatile`.
`volatile` is a type qualifier. It tells the compiler that accesses to the object are significant and that its value can change for reasons not visible in the current flow of C statements. Typical examples include memory-mapped hardware registers, objects shared with an asynchronous signal handler, and values that must remain valid across `longjmp` in the cases defined by the C standard.
The qualifier does not mean that a variable is constantly changing, nor does it make operations atomic. It also is not a general replacement for locks or C11 atomic types in multithreaded programs. A `volatile` object may still require synchronization, and compound operations such as incrementing it can involve separate read and write steps.
This contrasts with the distractors: `const` restricts modification through a particular access path, `static` concerns storage duration or linkage, and `register` requests a storage-class treatment. The practical effect of `volatile` is to prevent the compiler from treating apparently redundant reads or writes as irrelevant, while the exact hardware behavior remains implementation-dependent.