{"id":5973,"date":"2020-08-17T18:57:14","date_gmt":"2020-08-17T18:57:14","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/volatile-and-other-small-improvements-in-c-20\/"},"modified":"2023-06-26T09:46:02","modified_gmt":"2023-06-26T09:46:02","slug":"volatile-and-other-small-improvements-in-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/volatile-and-other-small-improvements-in-c-20\/","title":{"rendered":"volatile and Other Small Improvements in C++20"},"content":{"rendered":"

Today, I complete my tour through the C++20 core language features with a few small improvements. One interesting of these minor improvements is that most of volatile<\/span> has been deprecated.<\/p>\n

<\/p>\n

 \"TimelineCpp20CoreLanguage\"<\/p>\n

volatile<\/span><\/h2>\n

The abstract in the proposal P1152R0<\/a> briefly describes the changes that volatile <\/span>undergoes: “The proposed deprecation preserves the useful parts of volatile, and removes the dubious \/ already broken ones. This paper aims at breaking at compile-time code which is today subtly broken at runtime or through a compiler update.<\/em> “<\/p>\n

Before I show you what semantic of volatile<\/span> is preserved, I want to start with the deprecated features:<\/p>\n

    \n
  1. Deprecate volatile<\/span> compound assignment, and pre\/post increment\/decrement<\/li>\n
  2. Deprecate volatile<\/span> qualification of function parameters or return types<\/li>\n
  3. Deprecate volatile<\/span> qualifiers in a structured binding declaration<\/li>\n<\/ol>\n

    If you want to know all the sophisticated details, I strongly suggest you watch the CppCon 2019 talk “Deprecating volatile<\/a>” from JF Bastien. Here are a few examples from the talk referring to used numbers (1) to (3).<\/p>\n

     <\/p>\n

    \n
    (1<\/span>)\r\nint<\/span> neck, tail;\r\nvolatile<\/span> int<\/span> brachiosaur;\r\nbrachiosaur =<\/span> neck;   \/\/ OK, a volatile store<\/span>\r\ntail =<\/span> brachiosaur;    \/\/ OK, a volatile load<\/span>\r\n\r\n\/\/ deprecated: does this access brachiosaur once or twice<\/span>\r\ntail =<\/span> brachiosaur =<\/span> neck;\r\n\r\n\/\/ deprecated: does this access brachiosaur once or twice<\/span>\r\nbrachiosaur +=<\/span> neck;\r\n\r\n\/\/ OK, a volatile load, an addition, a volatile store<\/span>\r\nbrachiosau =<\/span> brachiosaur +<\/span> neck;\r\n\r\n#########################################<\/span>\r\n(2<\/span>)\r\n\/\/ deprecated: a volatile return type has no meaning<\/span>\r\nvolatile<\/span> struct<\/span> amber jurassic();\r\n\r\n\/\/ deprecated: volatile parameters aren't meaningful to the<\/span>\r\n\/\/             caller, volatile only applies within the function<\/span>\r\nvoid<\/span> trex<\/span>(volatile<\/span> short<\/span> left_arm, volatile<\/span> short<\/span> right_arm);\r\n\r\n\/\/ OK, the pointer isn't volatile, the data is opints to is<\/span>\r\nvoid<\/span> fly<\/span>(volatile<\/span> struct<\/span> pterosaur*<\/span> pterandon);\r\n\r\n########################################<\/span>\r\n(3<\/span>)\r\nstruct<\/span> linhenykus { volatile<\/span> short<\/span> forelimb; };\r\nvoid<\/span> park<\/span>(linhenykus alvarezsauroid) {\r\n    \/\/ deprecated: doe the binding copy the foreelimbs?<\/span>\r\n    auto<\/span> [what_is_this] =<\/span> alvarezsauroid;\r\n    \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    I didn’t answer the crucial question: When should you use volatile<\/span>?  A note from the C++ standard says that “volatile<\/span> is a hint to the implementation to avoid aggressive optimization involving the object because the value of the object might be changed by means undetectable by an implementation.<\/em>” This means for a single thread of execution that, the compiler must perform load or store operations in the executable as often as they occur in the source code. volatile<\/span> operations, therefore, cannot be eliminated or reordered. Consequently, you can use volatile<\/span> objects to communicate with a signal handler but not with another thread of execution.<\/p>\n
    To summarize, volatile<\/span> avoids aggressive optimization and has no multithreading semantics.<\/strong><\/p>\n
    I present the remaining minor improvements with a short example that runs in the Compiler Explorer.<\/p>\n<\/p>\n
    Range-based for-loop with Initializers<\/h2>\n
    With C++20, you can directly use a range-based for-loop with an initializer.<\/p>\n
     <\/p>\n
    \n
    \/\/ rangeBasedForLoopInitializer.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    for<\/span> (auto<\/span> vec =<\/span> std::<\/span>vector{1<\/span>, 2<\/span>, 3<\/span>}; auto<\/span> v :<\/span> vec) {  \/\/ (1)<\/span>\r\n        std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>;\r\n    }\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n    for<\/span> (auto<\/span> initList =<\/span> {1<\/span>, 2<\/span>, 3<\/span>}; auto<\/span> e :<\/span> initList) {  \/\/ (2)<\/span>\r\n        e *=<\/span> e;\r\n        std::<\/span>cout <<<\/span> e <<<\/span> \" \"<\/span>;\r\n    }\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n    using<\/span> namespace<\/span> std::<\/span>string_literals;\r\n    for<\/span> (auto<\/span> str =<\/span> \"Hello World\"<\/span>s; auto<\/span> c:<\/span> str) {        \/\/ (3)<\/span>\r\n        std::<\/span>cout <<<\/span> c <<<\/span> \" \"<\/span>;\r\n    }\r\n     \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The range-based for-loop uses in line (1) a std::vector<\/span>, in line (2) a std::initializer_list,<\/span> and line (3) a std::string<\/span>. Additionally, in lines (1) and line (2), I apply automatic type deduction for class templates we have had since C++17. Instead of std::vector<int><\/span> and std::initalizer_list<int><\/span>, I write std::vector<\/span> and std::initializer_list<\/span>. <\/p>\n
    With GCC 10.2 and Compiler Explorer<\/a>, I get the expected output.<\/p>\n
    \"rangeBasedForLoopWithInitializer\" <\/p>\n
    virtual constexpr<\/span> Functions<\/h2>\n
    A constexpr<\/span> function has the potential to run at compile-time but can also be executed at run-time. Consequently, you can make a constexpr<\/span> function with C++20 virtual<\/span>. Both directions are possible. Neither can a virtual<\/span> constexpr<\/span> function override a  non-constexpr<\/span> function nor can a virtual non-constexpr<\/span> function override a  constexpr<\/span> virtual<\/span> function. I want to emphasize that override implies that the regarding function of a base class is virtual<\/span>. <\/p>\n
    The following program shows both combinations.<\/p>\n
     <\/p>\n
    <\/p>\n
    \n
    \/\/ virtualConstexpr.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nstruct<\/span> X1 {\r\n    virtual<\/span> int<\/span> f() const<\/span> =<\/span> 0<\/span>;\r\n};\r\n\r\nstruct<\/span> X2:<\/span> public<\/span> X1 {\r\n    constexpr int<\/span> f() const<\/span> override { return<\/span> 2<\/span>; }\r\n};\r\n\r\nstruct<\/span> X3:<\/span> public<\/span> X2 {\r\n    int<\/span> f() const<\/span> override { return<\/span> 3<\/span>; }\r\n};\r\n\r\nstruct<\/span> X4:<\/span> public<\/span> X3 {\r\n    constexpr int<\/span> f() const<\/span> override { return<\/span> 4<\/span>; }\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    X1*<\/span> x1 =<\/span> new<\/span> X4;\r\n    std::<\/span>cout <<<\/span> \"x1->f(): \"<\/span> <<<\/span> x1-><\/span>f() <<<\/span> std::<\/span>endl;\r\n    \r\n    X4 x4;\r\n    X1&<\/span> x2 =<\/span> x4;\r\n    std::<\/span>cout <<<\/span> \"x2.f(): \"<\/span> <<<\/span> x2.f() <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Line (1) uses virtual dispatch (late binding) via a pointer, and line (2) uses virtual dispatch via reference. Once more, here is the output with GCC 10.2 and the Compiler Explorer<\/a>.<\/p>\n
    \"virtualConstexpr\"<\/h2>\n
    The new Character Type for UTF-8 Strings: char8_t<\/span><\/h2>\n
    Additionally, to the character types char16_t<\/span> and char32_t<\/span> from C++11, C++20 gets the new character type char8_t.char8_t <\/span>is large enough to represent any UTF-8 code unit (8 bits). It has the same size, signedness, and alignment as an unsigned char<\/span>, but is a distinct type. <\/p>\n
    Consequently, C++20 has a new typedef for the character type char8_t<\/span> (1) and a new UTF-8 string literal (2).<\/p>\n
    \n
    std::<\/span>u8string:<\/span> std::<\/span>basic_string<<\/span>char8_t<\/span>><\/span> (1<\/span>)\r\nu8\"Hello World\"<\/span>                           (2<\/span>)\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The following program shows the straightforward usage of char8_t<\/span>:<\/p>\n
    \n
    \/\/ char8Str.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    const<\/span> char8_t<\/span>*<\/span> char8Str =<\/span> u8\"Hello world\"<\/span>;\r\n    std::<\/span>basic_string<<\/span>char8_t<\/span>><\/span> char8String =<\/span> u8\"helloWorld\"<\/span>;\r\n    std::<\/span>u8string char8String2 =<\/span> u8\"helloWorld\"<\/span>;\r\n    \r\n    char8String2 +=<\/span> u8\".\"<\/span>;\r\n    \r\n    std::<\/span>cout <<<\/span> \"char8String.size(): \"<\/span> <<<\/span> char8String.size() <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"char8String2.size(): \"<\/span> <<<\/span> char8String2.size() <<<\/span> std::<\/span>endl;\r\n    \r\n    char8String2.replace(0<\/span>, 5<\/span>, u8\"Hello \"<\/span>);\r\n    \r\n    std::<\/span>cout <<<\/span> \"char8String2.size(): \"<\/span> <<<\/span> char8String2.size() <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    <\/span><\/span><\/p>\n
    Without further ado. Here is the output of the program on the Compiler Explorer.<\/a><\/span><\/p>\n<\/section>\n
     <\/p>\n
    \"char8Str\"<\/p>\n
    using enum<\/span> in Local Scopes <\/h2>\n
    A using enum<\/span> declaration introduces the enumerators of the named enumeration in the local scope.<\/p>\n
    \n
    \/\/ enumUsing.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string_view><\/span>\r\n\r\nenum<\/span> class<\/span> Color<\/span> {\r\n    red,\r\n    green, \r\n    blue\r\n};\r\n\r\nstd::<\/span>string_view toString(Color col) {\r\n  switch<\/span> (col) {\r\n    using<\/span> enum<\/span> Color;                   \/\/ (1)<\/span> \r\n    case<\/span> red:   return<\/span> \"red\"<\/span>;           \/\/ (2)<\/span> \r\n    case<\/span> green: return<\/span> \"green\"<\/span>;         \/\/ (2)<\/span> \r\n    case<\/span> blue:  return<\/span> \"blue\"<\/span>;          \/\/ (2)<\/span> \r\n  }\r\n  return<\/span> \"unknown\"<\/span>;\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n   \r\n    std::<\/span>cout <<<\/span> \"toString(Color::red): \"<\/span> <<<\/span> toString(Color::<\/span>red) <<<\/span> std::<\/span>endl;\r\n    \r\n    using<\/span> enum<\/span> Color;                                                    \/\/ (1)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> \"toString(green): \"<\/span> <<<\/span> toString(green) <<<\/span> std::<\/span>endl;    \/\/ (2)<\/span> \r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}  \r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The using enum<\/span> declaration in (1) introduces the enumerators of the scoped enumerations Color<\/span> into the local scope. From then on, the enumerators can be used unscoped (2). This time, the only C++ compiler supporting using enum<\/span> is the Microsoft Compiler 19.24:<\/p>\n
    \"enumUsing\"<\/p>\n
    Default member initializers for bit-fields<\/span><\/h1>\n
    First, what is a bit field? Here is the definition of Wikipedia<\/a>: “A bit field is a data structure<\/a> used in computer programming<\/a>. It consists of a number of adjacent computer memory<\/a> locations which have been allocated to hold a sequence of bits<\/a>, stored so that any single bit or group of bits within the set can be addressed.[1]<\/a>[2]<\/a> A bit field is most commonly used to represent integral types<\/a> of known, fixed bit-width.”<\/em><\/p>\n
    With C++20, we can default initialize the members of a bit-field:<\/p>\n
     <\/p>\n
    \n
    \/\/ bitField.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nstruct<\/span> Class11 {             \/\/ (1)<\/span>\r\n    int<\/span> i =<\/span> 1<\/span>;\r\n    int<\/span> j =<\/span> 2<\/span>;\r\n    int<\/span> k =<\/span> 3<\/span>;\r\n    int<\/span> l =<\/span> 4<\/span>;\r\n    int<\/span> m =<\/span> 5<\/span>;\r\n    int<\/span> n =<\/span> 6<\/span>;\r\n};\r\n\r\nstruct<\/span> BitField20 {          \/\/ (2)<\/span>\r\n    int<\/span> i :<\/span> 3<\/span> =<\/span> 1<\/span>;\r\n    int<\/span> j :<\/span> 4<\/span> =<\/span> 2<\/span>;\r\n    int<\/span> k :<\/span> 5<\/span> =<\/span> 3<\/span>;\r\n    int<\/span> l :<\/span> 6<\/span> =<\/span> 4<\/span>;\r\n    int<\/span> m :<\/span> 7<\/span> =<\/span> 5<\/span>;\r\n    int<\/span> n :<\/span> 7<\/span> =<\/span> 6<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span> () {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> \"sizeof(Class11): \"<\/span> <<<\/span> sizeof<\/span>(Class11) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"sizeof(BitField20): \"<\/span> <<<\/span> sizeof<\/span>(BitField20) <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    According to the member of a class (1) with C++11, the members of the bit-field can have default initializers (2) with C++20. Finally, here is the output of the program with the Clang 10.0 compiler:<\/p>\n
    \"bitField\"<\/p>\n
    A Short Writing Break<\/h2>\n
    In the next fortnight, I will be in Italy, so I will not write a regular post.
    If you want to read one of my more than 300 posts on modern C++, I created a visual tour through my blog. This visual tour explains the TOC, categories, tags, archive, and search system and should help you find the post you are looking for.<\/p>\n
    Here you go https:\/\/youtu.be\/hrXoVSi0O28<\/a>.<\/p>\n
    What’s next?<\/h2>\n
    After my short break, I continue my journey through C++20 with the new library. In particular, I will write about std::span<\/span>.<\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    Today, I complete my tour through the C++20 core language features with a few small improvements. One interesting of these minor improvements is that most of volatile has been deprecated.<\/p>\n","protected":false},"author":21,"featured_media":5945,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[428,458,457],"class_list":["post-5973","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-constexpr","tag-enum","tag-volatile"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5973","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5973"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5973\/revisions"}],"predecessor-version":[{"id":6730,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5973\/revisions\/6730"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5945"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5973"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5973"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5973"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}