It makes more sense if you think of const as “read-only”. Volatile just means the compiler can’t make the assumption that the compiler is the only thing that can modify the variable. A constvolatile variable can return different results when read different times.
I thought of it more in terms of changing constants (by casting the const away). AFAIK when it’s not volatile, the compiler can place it into read-only data segment or make it a part of some other data, etc. So, technically, changing a constvolatile would be less of a UB compared to changing a regular const (?)
const volatile is used a lot when doing HW programming. Const will prevent your code from editing it and volatile prevents the compiler from making assumptions. For example reading from a read only MMIO region. Hardware might change the value hence volatile but you can’t because it’s read only so marking it as const allows the compiler to catch it instead of allowing you to try and fail.
I was thinking about telling them how in embedded systems it’s a good practice to allocate the memory by hand, having in mind the backlog, but yours will come first
AFAIK when it’s not volatile, the compiler can place it into read-only data segment
That’s true, but preventing that is merely a side effect of the volatile qualifier. The reason for its existence is that some memory is changed by the underlying hardware, or by an external process, or by the act of accessing it.
The qualifier was a necessary addition to C in order to support such cases, which you might not encounter if you mainly deal with application code, but you’ll see quite a bit in domains like hardware drivers and embedded systems.
A const volatile variable is simply one that doesn’t accept explicit writes. A sensor value, for example.
I’ve never really thought about this before, but constvolatile value types don’t really make sense, do they? constvolatilepointers make sense, since const pointers can point to non-const values, but constvalues are typically placed in read-only memory, in which case the volatile is kind of meaningless, no?
Maybe there’s a signal handler or some other outside force that knows where that variable lives on the stack (maybe through DWARF) and can pause your program to modify it asynchronously. Very niche. More practical is purely to inhibit certain compiler optimizations.
It makes more sense if you think of
constas “read-only”. Volatile just means the compiler can’t make the assumption that the compiler is the only thing that can modify the variable. Aconst volatilevariable can return different results when read different times.I thought of it more in terms of changing constants (by casting the
constaway). AFAIK when it’s notvolatile, the compiler can place it into read-only data segment or make it a part of some other data, etc. So, technically, changing aconst volatilewould be less of a UB compared to changing a regularconst(?)The very notion of “less of a UB” is against the concept of UB. If you have an UB in your program, all guarantees are out of the window.
I mean, changing a
constis itself a questionable move (the question being whether the one doing it is insane)const volatile is used a lot when doing HW programming. Const will prevent your code from editing it and volatile prevents the compiler from making assumptions. For example reading from a read only MMIO region. Hardware might change the value hence volatile but you can’t because it’s read only so marking it as const allows the compiler to catch it instead of allowing you to try and fail.
I will not tell my kids regular scary stories. I will tell them about embedded systems
When you program embedded you’ll also dereference
NULLpointers at some point.More...
Some platforms can have something interesting at memory address
0x0(it’s oftenNULLin C).I was thinking about telling them how in embedded systems it’s a good practice to allocate the memory by hand, having in mind the backlog, but yours will come first
In amd64/x86 kernel space you can dereference null as well. My hobby kernel keeps critical kernel structures there XD.
That’s true, but preventing that is merely a side effect of the volatile qualifier. The reason for its existence is that some memory is changed by the underlying hardware, or by an external process, or by the act of accessing it.
The qualifier was a necessary addition to C in order to support such cases, which you might not encounter if you mainly deal with application code, but you’ll see quite a bit in domains like hardware drivers and embedded systems.
A const volatile variable is simply one that doesn’t accept explicit writes. A sensor value, for example.
I’ve never really thought about this before, but
const volatilevalue types don’t really make sense, do they?const volatilepointers make sense, sinceconstpointers can point to non-constvalues, butconstvalues are typically placed in read-only memory, in which case thevolatileis kind of meaningless, no?They do in embedded when you are polling a read only register. The cpu can change the register but writing to it does nothing.
Maybe there’s a signal handler or some other outside force that knows where that variable lives on the stack (maybe through DWARF) and can pause your program to modify it asynchronously. Very niche. More practical is purely to inhibit certain compiler optimizations.