{"id":9947,"date":"2024-09-02T10:58:09","date_gmt":"2024-09-02T10:58:09","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=9947"},"modified":"2025-07-03T16:13:36","modified_gmt":"2025-07-03T16:13:36","slug":"an-overview-of-c26-the-library","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/an-overview-of-c26-the-library\/","title":{"rendered":"An Overview of C++26: The Library"},"content":{"rendered":"\n

In my last post, I overviewed C++26’s core language. Today, I continue with the library.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

To make it short. The library does not offer such powerful features as the core language. Let me name them and give you a short example directly from the proposal.<\/p>\n\n\n\n

<\/span>std::string <\/code>and std::string_view<\/code> Processing<\/span><\/h2>\n\n\n\n

The functions around std::string<\/code> and std::string_view <\/code>makes using them more convenient.<\/p>\n\n\n\n

<\/span>Testing for success or failure of <charconv> functions<\/span><\/h3>\n\n\n\n

Using the functions to_chars <\/code>or from_chars <\/code>was pretty inconvenient. You had to check with res.ec == std::errc{}<\/code> the success of the conversion. With C++26, you can convert the result directly to bool<\/code>.<\/p>\n\n\n\n

<\/span>Arithmetic overloads of std::to_string and use std::format<\/span><\/h3>\n\n\n\n

std::to_string <\/code>has a few issues. The “choice of the floating-point format makes std::to_string<\/code> of very limited use in practice”<\/em> (P2587R3<\/a>).<\/p>\n\n\n\n

auto<\/span> loc =<\/span> std::<\/span>locale("uk_UA.UTF-8"<\/span>);\nstd::<\/span>locale::<\/span>global(loc);\nstd::<\/span>cout.imbue(loc);\nsetlocale(LC_ALL, "C"<\/span>);\n\nstd::<\/span>cout <<<\/span> "iostreams:<\/span>\\n<\/span>"<\/span>;\nstd::<\/span>cout <<<\/span> 1234<\/span> <<<\/span> "<\/span>\\n<\/span>"<\/span>;\nstd::<\/span>cout <<<\/span> 1234.5<\/span> <<<\/span> "<\/span>\\n<\/span>"<\/span>;\n\nstd::<\/span>cout <<<\/span> "<\/span>\\n<\/span>to_string:<\/span>\\n<\/span>"<\/span>;\nstd::<\/span>cout <<<\/span> std::<\/span>to_string(1234<\/span>) <<<\/span> "<\/span>\\n<\/span>"<\/span>;\nstd::<\/span>cout <<<\/span> std::<\/span>to_string(1234.5<\/span>) <<<\/span> "<\/span>\\n<\/span>"<\/span>;\n\nsetlocale(LC_ALL, "uk_UA.UTF-8"<\/span>);\n\nstd::<\/span>cout <<<\/span> "<\/span>\\n<\/span>to_string (uk_UA.UTF-8 C locale):<\/span>\\n<\/span>"<\/span>;\nstd::<\/span>cout <<<\/span> std::<\/span>to_string(1234<\/span>) <<<\/span> "<\/span>\\n<\/span>"<\/span>;\nstd::<\/span>cout <<<\/span> std::<\/span>to_string(1234.5<\/span>) <<<\/span> "<\/span>\\n<\/span>"<\/span>;\n<\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The program shows that the output of floating point overloads is inconsistent for iostreams. It takes the decimal point from the global C locale.<\/p>\n\n\n\n
<\/span>Interfacing stringstreams with std::string_view<\/code><\/span><\/h3>\n\n\n\n
 Thanks to proposal P2495R3<\/a>, you can create a stringstream from a std::string_view<\/code>. In the following example, \"\"sv<\/code> is an empty string_view<\/code> literal.<\/p>\n\n\n\n
\/\/ implicitly convertable to string_view<\/span>\nconst<\/span> mystring str;\n\nstringstream s1<\/span>(""<\/span>sv);\nstringstream s1<\/span>(str);\ns2.str(""<\/span>sv);\n<\/pre><\/div>\n\n\n\n
<\/span>Concatenation of strings and string views<\/span><\/h3>\n\n\n\n
With C++26, you can concatenate strings and string views:<\/p>\n\n\n\n
std::<\/span>string calculate(std::<\/span>string_view prefix)\n{\n  return<\/span> prefix +<\/span> get_string(); \/\/ NO ERROR<\/span>\n}\n<\/pre><\/div>\n\n\n\n
<\/span>Format Extensions<\/span><\/h2>\n\n\n\n
<\/span>Pointers<\/span><\/h3>\n\n\n\n
Before C++26, only void<\/code>, const void<\/code>, and std::nullptr_t<\/code> pointer types are valid. If you want to display the address of an arbitrary pointer, you must cast it to (const) void*<\/code>.<\/p>\n\n\n\n
\ndouble<\/span> d =<\/span> 123.456789<\/span>;\nstd::<\/span>format("{}"<\/span>, &<\/span>d); \/\/ ERROR<\/span>\nstd::<\/span>format("{}"<\/span>, static_cast<\/span><<\/span>void<\/span>*><\/span>(&<\/span>d)); \/\/ okay<\/span>\nstd::<\/span>format("{}"<\/span>, static_cast<\/span><<\/span>const<\/span> void<\/span>*><\/span>(&<\/span>d)); \/\/ okay<\/span>\nstd::<\/span>format("{}"<\/span>, nullptr); \/\/ okay<\/span>\n<\/pre><\/div>\n\n\n\n
With C++26, the error messages are no longer displayed.<\/p>\n\n\n\n
\/\/ pointerFormat.cpp<\/span>\n\n#include <format><\/span>\n#include <iostream><\/span>\n\nint<\/span> main<\/span>() {\n \n     std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    double<\/span> d =<\/span> 123.456789<\/span>;\n\n    std::<\/span>cout <<<\/span> std::<\/span>format("{}"<\/span>, static_cast<\/span><<\/span>void<\/span>*><\/span>(&<\/span>d)) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> std::<\/span>format("{}"<\/span>, static_cast<\/span><<\/span>const<\/span> void<\/span>*><\/span>(&<\/span>d)) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> std::<\/span>format("{}"<\/span>, nullptr) <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
Here’s the output of the program.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
<\/span>std::filesystem::path<\/code><\/span><\/h3>\n\n\n\n
std::format<\/code> can display std::filesystem::path <\/code>objects. The example from the proposal P2845R8<\/a> shows.<\/p>\n\n\n\n
auto<\/strong> p1 = std::filesystem::path(\"\/usr\/bin\");
Ja std::cout << std::format(\"{}\", p1);                           \/\/  \/usr\/bin<\/em>


auto<\/strong> p2 = std::filesystem::path(\"multi\\n<\/strong>line\");
std::cout << std::format(\"{}\", p2);                          \/\/ multi<\/em>
                                                             \/\/ line<\/em>


auto<\/strong> p3 = std::filesystem::path(\"multi\\n<\/strong>line\");
std::cout << std::format(\"{:?}\", p3);                        \/\/ \"multi\\nline\"<\/em>
<\/pre>\n\n\n\n
Thanks to the format string “{:?}<\/code>” in the last line, the escape sequence “\\n<\/code>” is not interpreted.<\/p>\n\n\n\n
<\/span>std::inplace_vector<\/code> <\/span><\/h2>\n\n\n\n
std::inplace_vector <\/code>“is, a dynamically-resizable vector<\/code> with compile-time fixed capacity and contiguous embedded storage in which the elements are stored within the vector object itself.<\/em>” (P0843R8<\/a>)<\/p>\n\n\n\n
This container can be used as a drop-in replacement for std::vector<\/code>. You might ask yourself, when should I use the inplace_vector<\/code> or vector<\/code>.<\/p>\n\n\n\n
 The proposal P0843R8<\/a> gives you the answer:<\/p>\n\n\n\n