{"id":5232,"date":"2017-03-31T05:48:49","date_gmt":"2017-03-31T05:48:49","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-17-what-s-new-in-the-library\/"},"modified":"2023-06-26T12:18:44","modified_gmt":"2023-06-26T12:18:44","slug":"c-17-what-s-new-in-the-library","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-17-what-s-new-in-the-library\/","title":{"rendered":"C++17 – What’s New in the Library?"},"content":{"rendered":"

What’s new in the library? A lot. To make the long story short. We get a std::string_view<\/span>, parallel algorithm of the Standard Template Library, a file system library, and the three new data types <\/span>std::any<\/span>, std::optional<\/span>, and std::variant.<\/span> Let’s look at the details.<\/p>\n

<\/p>\n

 <\/p>\n

\"timeline\"<\/p>\n

Our journey starts with std::string_view<\/span>.<\/p>\n

std::string_view<\/h2>\n

A std::string_view<\/span> is a non-owning reference to a string. 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

std::string_view      std::basic_string_view<char<\/span>>\r\nstd::wstring_view     std::basic_string_view<wchar_t<\/span>>\r\nstd::u16string_view   std::basic_string_view<char16_t<\/span>>\r\nstd::u32string_view   std::basic_string_view<char32_t<\/span>>
\r\n<\/pre>\n
The question remains. Why do we need a std::string_view?<\/span> Why had Google, LLVM, and Bloomberg already an implementation of a string view? The answer is easy. It’s pretty cheap to copy a std::string_view<\/span>. A std::string_view<\/span> only needs two pieces of information: the pointer to the character sequence and their length. As you may assume, the std::string_view<\/span> and its three siblings consist mainly of reading operations that follow the interface of std::string<\/span>. Mainly because it gets the new methods remove_prefix<\/span> and remove_suffix<\/span>.<\/p>\n
 <\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24<\/pre>\n<\/td>\n
\n
\/\/ string_view.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <experimental\/string_view><\/span>\r\n\r\nint<\/span> main(){\r\n    \r\n  std::string str = \"   A lot of space\"<\/span>;\r\n  std::experimental::string_view strView = str;\r\n  strView.remove_prefix(std::min(strView.find_first_not_of(\" \"<\/span>), strView.size()));\r\n  std::cout << \"str      :  \"<\/span> << str << std::endl \r\n            << \"strView  : \"<\/span> << strView << std::endl;\r\n                 \r\n  std::cout << std::endl;\r\n\r\n  char<\/span> arr[] = {'A'<\/span>,' '<\/span>,'l'<\/span>,'o'<\/span>,'t'<\/span>,' '<\/span>,'o'<\/span>,'f'<\/span>,' '<\/span>,'s'<\/span>,'p'<\/span>,'a'<\/span>,'c'<\/span>,'e'<\/span>,'\\0'<\/span>, '\\0'<\/span>, '\\0'<\/span>};\r\n  std::experimental::string_view strView2(arr, sizeof<\/span> arr);\r\n  auto<\/span> trimPos = strView2.find('\\0'<\/span>);\r\n  if<\/span>(trimPos != strView2.npos) strView2.remove_suffix(strView2.size() - trimPos);\r\n  std::cout << \"arr     : \"<\/span> << arr << \", size=\"<\/span> << sizeof<\/span> arr << std::endl\r\n            << \"strView2: \"<\/span> << strView2 << \", size=\"<\/span> << strView2.size() << std::endl;\r\n              \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The program should not surprise you. The std::string_view<\/span>‘s in lines 10 and 18 get their C++-string and character-array reference. In line 11, all leading non-spaces (strView.find_first_not_of(” “)<\/span>) are removed, and in line 20, all trailing “\\0”-characters (strView2.find(‘\\0″)<\/span>) are removed. By using the namespace experimental<\/span>, I can already execute the program at cppreference.com<\/a>.<\/p>\n
 \"string<\/p>\n
Now, to something more familiar.<\/p>\n<\/p>\n
Parallel algorithm of the Standard Template Library<\/h2>\n
My story is relatively short. 69 Standard Template Library algorithms (STL) algorithms will be available in sequential, parallel, parallel, and vectorized version. Additionally, we get eight new algorithms. Look at the 69 new variants (black) and the 8 (red) new algorithms.<\/p>\n
 \"stl\"<\/p>\n
 <\/p>\n
That was all. I already wrote a post Parallel Algorithm of the Standard Template Library<\/a>. On the contrary, the filesystem library should be new to you.<\/p>\n
The filesystem library<\/h2>\n
The new filesystem library is based on boost::filesystem<\/a>. Some of its components are optional. That means not all functionality of std::filesytem<\/span> is available on each implementation of the filesystem library. For example, FAT-32 does not support symbolic links.<\/p>\n
The library uses three concepts file, file name, and path. Files can be directories, hard links, symbolic links, or regular files. Paths can be absolute or relative.<\/p>\n
There is a powerful interface for reading and manipulating the filesystem. Use cppreference.com<\/a> for the details. Here is a first impression.<\/p>\n
 <\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30<\/pre>\n<\/td>\n
\n
\/\/ filesystem.cpp<\/span>\r\n\r\n#include <fstream><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <experimental\/filesystem><\/span>\r\nnamespace<\/span> fs = std::experimental::filesystem;\r\n \r\nint<\/span> main(){\r\n\r\n    std::cout << \"Current path: \"<\/span> << fs::current_path() << std::endl;\r\n\r\n    std::string dir= \"sandbox\/a\/b\"<\/span>;\r\n    fs::create_directories(dir);\r\n\r\n    std::ofstream(\"sandbox\/file1.txt\"<\/span>);\r\n    fs::path symPath= fs::current_path() \/=  \"sandbox\"<\/span>;\r\n    symPath \/= \"syma\"<\/span>;\r\n    fs::create_symlink(\"a\"<\/span>, \"symPath\"<\/span>);\r\n    \r\n    std::cout << \"fs::is_directory(dir): \"<\/span> << fs::is_directory(dir) << std::endl;\r\n    std::cout << \"fs::exists(symPath): \"<\/span>  << fs::exists(symPath) << std::endl;\r\n    std::cout << \"fs::symlink(symPath): \"<\/span> << fs::is_symlink(symPath) << std::endl;\r\n    \r\n\r\n    for<\/span>(auto<\/span>& p: fs::recursive_directory_iterator(\"sandbox\"<\/span>))\r\n        std::cout << p << std::endl;\r\n    \/\/ fs::remove_all(\"sandbox\");<\/span>\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
fs::current_path()<\/span> in line 11 returns the current path. You can create a directory hierarchy (line 14) with std::filesystem.<\/span> Line 18 looks a little bit odd. The \/=<\/span> is overloaded for a path. Therefore, I can directly create a symbolic link in line 19. You can check the properties of a file (lines 21 – 23).   The call recursive_directory_iterator<\/span> in line 26 is quite powerful. You can use it to traverse directories recursively. Of course, I can not remove a directory (line 28) on an online compiler.<\/p>\n
Here is the output of the program.<\/p>\n
\"filesystem\"<\/p>\n
What has the new data type std::any, std::optional, <\/span>and<\/span> std::variant <\/span>in common? They are based on boost.<\/a><\/p>\n
std::any<\/h2>\n
std::any<\/span> will be the right choice if you want a container with an arbitrary type. The arbitrary type is not a hundred percent correct. std::any<\/span> requires, that its values must be copyable. Here is a short example.<\/p>\n
 <\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23<\/pre>\n<\/td>\n
\n
\/\/ any.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n#include <any><\/span>\r\n\r\nstruct<\/span> MyClass{};\r\n\r\nint<\/span> main(){\r\n    \r\n    std::cout << std::boolalpha;\r\n    \r\n    std::vector<std::any> anyVec(true,2017,std::string(\"test\"<\/span>),3.14,MyClass());\r\n    std::cout << \"std::any_cast<bool>anyVec[0]: \"<\/span> << std::any_cast<bool<\/span>>(anyVec[0]); \/\/ true<\/span>\r\n    int<\/span> myInt= std::any_cast<int<\/span>>(anyVec[1]);                                        \r\n    std::cout << \"myInt: \"<\/span> << myInt << std::endl;                                    \/\/ 2017<\/span>\r\n    \r\n    std::cout << std::endl;\r\n    std::cout << \"anyVec[0].type().name(): \"<\/span> << anyVec[0].type().name();             \/\/ b<\/span>\r\n    std::cout << \"anyVec[1].type().name(): \"<\/span> << anyVec[1].type().name();             \/\/ i<\/span>\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The output of the program is in the source code. Line 14 defines a std::vector<std::any><\/span>. To get one of its elements, you have to use std::any_cast<\/span>. If you use the wrong type, you will get a std::bad_any_cast<\/span> exception. For further details, go to cppreferenc.com <\/a>or wait for my additional post.<\/p>\n
std::any<\/span> can have values of arbitrary types, std::optional<\/span> can have a value or no value.<\/p>\n
std::optional<\/h2>\n
I will make it relatively short. In the post Monads in C++<\/a>, I already wrote about the monad std::optional. <\/span><\/p>\n
The third new data type from boost is std::variant.<\/span><\/p>\n
std::variant<\/h2>\n
A std::variant<\/span> is a type-safe union. An instance of std::variant<\/span> has a value from one of its types. The type must not be a reference, array, or void.<\/span> A union can have one type more than once. A default-initialized std::variant<\/span> will be initialized with its first type. In this case, the first type must have a default constructor. Here is an example based on cppreference.com.<\/a> <\/p>\n
 <\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26<\/pre>\n<\/td>\n
\n
\/\/ variant.cpp<\/span>\r\n\r\n#include <variant><\/span>\r\n#include <string><\/span>\r\n \r\nint<\/span> main(){\r\n\r\n  std::variant<int<\/span>, float<\/span>> v, w;\r\n  v = 12;                              \/\/ v contains int<\/span>\r\n  int<\/span> i = std::get<int<\/span>>(v);\r\n  w = std::get<int<\/span>>(v);\r\n  w = std::get<0>(v);                  \/\/ same effect as the previous line<\/span>\r\n  w = v;                               \/\/ same effect as the previous line<\/span>\r\n \r\n  \/\/  std::get<double>(v);             \/\/ error: no double in [int, float]<\/span>\r\n  \/\/  std::get<3>(v);                  \/\/ error: valid index values are 0 and 1<\/span>\r\n \r\n  try{\r\n    std::get<float<\/span>>(w);                \/\/ w contains int, not float: will throw<\/span>\r\n  }\r\n  catch<\/span> (std::bad_variant_access&) {}\r\n \r\n  std::variant<std::string> v(\"abc\"<\/span>);  \/\/ converting constructors work when unambiguous<\/span>\r\n  v = \"def\"<\/span>;                           \/\/ converting assignment also works when unambiguous<\/span>\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I define in line 8 both variants v<\/span> and w<\/span>. Both can have an int<\/span> and a float<\/span> value. Their value is 0. v<\/span> becomes 12 on line 9. std::get<int>(v)<\/span> returns the value. In lines 11-13, you see three possibilities to assign variant v<\/span> the variant w.<\/span> But you have to keep a few rules in mind. You can ask for the value of a variant by type (line 15) or index (line 16). The type must be unique and the index valid. On line 19, the variant w<\/span> holds an int<\/span> value. Therefore, I get a std::bad_variant_access<\/span> exception in line 21. A conversion can occur if the constructor call or assignment call is unambiguous. That is why it’s possible to construct a std::variant<std::string><\/span> in line 23 with a C-string or assign a new C-string to the variant (line 24).<\/p>\n
 What’s next?<\/h2>\n
I stick with the C++17 standard. After I gave in this and the last post an overview of the core language and the library, I will dive into the next post<\/a> into the details (Proofreader Marc Bertola<\/strong>).<\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
What’s new in the library? A lot. To make the long story short. We get a std::string_view, parallel algorithm of the Standard Template Library, a file system library, and the three new data types std::any, std::optional, and std::variant. Let’s look at the details.<\/p>\n","protected":false},"author":21,"featured_media":4724,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[370],"tags":[463],"class_list":["post-5232","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-17","tag-string"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5232","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=5232"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5232\/revisions"}],"predecessor-version":[{"id":6876,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5232\/revisions\/6876"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4724"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5232"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5232"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5232"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}