{"id":10290,"date":"2025-01-13T11:42:00","date_gmt":"2025-01-13T11:42:00","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10290"},"modified":"2025-07-03T14:20:50","modified_gmt":"2025-07-03T14:20:50","slug":"c26-library-string-and-string_view-processing","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c26-library-string-and-string_view-processing\/","title":{"rendered":"C++26 Library: string and string_view Processing"},"content":{"rendered":"\n

C++26 offers many small improvements around string<\/code>s and string_view<\/code>s.<\/code><\/p>\n\n\n\n

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

First of all: What is a string_view?<\/code><\/p>\n\n\n\n

std::string_view<\/h2>\n\n\n\n

A std::string_view <\/code>is a non-owning reference to a string<\/code>. It represents a view of a sequence of characters. This sequence of characters can be a C++ string or a C-string. In a typical way, C++17 offers four type synonyms for the underlying character types.<\/p>\n\n\n\n

std::<\/span>string_view      std::<\/span>basic_string_view<<\/span>char<\/span>><\/span>\nstd::<\/span>wstring_view     std::<\/span>basic_string_view<<\/span>wchar_t<\/span>><\/span>\nstd::<\/span>u16string_view   std::<\/span>basic_string_view<<\/span>char16_t<\/span>><\/span>\nstd::<\/span>u32string_view   std::<\/span>basic_string_view<<\/span>char32_t<\/span>><\/span>\n<\/pre><\/div>\n\n\n\n
One question remains. Why do we need a std::string_view<\/code>? Why had Google, LLVM, and Bloomberg already an implementation of a string view? The answer is easy. It\u2019s pretty cheap to copy a std::string_view. <\/code>A std::string_view<\/code> only needs two pieces of information: the pointer to the character sequence and their length. As you may assume, the std::string_view<\/code> and its three siblings consist mainly of reading operations that follow the interface of std::string.<\/code> Mainly because it gets the new methods remove_prefix <\/code>and remove_suffix<\/code>.<\/p>\n\n\n\n
Testing for Success or Failure of <charconv<\/code>> Functions<\/h2>\n\n\n\n
The functions std::to_chars<\/code> and  std::from_chars<\/code> was inconvenient to test: if(res.ec == std::errc{})<\/code>.<\/p>\n\n\n\n
 Here’s a simplified program from https:\/\/en.cppreference.com\/w\/cpp\/utility\/to_chars<\/a>.<\/p>\n\n\n\n
\/\/ charconv.cpp <\/span>\n \n#include <charconv><\/span>\n#include <iomanip><\/span>\n#include <iostream><\/span>\n#include <string_view><\/span>\n#include <system_error><\/span>\n \ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nvoid<\/span> show_to_chars(T value) {\n    const<\/span> size_t<\/span> buf_size =<\/span> 5<\/span>;\n    char<\/span> buf[buf_size];\n    std::<\/span>to_chars_result result =<\/span> std::<\/span>to_chars(buf, buf +<\/span> buf_size, value);\n \n    if<\/span> (result.ec !=<\/span> std::<\/span>errc{})\n        std::<\/span>cout <<<\/span> std::<\/span>make_error_code(result.ec).message() <<<\/span> '\\n'<\/span>;\n    else<\/span>{\n        std::<\/span>string_view str(buf, result.ptr -<\/span> buf);\n        std::<\/span>cout <<<\/span> std::<\/span>quoted(str) <<<\/span> '\\n'<\/span>;\n    }\n}\n \nint<\/span> main() {\n    show_to_chars(42<\/span>);\n    show_to_chars(1234567<\/span>);  \n}\n<\/pre><\/div>\n\n\n\n
The program includes the headers <charconv><\/code> for character conversion, <iomanip><\/code> for input\/output manipulators,  <string_view><\/code> for handling string_view<\/code>s, and <system_error><\/code> for error handling.<\/p>\n\n\n\n
The show_to_chars <\/code>function template takes a value of any type T<\/code> and tries to convert it to a character sequence. Inside the function, a buffer of size 5 is declared to hold the resulting character sequence. The std::to_chars<\/code> function is then called to perform the conversion, storing the result in a std::to_chars_result<\/code> object named result<\/code>.<\/p>\n\n\n\n
The result<\/code> object contains a pointer to the end of the converted character sequence and an error code. If the error code is not equal to std::errc{}<\/code>, indicating an error occurred during conversion, an error message is printed to the console using std::make_error_code(result.ec).message()<\/code>. Otherwise, a std::string_view<\/code> object is created to represent the converted character sequence, and the sequence is printed to the console using std::quoted<\/code> to ensure it is displayed within double quotes.<\/p>\n\n\n\n
In the main <\/code>function, the show_to_chars <\/code>function is called twice: first with the value 42<\/code> and then with the value 1234567<\/code>. The first call successfully converts the value 42<\/code> to a character sequence and prints it. However, the second call attempts to convert the value 1234567<\/code>, which exceeds the buffer size of 5, resulting in an error message being printed to the console.<\/p>\n\n\n\n
Finally, here comes the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Thanks to C++26, the function std::to_chars <\/code>retuns a boolean and the function show_to_chars <\/code>can be simplified:<\/p>\n\n\n\n
template<\/span> <<\/span>typename<\/span> T><\/span>\nvoid<\/span> show_to_chars(T value) {\n    std::<\/span>array<<\/span>char<\/span>, 5<\/span>><\/span> str;\n    if<\/span> (auto<\/span> result =<\/span> std::<\/span>to_chars(str.data(), str.data() +<\/span> str.size(), value)) {\n            std::<\/span>string_view strView(str.data(), result.ptr);\n            std::<\/span>cout <<<\/span> std::<\/span>quoted(strView) <<<\/span> '\\n'<\/span>;\n        }\n    else<\/span>\n        std::<\/span>cout <<<\/span> std::<\/span>make_error_code(result.ec).message() <<<\/span> '\\n'<\/span>;\n}\n<\/pre><\/div>\n\n\n\n
Inside the function, a std::array<\/code> of characters with a fixed size of 5 is declared to hold the resulting character sequence. The std::to_chars<\/code> function is then called to perform the conversion. This function attempts to convert the numeric value value<\/code> into a character sequence and store it in the str<\/code> array. The std::to_chars<\/code> function returns a std::to_chars_result<\/code> object, which contains a pointer to the end of the converted character sequence and an error code.<\/p>\n\n\n\n
The function uses an if<\/code> statement to check the result of the std::to_chars<\/code> call. If the conversion is successful, the result<\/code> object will be implicitly convertible to true<\/code>, and the function will proceed to print the converted character sequence. This is done by creating a std::string_view<\/code> object named strView<\/code> that represents the character sequence from the beginning of the str<\/code> array up to the result.ptr<\/code> pointer. The std::cout<\/code> stream is then used to print this string view to the console, with std::quoted<\/code> ensuring the output is displayed within double quotes.<\/p>\n\n\n\n
If the conversion fails, the result <\/code>bject will be implicitly convertible to false<\/code>, and the function will print an error message instead. The error message is obtained by calling std::make_error_code(result.ec).message()<\/code>, which converts the error code to a human-readable string.<\/p>\n\n\n\n
 They are further string <\/code>and string_view<\/code> processing functions in C++26:<\/p>\n\n\n\n