Why is volatile deprecated in C++20?

by

There’s a good talk by the C++ committee language evolution chair on why.

Brief summary, the places that volatile is being removed from didn’t have any well defined meaning in the standard and just caused confusion.

Motivating (Ambiguous) Examples

  • Volatile bit Fields should be specified by your hardware manual and/or compiler.
  • Is += a single/atomic instruction? How about ++?
  • How many reads/writes are needed for compare_exchange? What if it fails?
  • What does void foo(int volatile n) mean? or int volatile foo()?
  • Should *vp; do a load? (This has changed twice in the standard.)

Threading

Historically, people have used volatile to achieve thread safety in C and C++. In C++11, non-UB ways to create synchronization and shared state between threads were added. I recommend Back to Basics: Concurrency as a good introduction.

More Related Contents:

  1. What is a “span” and when should I use one?
  2. Why does volatile exist?
  3. What is the (“spaceship”, three-way comparison) operator in C++?
  4. Volatile in C++11
  5. What kinds of optimizations does ‘volatile’ prevent in C++?
  6. Does the C++ volatile keyword introduce a memory fence?
  7. Why does same_as concept check type equality twice?
  8. Can class template constructors have a redundant template parameter list in c++20
  9. Designated initializers in C++20
  10. Why do we require requires requires?
  11. Why is the volatile qualifier used through out std::atomic?
  12. How to use c++20 modules with CMake?
  13. Which headers in the C++ standard library are guaranteed to include another header?
  14. What is `constinit` in C++20?
  15. Will consteval functions allow template parameters dependent on function arguments?
  16. Familiar template syntax for generic lambdas
  17. Why am I not provided with a default copy constructor from a volatile?
  18. Why default three-way operator (spaceship ) generates equality operator (==) and user define three-way operator not?
  19. Is it allowed for a compiler to optimize away a local volatile variable?
  20. Is C++20 ‘char8_t’ the same as our old ‘char’?
  21. What is the purpose of C++20 std::common_reference?
  22. Contiguous iterator detection
  23. C/C++: casting away volatile considered harmful?
  24. What Rules does compiler have to follow when dealing with volatile memory locations?
  25. Range TS idioms and the mysterious auto &&
  26. Is lambdification of a concept an improvement or bad practice?
  27. Why is operator!= removed in C++20 for many standard library types?
  28. C++ check if statement can be evaluated constexpr
  29. Why must a std::ranges::filter_view object be non-const for querying its elements?
  30. Why don’t I need to specify “typename” before a dependent type in C++20?

Leave a Comment