Why is volatile needed in C

Question

Why is volatile needed in C  What is it used for  What will it do

User · Answer

volatile means the storage is likely to change at anytime and be changed but something outside the control of the user program  This means that if you reference the variable  the program should always check the physical address  ie a mapped input fifo   and not use it in a cached way

User · Answer

As rightly suggested by many here  the volatile keyword s popular use is to skip the optimisation of the volatile variable   The best advantage that comes to mind  and worth mentioning after reading about volatile is -- to prevent rolling back of the variable in case of a longjmp  A non-local jump   What does this mean   It simply means that the last value will be retained after you do stack unwinding  to return to some previous stack frame  typically in case of some erroneous scenario   Since it d be out of scope of this question  I am not going into details of setjmp longjmp here  but it s worth reading about it  and how the volatility feature can be used to retain the last value

User · Answer

There are two uses  These are specially used more often in embedded development    Compiler will not optimise the functions that uses variables that are defined with volatile keyword Volatile is used to access exact memory locations in RAM  ROM  etc    This is used more often to control memory-mapped devices  access CPU registers and locate specific memory locations    See examples with assembly listing  Re  Usage of C  volatile  Keyword in Embedded Development

User · Answer

Volatile tells the compiler not to optimize anything that has to do with the volatile variable        There are at least three common reasons to use it  all involving situations where the value of the variable can change without action from the visible code  When you interface with hardware that changes the value itself  when there s another thread running that also uses the variable  or when there s a signal handler that might change the value of the variable   Let s say you have a little piece of hardware that is mapped into RAM somewhere and that has two addresses  a command port and a data port   typedef struct     int command    int data    int isbusy    MyHardwareGadget    Now you want to send some command   void SendCommand  MyHardwareGadget   gadget  int command  int data         wait while the gadget is busy    while  gadget- gt isbusy             do nothing here           set data first    gadget- gt data      data       writing the command starts the action    gadget- gt command   command      Looks easy  but it can fail because the compiler is free to change the order in which data and commands are written  This would cause our little gadget to issue commands with the previous data-value  Also take a look at the wait while busy loop  That one will be optimized out  The compiler will try to be clever  read the value of isbusy just once and then go into an infinite loop  That s not what you want    The way to get around this is to declare the pointer gadget as volatile  This way the compiler is forced to do what you wrote  It can t remove the memory assignments  it can t cache variables in registers and it can t change the order of assignments either   This is the correct version      void SendCommand  volatile MyHardwareGadget   gadget  int command  int data                 wait while the gadget is busy        while  gadget- gt isbusy                     do nothing here                   set data first        gadget- gt data      data           writing the command starts the action        gadget- gt command   command

User · Answer

In simple terms  it tells the compiler not to do any optimisation on a particular variable  Variables which are mapped to device register are modified indirectly by the device  In this case  volatile must be used

User · Answer

Another use for volatile is signal handlers  If you have code like this   int quit   0  while   quit           very small loop which is completely visible to the compiler        The compiler is allowed to notice the loop body does not touch the quit variable and convert the loop to a while  true  loop  Even if the quit variable is set on the signal handler for SIGINT and SIGTERM  the compiler has no way to know that   However  if the quit variable is declared volatile  the compiler is forced to load it every time  because it can be modified elsewhere  This is exactly what you want in this situation

User · Answer

it does not allows compiler to automatic changing values of variables   a volatile variable is for dynamic use

User · Answer

volatile tells the compiler that your variable may be changed by other means  than the code that is accessing it  e g   it may be a I O-mapped memory location  If this is not specified in such cases  some variable accesses can be optimised  e g   its contents can be held in a register  and the memory location not read back in again

User · Answer

As rightly suggested by many here  the volatile keyword s popular use is to skip the optimisation of the volatile variable   The best advantage that comes to mind  and worth mentioning after reading about volatile is -- to prevent rolling back of the variable in case of a longjmp  A non-local jump   What does this mean   It simply means that the last value will be retained after you do stack unwinding  to return to some previous stack frame  typically in case of some erroneous scenario   Since it d be out of scope of this question  I am not going into details of setjmp longjmp here  but it s worth reading about it  and how the volatility feature can be used to retain the last value

User · Answer

volatile in C actually came into existence for the purpose of not caching the values of the variable automatically  It will tell the compiler not to cache the value of this variable  So it will generate code to take the value of the given volatile variable from the main memory every time it encounters it  This mechanism is used because at any time the value can be modified by the OS or any interrupt  So using volatile will help us accessing the value afresh every time

User · Answer

My simple explanation is   In some scenarios  based on the logic or code  the compiler will do optimisation of variables which it thinks do not change  The volatile keyword prevents a variable being optimised   For example   bool usb interface flag   0  while usb interface flag    0           execute logic for the scenario where the USB isn t connected      From the above code  the compiler may think usb interface flag is defined as 0  and that in the while loop it will be zero forever  After optimisation  the compiler will treat it as while true  all the time  resulting in an infinite loop    To avoid these kinds of scenarios  we declare the flag as volatile  we are telling to compiler that this value may be changed by an external interface or other module of program  i e   please don t optimise it  That s the use case for volatile

User · Answer

Another use for volatile is signal handlers  If you have code like this   int quit   0  while   quit           very small loop which is completely visible to the compiler        The compiler is allowed to notice the loop body does not touch the quit variable and convert the loop to a while  true  loop  Even if the quit variable is set on the signal handler for SIGINT and SIGTERM  the compiler has no way to know that   However  if the quit variable is declared volatile  the compiler is forced to load it every time  because it can be modified elsewhere  This is exactly what you want in this situation

User · Answer

A marginal use for volatile is the following  Say you want to compute the numerical derivative of a function f    double der f double x        static const double h   1e-3      return  f x   h  - f x     h      The problem is that x h-x is generally not equal to h due to roundoff errors  Think about it   when you substract very close numbers  you lose a lot of significant digits which can ruin the computation of the derivative  think 1 00001 - 1   A possible workaround could be  double der f2 double x        static const double h   1e-3      double hh   x   h - x      return  f x   hh  - f x     hh      but depending on your platform and compiler switches  the second line of that function may be wiped out by a aggressively optimizing compiler  So you write instead      volatile double hh   x   h      hh -  x    to force the compiler to read the memory location containing hh  forfeiting an eventual optimization opportunity

User · Answer

I ll mention another scenario where volatiles are important   Suppose you memory-map a file for faster I O and that file can change behind the scenes  e g  the file is not on your local hard drive  but is instead served over the network by another computer    If you access the memory-mapped file s data through pointers to non-volatile objects  at the source code level   then the code generated by the compiler can fetch the same data multiple times without you being aware of it   If that data happens to change  your program may become using two or more different versions of the data and get into an inconsistent state  This can lead not only to logically incorrect behavior of the program but also to exploitable security holes in it if it processes untrusted files or files from untrusted locations   If you care about security  and you should  this is an important scenario to consider

User · Answer

volatile means the storage is likely to change at anytime and be changed but something outside the control of the user program  This means that if you reference the variable  the program should always check the physical address  ie a mapped input fifo   and not use it in a cached way

User · Answer

volatile in C actually came into existence for the purpose of not caching the values of the variable automatically  It will tell the compiler not to cache the value of this variable  So it will generate code to take the value of the given volatile variable from the main memory every time it encounters it  This mechanism is used because at any time the value can be modified by the OS or any interrupt  So using volatile will help us accessing the value afresh every time

User · Answer

In my opinion  you should not expect too much from volatile  To illustrate  look at the example in Nils Pipenbrinck s highly-voted answer   I would say  his example is not suitable for volatile  volatile is only used to   prevent the compiler from making useful and desirable optimizations  It is nothing about the thread safe  atomic access or even memory order   In that example       void SendCommand  volatile MyHardwareGadget   gadget  int command  int data                 wait while the gadget is busy        while  gadget- gt isbusy                     do nothing here                   set data first        gadget- gt data      data           writing the command starts the action        gadget- gt command   command          the gadget- gt data   data before gadget- gt command   command only is only guaranteed in compiled code by compiler  At running time  the processor still possibly reorders the data and command assignment  regarding to the processor architecture  The hardware could get the wrong data suppose gadget is mapped to hardware I O   The memory barrier is needed between data and command assignment

User · Answer

Volatile tells the compiler not to optimize anything that has to do with the volatile variable        There are at least three common reasons to use it  all involving situations where the value of the variable can change without action from the visible code  When you interface with hardware that changes the value itself  when there s another thread running that also uses the variable  or when there s a signal handler that might change the value of the variable   Let s say you have a little piece of hardware that is mapped into RAM somewhere and that has two addresses  a command port and a data port   typedef struct     int command    int data    int isbusy    MyHardwareGadget    Now you want to send some command   void SendCommand  MyHardwareGadget   gadget  int command  int data         wait while the gadget is busy    while  gadget- gt isbusy             do nothing here           set data first    gadget- gt data      data       writing the command starts the action    gadget- gt command   command      Looks easy  but it can fail because the compiler is free to change the order in which data and commands are written  This would cause our little gadget to issue commands with the previous data-value  Also take a look at the wait while busy loop  That one will be optimized out  The compiler will try to be clever  read the value of isbusy just once and then go into an infinite loop  That s not what you want    The way to get around this is to declare the pointer gadget as volatile  This way the compiler is forced to do what you wrote  It can t remove the memory assignments  it can t cache variables in registers and it can t change the order of assignments either   This is the correct version      void SendCommand  volatile MyHardwareGadget   gadget  int command  int data                 wait while the gadget is busy        while  gadget- gt isbusy                     do nothing here                   set data first        gadget- gt data      data           writing the command starts the action        gadget- gt command   command

User · Answer

The Wiki say everything about volatile    volatile  computer programming    And the Linux kernel s doc also make a excellent notation about volatile    Why the  volatile  type class should not be used

User · Answer

A volatile can be changed from outside the compiled code  for example  a program may map a volatile variable to a memory mapped register   The compiler won t apply certain optimizations to code that handles a volatile variable - for example  it won t load it into a register without writing it to memory  This is important when dealing with hardware registers

User · Answer

Volatile is also useful  when you want to force the compiler not to optimize a specific code sequence  e g  for writing a micro-benchmark

User · Answer

A volatile can be changed from outside the compiled code  for example  a program may map a volatile variable to a memory mapped register   The compiler won t apply certain optimizations to code that handles a volatile variable - for example  it won t load it into a register without writing it to memory  This is important when dealing with hardware registers

User · Answer

it does not allows compiler to automatic changing values of variables   a volatile variable is for dynamic use

User · Answer

My simple explanation is   In some scenarios  based on the logic or code  the compiler will do optimisation of variables which it thinks do not change  The volatile keyword prevents a variable being optimised   For example   bool usb interface flag   0  while usb interface flag    0           execute logic for the scenario where the USB isn t connected      From the above code  the compiler may think usb interface flag is defined as 0  and that in the while loop it will be zero forever  After optimisation  the compiler will treat it as while true  all the time  resulting in an infinite loop    To avoid these kinds of scenarios  we declare the flag as volatile  we are telling to compiler that this value may be changed by an external interface or other module of program  i e   please don t optimise it  That s the use case for volatile

User · Answer

See this article by Andrei Alexandrescu   volatile - Multithreaded Programmer s Best Friend      The volatile keyword was   devised to prevent compiler   optimizations that might render code   incorrect in the presence of certain   asynchronous events  For example  if   you declare a primitive variable as   volatile  the compiler is not   permitted to cache it in a register --   a common optimization that would be   disastrous if that variable were   shared among multiple threads  So the   general rule is  if you have variables   of primitive type that must be shared   among multiple threads  declare those   variables volatile  But you can   actually do a lot more with this   keyword  you can use it to catch code   that is not thread safe  and you can   do so at compile time  This article   shows how it is done  the solution   involves a simple smart pointer that   also makes it easy to serialize   critical sections of code    The article applies to both C and C     Also see the article  C   and the Perils of Double-Checked Locking  by Scott Meyers and Andrei Alexandrescu      So when dealing with some memory locations  e g  memory mapped ports or memory referenced by ISRs   Interrupt Service Routines      some optimizations must be suspended  volatile exists for specifying special treatment for such locations  specifically   1  the content of a volatile variable is  unstable   can change by means unknown to the compiler    2  all writes to volatile data are  observable  so they must be executed religiously  and  3  all operations on volatile data are executed in the sequence in which they appear in the source code  The first two rules ensure proper reading and writing  The last one allows implementation of I O protocols that mix input and output  This is informally what C and C   s volatile guarantees

User · Answer

Another use for volatile is signal handlers  If you have code like this   int quit   0  while   quit           very small loop which is completely visible to the compiler        The compiler is allowed to notice the loop body does not touch the quit variable and convert the loop to a while  true  loop  Even if the quit variable is set on the signal handler for SIGINT and SIGTERM  the compiler has no way to know that   However  if the quit variable is declared volatile  the compiler is forced to load it every time  because it can be modified elsewhere  This is exactly what you want in this situation

User · Answer

Volatile is also useful  when you want to force the compiler not to optimize a specific code sequence  e g  for writing a micro-benchmark

User · Answer

In the language designed by Dennis Ritchie  every access to any object  other than automatic objects whose address had not been taken  would behave as though it computed the address of the object and then read or wrote the storage at that address   This made the language very powerful  but severely limited optimization opportunities   While it might have been possible to add a qualifier that would invite a compiler to assume that a particular object wouldn t be changed in weird ways  such an assumption would be appropriate for the vast majority of objects in C programs  and it would have been impractical to add a qualifier to all the objects for which such assumption would be appropriate   On the other hand  some programs need to use some objects for which such an assumption would not hold   To resolve this issue  the Standard says that compilers may assume that objects which are not declared volatile will not have their value observed or changed in ways that are outside the compiler s control  or would be outside a reasonable compiler s understanding   Because various platforms may have different ways in which objects could be observed or modified outside a compiler s control  it is appropriate that quality compilers for those platforms should differ in their exact handling of volatile semantics   Unfortunately  because the Standard failed to suggest that quality compilers intended for low-level programming on a platform should handle volatile in a way that will recognize any and all relevant effects of a particular read write operation on that platform  many compilers fall short of doing so in ways that make it harder to process things like background I O in a way which is efficient but can t be broken by compiler  optimizations

User · Answer

Volatile is also useful  when you want to force the compiler not to optimize a specific code sequence  e g  for writing a micro-benchmark

User · Answer

Volatile tells the compiler not to optimize anything that has to do with the volatile variable        There are at least three common reasons to use it  all involving situations where the value of the variable can change without action from the visible code  When you interface with hardware that changes the value itself  when there s another thread running that also uses the variable  or when there s a signal handler that might change the value of the variable   Let s say you have a little piece of hardware that is mapped into RAM somewhere and that has two addresses  a command port and a data port   typedef struct     int command    int data    int isbusy    MyHardwareGadget    Now you want to send some command   void SendCommand  MyHardwareGadget   gadget  int command  int data         wait while the gadget is busy    while  gadget- gt isbusy             do nothing here           set data first    gadget- gt data      data       writing the command starts the action    gadget- gt command   command      Looks easy  but it can fail because the compiler is free to change the order in which data and commands are written  This would cause our little gadget to issue commands with the previous data-value  Also take a look at the wait while busy loop  That one will be optimized out  The compiler will try to be clever  read the value of isbusy just once and then go into an infinite loop  That s not what you want    The way to get around this is to declare the pointer gadget as volatile  This way the compiler is forced to do what you wrote  It can t remove the memory assignments  it can t cache variables in registers and it can t change the order of assignments either   This is the correct version      void SendCommand  volatile MyHardwareGadget   gadget  int command  int data                 wait while the gadget is busy        while  gadget- gt isbusy                     do nothing here                   set data first        gadget- gt data      data           writing the command starts the action        gadget- gt command   command

User · Answer

In the language designed by Dennis Ritchie  every access to any object  other than automatic objects whose address had not been taken  would behave as though it computed the address of the object and then read or wrote the storage at that address   This made the language very powerful  but severely limited optimization opportunities   While it might have been possible to add a qualifier that would invite a compiler to assume that a particular object wouldn t be changed in weird ways  such an assumption would be appropriate for the vast majority of objects in C programs  and it would have been impractical to add a qualifier to all the objects for which such assumption would be appropriate   On the other hand  some programs need to use some objects for which such an assumption would not hold   To resolve this issue  the Standard says that compilers may assume that objects which are not declared volatile will not have their value observed or changed in ways that are outside the compiler s control  or would be outside a reasonable compiler s understanding   Because various platforms may have different ways in which objects could be observed or modified outside a compiler s control  it is appropriate that quality compilers for those platforms should differ in their exact handling of volatile semantics   Unfortunately  because the Standard failed to suggest that quality compilers intended for low-level programming on a platform should handle volatile in a way that will recognize any and all relevant effects of a particular read write operation on that platform  many compilers fall short of doing so in ways that make it harder to process things like background I O in a way which is efficient but can t be broken by compiler  optimizations

User · Answer

In simple terms  it tells the compiler not to do any optimisation on a particular variable  Variables which are mapped to device register are modified indirectly by the device  In this case  volatile must be used

User · Answer

volatile tells the compiler that your variable may be changed by other means  than the code that is accessing it  e g   it may be a I O-mapped memory location  If this is not specified in such cases  some variable accesses can be optimised  e g   its contents can be held in a register  and the memory location not read back in again

User · Answer

I ll mention another scenario where volatiles are important   Suppose you memory-map a file for faster I O and that file can change behind the scenes  e g  the file is not on your local hard drive  but is instead served over the network by another computer    If you access the memory-mapped file s data through pointers to non-volatile objects  at the source code level   then the code generated by the compiler can fetch the same data multiple times without you being aware of it   If that data happens to change  your program may become using two or more different versions of the data and get into an inconsistent state  This can lead not only to logically incorrect behavior of the program but also to exploitable security holes in it if it processes untrusted files or files from untrusted locations   If you care about security  and you should  this is an important scenario to consider

User · Answer

See this article by Andrei Alexandrescu   volatile - Multithreaded Programmer s Best Friend      The volatile keyword was   devised to prevent compiler   optimizations that might render code   incorrect in the presence of certain   asynchronous events  For example  if   you declare a primitive variable as   volatile  the compiler is not   permitted to cache it in a register --   a common optimization that would be   disastrous if that variable were   shared among multiple threads  So the   general rule is  if you have variables   of primitive type that must be shared   among multiple threads  declare those   variables volatile  But you can   actually do a lot more with this   keyword  you can use it to catch code   that is not thread safe  and you can   do so at compile time  This article   shows how it is done  the solution   involves a simple smart pointer that   also makes it easy to serialize   critical sections of code    The article applies to both C and C     Also see the article  C   and the Perils of Double-Checked Locking  by Scott Meyers and Andrei Alexandrescu      So when dealing with some memory locations  e g  memory mapped ports or memory referenced by ISRs   Interrupt Service Routines      some optimizations must be suspended  volatile exists for specifying special treatment for such locations  specifically   1  the content of a volatile variable is  unstable   can change by means unknown to the compiler    2  all writes to volatile data are  observable  so they must be executed religiously  and  3  all operations on volatile data are executed in the sequence in which they appear in the source code  The first two rules ensure proper reading and writing  The last one allows implementation of I O protocols that mix input and output  This is informally what C and C   s volatile guarantees

User · Answer

volatile tells the compiler that your variable may be changed by other means  than the code that is accessing it  e g   it may be a I O-mapped memory location  If this is not specified in such cases  some variable accesses can be optimised  e g   its contents can be held in a register  and the memory location not read back in again

User · Answer

volatile tells the compiler that your variable may be changed by other means  than the code that is accessing it  e g   it may be a I O-mapped memory location  If this is not specified in such cases  some variable accesses can be optimised  e g   its contents can be held in a register  and the memory location not read back in again

User · Answer

Another use for volatile is signal handlers  If you have code like this   int quit   0  while   quit           very small loop which is completely visible to the compiler        The compiler is allowed to notice the loop body does not touch the quit variable and convert the loop to a while  true  loop  Even if the quit variable is set on the signal handler for SIGINT and SIGTERM  the compiler has no way to know that   However  if the quit variable is declared volatile  the compiler is forced to load it every time  because it can be modified elsewhere  This is exactly what you want in this situation

User · Answer

Volatile tells the compiler not to optimize anything that has to do with the volatile variable        There are at least three common reasons to use it  all involving situations where the value of the variable can change without action from the visible code  When you interface with hardware that changes the value itself  when there s another thread running that also uses the variable  or when there s a signal handler that might change the value of the variable   Let s say you have a little piece of hardware that is mapped into RAM somewhere and that has two addresses  a command port and a data port   typedef struct     int command    int data    int isbusy    MyHardwareGadget    Now you want to send some command   void SendCommand  MyHardwareGadget   gadget  int command  int data         wait while the gadget is busy    while  gadget- gt isbusy             do nothing here           set data first    gadget- gt data      data       writing the command starts the action    gadget- gt command   command      Looks easy  but it can fail because the compiler is free to change the order in which data and commands are written  This would cause our little gadget to issue commands with the previous data-value  Also take a look at the wait while busy loop  That one will be optimized out  The compiler will try to be clever  read the value of isbusy just once and then go into an infinite loop  That s not what you want    The way to get around this is to declare the pointer gadget as volatile  This way the compiler is forced to do what you wrote  It can t remove the memory assignments  it can t cache variables in registers and it can t change the order of assignments either   This is the correct version      void SendCommand  volatile MyHardwareGadget   gadget  int command  int data                 wait while the gadget is busy        while  gadget- gt isbusy                     do nothing here                   set data first        gadget- gt data      data           writing the command starts the action        gadget- gt command   command

User · Answer

The Wiki say everything about volatile    volatile  computer programming    And the Linux kernel s doc also make a excellent notation about volatile    Why the  volatile  type class should not be used

User · Answer

volatile in C actually came into existence for the purpose of not caching the values of the variable automatically  It will tell the compiler not to cache the value of this variable  So it will generate code to take the value of the given volatile variable from the main memory every time it encounters it  This mechanism is used because at any time the value can be modified by the OS or any interrupt  So using volatile will help us accessing the value afresh every time

User · Answer

A volatile can be changed from outside the compiled code  for example  a program may map a volatile variable to a memory mapped register   The compiler won t apply certain optimizations to code that handles a volatile variable - for example  it won t load it into a register without writing it to memory  This is important when dealing with hardware registers

User · Answer

Volatile is also useful  when you want to force the compiler not to optimize a specific code sequence  e g  for writing a micro-benchmark

User · Answer

In my opinion  you should not expect too much from volatile  To illustrate  look at the example in Nils Pipenbrinck s highly-voted answer   I would say  his example is not suitable for volatile  volatile is only used to   prevent the compiler from making useful and desirable optimizations  It is nothing about the thread safe  atomic access or even memory order   In that example       void SendCommand  volatile MyHardwareGadget   gadget  int command  int data                 wait while the gadget is busy        while  gadget- gt isbusy                     do nothing here                   set data first        gadget- gt data      data           writing the command starts the action        gadget- gt command   command          the gadget- gt data   data before gadget- gt command   command only is only guaranteed in compiled code by compiler  At running time  the processor still possibly reorders the data and command assignment  regarding to the processor architecture  The hardware could get the wrong data suppose gadget is mapped to hardware I O   The memory barrier is needed between data and command assignment

User · Answer

There are two uses  These are specially used more often in embedded development    Compiler will not optimise the functions that uses variables that are defined with volatile keyword Volatile is used to access exact memory locations in RAM  ROM  etc    This is used more often to control memory-mapped devices  access CPU registers and locate specific memory locations    See examples with assembly listing  Re  Usage of C  volatile  Keyword in Embedded Development

User · Answer

A marginal use for volatile is the following  Say you want to compute the numerical derivative of a function f    double der f double x        static const double h   1e-3      return  f x   h  - f x     h      The problem is that x h-x is generally not equal to h due to roundoff errors  Think about it   when you substract very close numbers  you lose a lot of significant digits which can ruin the computation of the derivative  think 1 00001 - 1   A possible workaround could be  double der f2 double x        static const double h   1e-3      double hh   x   h - x      return  f x   hh  - f x     hh      but depending on your platform and compiler switches  the second line of that function may be wiped out by a aggressively optimizing compiler  So you write instead      volatile double hh   x   h      hh -  x    to force the compiler to read the memory location containing hh  forfeiting an eventual optimization opportunity

User · Answer

A volatile can be changed from outside the compiled code  for example  a program may map a volatile variable to a memory mapped register   The compiler won t apply certain optimizations to code that handles a volatile variable - for example  it won t load it into a register without writing it to memory  This is important when dealing with hardware registers

User · Answer

volatile in C actually came into existence for the purpose of not caching the values of the variable automatically  It will tell the compiler not to cache the value of this variable  So it will generate code to take the value of the given volatile variable from the main memory every time it encounters it  This mechanism is used because at any time the value can be modified by the OS or any interrupt  So using volatile will help us accessing the value afresh every time

[c] Why is volatile needed in C?

Examples related to c

Examples related to declaration

Examples related to volatile