{"id":5227,"date":"2017-03-24T21:05:59","date_gmt":"2017-03-24T21:05:59","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/cpp17-core\/"},"modified":"2017-03-24T21:05:59","modified_gmt":"2017-03-24T21:05:59","slug":"cpp17-core","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/cpp17-core\/","title":{"rendered":"C++17 – What’s New in the Core Language?"},"content":{"rendered":"

C++11, C++14, and C++17. I guess you see the pattern.  Later this year, we will get a new C++ standard. In March 2017, the C++17 specification reached the Draft International Standard stage. Before I dive into the details, I will give you an overview of C++17.<\/p>\n

<\/p>\n

 <\/p>\n

Let me first look at the big picture.<\/p>\n

The big picture<\/h2>\n

 <\/p>\n

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

Concerning C++98 to C++14, I only mentioned the big points. But, there is a C++ standard missing in my graphic: C++03. This is intentional because C++03 is a minimal C++ standard. More like a bug-fix release to C++98. If you know C++, you know, that the first ISO standard C++98 and the ISO standard C++11 are extensive standards. That will not hold for C++14 and in particular, for C++03.<\/p>\n

So the question is. Is C++17 a big C++ standard or a small one? From my perspective, the answer is relatively easy. C++17 is something in between C++14 and C++11. So, C++17 is neither big nor small. Why? Here comes my short answer.<\/p>\n<\/p>\n

Overview<\/h2>\n

C++17 has a lot to offer. That will hold for the core language and the library. Let’s first look at the core language.<\/p>\n

Core language<\/h3>\n

Fold expressions<\/h4>\n

C++11 supports variadic templates. These are templates that can accept an arbitrary number of arguments. A parameter pack holds the arbitrary number. Additionally, with C++17, you can directly reduce a parameter pack with a binary operator:<\/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<\/pre>\n<\/td>\n
\n
\/\/ foldExpressionAll.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><typename<\/span>... Args>\r\nbool<\/span> all(Args... args) { return<\/span> (... && args); }\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::boolalpha;\r\n\r\n  std::cout << \"all(): \"<\/span> << all() << std::endl;\r\n  std::cout << \"all(true): \"<\/span> << all(true) << std::endl;\r\n  std::cout << \"all(true, true, true, false): \"<\/span> << all(true, true, true, false) << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
 The binary operator is the logical AND in line 6. Here is the output of the program.<\/p>\n
\"foldExpression\"<\/p>\n
That’s all I have to say about fold expressions because I have already written a post about fold expressions<\/a>. So, there you have the details.<\/p>\n
We stay at compile time.<\/p>\n
constexpr if<\/h4>\n
constexpr if<\/span> it enables it to compile source code conditionally.<\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7<\/pre>\n<\/td>\n
\n
template<\/span> <typename<\/span> T>\r\nauto<\/span> get_value(T t) {\r\n    if<\/span> constexpr (std::is_pointer_v<T>)\r\n        return<\/span> *t; \/\/ deduces return type to int for T = int*<\/span>\r\n    else<\/span>\r\n        return<\/span> t;  \/\/ deduces return type to int for T = int<\/span>\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
If T<\/span> is a pointer, the if branch in line 3 will be compiled. If not, the else branch is in line 5. Two points are essential to mention. The function get_value<\/span> has two different return types, and both branches of the if the statement has to be valid.<\/p>\n
Consequently, what is possible with for<\/span> statements is with C++17 possible with if<\/span> and switch<\/span> statements.<\/p>\n
Initializers in if and switch statements<\/h4>\n
You can directly initialize your variable inside the if<\/span> and switch<\/span> statement.<\/p>\n
 <\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9<\/pre>\n<\/td>\n
\n
std::map<int<\/span>,std::string> myMap;\r\n\r\nif<\/span> (auto<\/span> result = myMap.insert(value); result.second){\r\n    useResult(result.first);  \r\n    \/\/ ...<\/span>\r\n} \r\nelse<\/span>{\r\n    \/\/ ...<\/span>\r\n} \/\/ result is automatically destroyed<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Therefore, the variable result<\/span> is valid inside the if<\/span> and else<\/span> branches of the if<\/span> statement. But result<\/span> will not pollute the outer scope.<\/p>\n
If you use the initializer in if<\/span> and switch<\/span> statements in combination with the structured binding declaration, the C++ syntax will be more elegant.<\/p>\n
Structured binding declarations<\/h4>\n
Thanks to the structured binding, you can bind a std::tuple<\/span> or a struct<\/span> directly to variables. Therefore I can still improve my last example.<\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9<\/pre>\n<\/td>\n
\n
std::map<int<\/span>,std::string> myMap;\r\n                \r\nif<\/span> (auto<\/span> [iter, succeeded] = myMap.insert(value); succeeded) {\r\n    useIter(iter);  \r\n    \/\/ ...<\/span>\r\n}\r\nelse<\/span>{\r\n    \/\/ ...<\/span>\r\n} iter and succeded are automatically be destroyed\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
auto [iter, succeeded]<\/span> in line 3 automatically creates the two variables iter<\/span> and succeeded. <\/span>They will be destroyed at line 9. <\/span><\/p>\n
One of these features that make programming less cumbersome. The same holds for template deduction of constructors.<\/p>\n
Template deduction of constructors<\/h4>\n
A function template can deduce its type parameters from its function arguments. But that was not possible for a unique function template: the constructor of a class template. With C++17, this statement is simply wrong. A constructor can deduce its type parameters from its constructor arguments.<\/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<\/pre>\n<\/td>\n
\n
\/\/ templateArgumentDeduction.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nvoid<\/span> showMe(const<\/span> T& t){\r\n  std::cout << t << std::endl;\r\n}\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nstruct<\/span> ShowMe{\r\n  ShowMe(const<\/span> T& t){\r\n    std::cout << t << std::endl;\r\n  }\r\n};\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n    \r\n  showMe(5.5);          \/\/ not showMe<double>(5.5);<\/span>\r\n  showMe(5);            \/\/ not showMe<int>(5);<\/span>\r\n    \r\n  ShowMe<double<\/span>>(5.5);  \/\/ with C++17: ShowMe(5.5);<\/span>\r\n  ShowMe<int<\/span>>(5);       \/\/ with C++17: ShowMe(5);<\/span>\r\n  \r\n  std::cout << std::endl;\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Line 11 and 22 are possible in C++ since the first C++ standard. Lines 24 and 25 will be possible with C++17. Hence, you do not have to use angle brackets to instantiate a class template.<\/p>\n
There is not just usability. Additionally, we will get performance features.<\/p>\n
Guaranteed copy elision<\/h4>\n
RVO<\/a><\/strong> stands for R<\/strong>eturn V<\/strong>alue O<\/strong>ptimisation and means that the compiler is allowed to remove unnecessary copy operations. What was until now a possible optimization step becomes in C++17 a guarantee.<\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4<\/pre>\n<\/td>\n
\n
MyType func(){\r\n  return<\/span> MyType{};         \/\/ no copy with C++17<\/span>\r\n}\r\nMyType myType = func();    \/\/ no copy with C++17<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Two unnecessary copy operations can happen in these few lines. The first one is in line 2 and the second one is in line 4. With C++17, both copy operations must go. <\/p>\n
If the return value has a name, we call it NRVO.<\/strong> Maybe, you guessed it. This acronym stands for N<\/strong>amed R<\/strong>eturn V<\/strong>alue O<\/strong>ptimization.<\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5<\/pre>\n<\/td>\n
\n
MyType func(){\r\n  MyType myVal;\r\n  return<\/span> myVal;            \/\/ one copy allowed <\/span>\r\n}\r\nMyType myType = func();    \/\/ no copy with C++17<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The subtle difference is that the compiler can still copy the value myValue <\/span>according to C++17 (line 3). But no copy will take place in line 5.
<\/span><\/p>\n
If a feature is unnecessary or its application is even dangerous, you should remove it. This will happen in C++17 with std::auto_ptr<\/span> and trigraphs.<\/p>\n
auto_ptr and trigraphs removed<\/h4>\n
auto_ptr<\/h5>\n
std::auto_ptr<\/span> is the first smart pointer in C++. Its job is to take care of one resource. But it had a big issue. If you copy a std::auto_ptr,<\/span> a move operation will occur under the hood. That is the reason we get std::unique_ptr<\/span> with C++11 as the replacement. You can not copy a std::unique_ptr. 
<\/span><\/p>\n
 <\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6<\/pre>\n<\/td>\n
\n
std::auto_ptr<int<\/span>> ap1(new<\/span> int<\/span>(2011));\r\nstd::auto_ptr<int<\/span>> ap2= ap1;              \/\/ OK     (1)<\/span>\r\n\r\nstd::unique_ptr<int<\/span>> up1(new<\/span> int<\/span>(2011));\r\nstd::unique_ptr<int<\/span>> up2= up1;            \/\/ ERROR  (2)<\/span>\r\nstd::unique_ptr<int<\/span>> up3= std::move(up1); \/\/ OK     (3)<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Trigraphs<\/h5>\n
Trigraphs are a sequence of three characters in the source code that are treated as a single character. They will be necessary if your keyboard doesn’t support single characters.<\/p>\n
If you want to write obfuscated code, C++17 maybe not be your language anymore.<\/p>\n
 <\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7<\/pre>\n<\/td>\n
\n
\/\/ trigraphs.cpp<\/span>\r\n\r\nint<\/span> main()??<\r\n\r\n  ??(??)??<??>();\r\n\r\n??>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I guess, you know, what the program is doing? If not, you have to translate the trigraphs to their single-character representation.<\/p>\n
 \"trigraph\"<\/p>\n
If you apply the table, you will solve the riddle. The program represents a lambda function that will be executed just in place.<\/p>\n
 <\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7<\/pre>\n<\/td>\n
\n
\/\/ trigraphsLambda.cpp<\/span>\r\n\r\nint<\/span> main(){\r\n\r\n  []{}();\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
What’s next?<\/h2>\n
That is easy. In the next post, I will write about the library feature we get with C++17. These are the string_view,<\/span> the parallel STL, and the filesystem library. Additionally, we will get the new data types std::any, std::optional,<\/span> and std::variant.<\/span><\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
C++11, C++14, and C++17. I guess you see the pattern.  Later this year, we will get a new C++ standard. In March 2017, the C++17 specification reached the Draft International Standard stage. Before I dive into the details, I will give you an overview of C++17.<\/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":[],"class_list":["post-5227","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-17"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5227","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=5227"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5227\/revisions"}],"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=5227"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5227"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5227"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}