{"id":4426,"date":"2022-01-17T08:09:45","date_gmt":"2022-01-17T06:09:45","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=4426"},"modified":"2022-01-17T08:09:47","modified_gmt":"2022-01-17T06:09:47","slug":"three-cpp23-features-for-common-use","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2022\/01\/17\/three-cpp23-features-for-common-use\/","title":{"rendered":"Three C++23 features for common use"},"content":{"rendered":"\n

C++23 is the current working version of the C++ standard. No major feature has been included so far, but a series of smaller ones as well as many defect reports have made it already to the standard. You can check the current status as well as the compiler support for the new features here<\/a>. Many of these new features are small improvements or things you probably wouldn’t use on a regular basis. However, I want to point here to three C++23 features that, in my opinion, stand out among the others as more likely to be used more often.<\/p>\n\n\n\n\n\n\n\n

Literal suffixes for size_t and ptrdiff_t<\/h2>\n\n\n\n

std::size_t<\/a> is an unsigned data type (of at least 16 bits) that can hold the maximum size of an object of any type. It can safely store the index of an array on any platform. It is the type returned by the sizeof<\/code>, sizeof...<\/code>, and alignof<\/code> operators.<\/p>\n\n\n\n

std::ptrdiff_t<\/a> is a signed data type (of at least 17 bits) that represents the type of the result of subtracting two pointers. <\/p>\n\n\n\n

In C++23, these have their own string literal suffixes.<\/p>\n\n\n\n

Literal suffix<\/th>Deduced type<\/th>Example<\/th><\/tr><\/thead>
uz<\/code> or uZ<\/code> or Uz<\/code> or UZ<\/code><\/td>std::size_t<\/code><\/td>auto a = 42uz;<\/code><\/td><\/tr>
z<\/code> or Z<\/code><\/td>signed std::size_t<\/code> (std::ptrdiff_t<\/code>)<\/td>auto b = -42z;<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Let’s see how this is useful. In C++20, we could write the following:<\/p>\n\n\n\n

std::vector<int> v {1, 1, 2, 3, 5, 8};\nfor(auto i = 0u; i < v.size(); ++i)\n{\n   std::cout << v[i] << '\\n';\n}<\/pre>\n\n\n\n
The deduced type of the variable i<\/code> is unsigned int<\/code>. This works fine on 32-bit, where both unsigned int<\/code> and size_t<\/code>, which is the return type of the size()<\/code> member function, are 32-bit. But on 64-bit you may get a warning and the value is truncated, because unsigned int<\/code> is still 32-bit but size_t<\/code> is 64-bit.<\/p>\n\n\n\n
On the other hand, we can have the following:<\/p>\n\n\n\n
std::vector<int> v {1, 1, 2, 3, 5, 8};\nauto m = std::max(42, std::ssize(v)); \/\/ compiles on 32-bit but fails on 64-bit<\/pre>\n\n\n\n
std::vector<int> v {1, 1, 2, 3, 5, 8};\nauto m = std::max(42ll, std::ssize(v)); \/\/ compiles on 64-bit but fails on 32-bit<\/pre>\n\n\n\n
Neither of these two versions work on both 32-bit and 64-bit platforms.<\/p>\n\n\n\n
This is where the new literal suffixes help:<\/p>\n\n\n\n
std::vector<int> v {1, 1, 2, 3, 5, 8};\nfor(auto i = 0uz; i < v.size(); ++i)\n{\n   std::cout << v[i] << '\\n';\n}\n\nauto m = std::max(42z, std::ssize(v));<\/pre>\n\n\n\n
This code works the same on all platforms.<\/p>\n\n\n\n
See more<\/strong>:<\/p>\n\n\n\n