{"id":5802,"date":"2019-10-27T06:14:18","date_gmt":"2019-10-27T06:14:18","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-the-core-language\/"},"modified":"2023-06-26T09:58:50","modified_gmt":"2023-06-26T09:58:50","slug":"c-20-the-core-language","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-the-core-language\/","title":{"rendered":"C++ 20: The Core Language"},"content":{"rendered":"

My last post C++20: The Big Four <\/a>started with an overview of concepts, ranges, coroutines, and modules. Of course, C++20 has more to offer. Today, let’s continue my overview of the core language.<\/p>\n

<\/p>\n

 \"TimelineCpp20Core\"<\/p>\n

<\/span>Core Language<\/span><\/h2>\n

Looking at the image, you see the features I want to cover.<\/p>\n

<\/span>The three-way Comparison operator <=><\/span><\/h3>\n

The three-way comparison operator <=><\/span> is often just called the spaceship operator. The spaceship operator determines whether A < B, A = B, or A > B for two values A and B.<\/p>\n

The compiler can auto-generate the three-way comparison operator. You have only to ask for it politely with default.<\/span> In this case, you get all six comparison operators such as ==, !=, <, <=, >, <\/span>and >=. <\/span><\/p>\n

\n
#include <compare><\/span>\r\nstruct<\/span> MyInt {\r\n  int<\/span> value;\r\n  MyInt(int<\/span> value):<\/span> value{value} { }\r\n  auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span>) const<\/span> =<\/span> default<\/span>;\r\n};\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The default operator <=> performs lexicographical comparison starting the base classes left to right and using the non-static members in declaration order. Here is a quite sophisticated example from the Microsoft blog: Simplify Your Code with Rocket Science: C++ 20’s Spaceship Operator.<\/a>
<\/span><\/p>\n
 <\/p>\n
\n
struct<\/span> Basics {\r\n  int<\/span> i;\r\n  char<\/span> c;\r\n  float<\/span> f;\r\n  double<\/span> d;\r\n  auto<\/span> operator<\/span><=><\/span>(const<\/span> Basics&<\/span>) const<\/span> =<\/span> default<\/span>;\r\n};\r\n \r\nstruct<\/span> Arrays {\r\n  int<\/span> ai[1<\/span>];\r\n  char<\/span> ac[2<\/span>];\r\n  float<\/span> af[3<\/span>];\r\n  double<\/span> ad[2<\/span>][2<\/span>];\r\n  auto<\/span> operator<\/span><=><\/span>(const<\/span> Arrays&<\/span>) const<\/span> =<\/span> default<\/span>;\r\n};\r\n \r\nstruct<\/span> Bases :<\/span> Basics, Arrays {\r\n  auto<\/span> operator<\/span><=><\/span>(const<\/span> Bases&<\/span>) const<\/span> =<\/span> default<\/span>;\r\n};\r\n \r\nint<\/span> main<\/span>() {\r\n  constexpr Bases a =<\/span> { { 0<\/span>, 'c'<\/span>, 1.f<\/span>, 1.<\/span> },\r\n                        { { 1<\/span> }, { 'a'<\/span>, 'b'<\/span> }, { 1.f<\/span>, 2.f<\/span>, 3.f<\/span> }, { { 1.<\/span>, 2.<\/span> }, { 3.<\/span>, 4.<\/span> } } } };\r\n  constexpr Bases b =<\/span> { { 0<\/span>, 'c'<\/span>, 1.f<\/span>, 1.<\/span> },\r\n                        { { 1<\/span> }, { 'a'<\/span>, 'b'<\/span> }, { 1.f<\/span>, 2.f<\/span>, 3.f<\/span> }, { { 1.<\/span>, 2.<\/span> }, { 3.<\/span>, 4.<\/span> } } } };\r\n  static_assert(a ==<\/span> b);\r\n  static_assert(!<\/span>(a !=<\/span> b));\r\n  static_assert(!<\/span>(a <<\/span> b));\r\n  static_assert(a <=<\/span> b);\r\n  static_assert(!<\/span>(a ><\/span> b));\r\n  static_assert(a >=<\/span> b);\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I assume the most complicated stuff in this code snippet is not the spaceship operator but the initialization of Base<\/span> using aggregate initialization. Aggregate initialization essential means that you can directly initialize the members of class types (class<\/span>, struct,<\/span> or union)<\/span> if all members are public. You can use, in this case, a braced-initialization list such as in the example. Okay, this was a simplification. Read the details here: aggregate initialization<\/a>. <\/p>\n<\/p>\n
<\/span>String Literals as Template Parameters<\/span><\/h3>\n
Before C++20, you could not use a string as a non-type template parameter. With C++20, you can use it. The idea is to use the standard defined basic_fixed_string<\/span>, which has a constexpr<\/span> constructor. The constexpr<\/span> constructor enables it to instantiate the fixed string at compile-time.<\/p>\n
 <\/p>\n
\n
template<\/span><std::basic_fixed_string<\/span> T><\/span>\r\nclass<\/span> Foo<\/span> {\r\n    static<\/span> constexpr char<\/span> const<\/span>*<\/span> Name =<\/span> T;\r\npublic:<\/span>\r\n    void<\/span> hello() const<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n    Foo<<\/span>\"Hello!\"<\/span>><\/span> foo;\r\n    foo.hello();\r\n}\r\n<\/pre>\n<\/div>\n
<\/span>constexpr<\/span> Virtual Functions<\/span><\/h3>\n
Virtual functions can not be invoked in constant expressions because the dynamic type is unknown. This restriction will fall with C++20.<\/p>\n
<\/span>Designated initializers<\/span><\/h3>\n
Let me first write about aggregate initialization. Here is a straightforward example.<\/p>\n
\n
\/\/ aggregateInitialisation.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nstruct<\/span> Point2D{\r\n    int<\/span> x;\r\n    int<\/span> y;\r\n};\r\n\r\nclass<\/span> Point3D<\/span>{\r\npublic:<\/span>\r\n    int<\/span> x;\r\n    int<\/span> y;\r\n    int<\/span> z;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    Point2D point2D {1<\/span>, 2<\/span>};\r\n    Point3D point3D {1<\/span>, 2<\/span>, 3<\/span>};\r\n\r\n    std::<\/span>cout <<<\/span> \"point2D: \"<\/span> <<<\/span> point2D.x <<<\/span> \" \"<\/span> <<<\/span> point2D.y <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"point3D: \"<\/span> <<<\/span> point3D.x <<<\/span> \" \"<\/span> <<<\/span> point3D.y <<<\/span> \" \"<\/span> <<<\/span> point3D.z <<<\/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
I assume an explanation of the program is not necessary. Here is the output of the program:<\/p>\n
\"aggregateInitialisation\"<\/p>\n
Explicit is better than implicit. Let’s see what that means. The initialization in the program aggregateInitialisation.cpp<\/span> is quite error-prone because you can swap the constructor arguments, and you will never notice. Here designated initializers from C99<\/a> kick in.<\/p>\n
 <\/p>\n
\n
\/\/ designatedInitializer.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nstruct<\/span> Point2D{\r\n    int<\/span> x;\r\n    int<\/span> y;\r\n};\r\n\r\nclass<\/span> Point3D<\/span>{\r\npublic:<\/span>\r\n    int<\/span> x;\r\n    int<\/span> y;\r\n    int<\/span> z;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    Point2D point2D {.x =<\/span> 1<\/span>, .y =<\/span> 2<\/span>};\r\n    \/\/ Point2D point2d {.y = 2, .x = 1};         \/\/ (1) error<\/span>\r\n    Point3D point3D {.x =<\/span> 1<\/span>, .y =<\/span> 2<\/span>, .z =<\/span> 2<\/span>};   \r\n    \/\/ Point3D point3D {.x = 1, .z = 2}          \/\/ (2)  {1, 0, 2}<\/span>\r\n    \r\n\r\n    std::<\/span>cout <<<\/span> \"point2D: \"<\/span> <<<\/span> point2D.x <<<\/span> \" \"<\/span> <<<\/span> point2D.y <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"point3D: \"<\/span> <<<\/span> point3D.x <<<\/span> \" \"<\/span> <<<\/span> point3D.y <<<\/span> \" \"<\/span> <<<\/span> point3D.z <<<\/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
The arguments for the instances of Point2d<\/span> and Point3D<\/span> are explicitly named. The program’s output is identical to the output of the program aggregateInitialisation.cpp<\/span>. The commented outlines (1) and (2) are pretty interesting. Line (1) would give an error because the order of the designator does not match their declaration order. The designator for y is missing inline (3). In this case, y would be initialized to 0 using braces-initialization-list {1, 0, 3}.<\/span><\/p>\n
<\/span>Various Lambda Improvements<\/span><\/h3>\n
Lambas will have many improvements in C++20.<\/p>\n
If you want more details, go to Bartek’s post<\/a> about lambda improvements in C++17 and C++20 or wait for my detailed posts. Anyway, here are two exciting changes we will get.<\/p>\n