{"id":6411,"date":"2022-07-24T16:35:41","date_gmt":"2022-07-24T16:35:41","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/an-the-five-winners-for-c-core-guidelines-best-practices-for-modern-c\/"},"modified":"2022-07-24T16:35:41","modified_gmt":"2022-07-24T16:35:41","slug":"an-the-five-winners-for-c-core-guidelines-best-practices-for-modern-c","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/an-the-five-winners-for-c-core-guidelines-best-practices-for-modern-c\/","title":{"rendered":"And the Five Winners for “C++ Core Guidelines: Best Practices for Modern C++”"},"content":{"rendered":"

Today, I want to present the five winners of the vouchers for my book “C++ Core Guidelines Explained: Best Practices for Modern C++”.<\/p>\n

<\/p>\n

 \"CppCoreGuidelines\"<\/p>\n

 <\/p>\n

First, I have to adjust the number. Instead of five, I will give away seven vouchers. Why? Honestly, I could not decide. Additionally, I got more than 30 answers. Therefore, I added three vouchers. Here are the answers in the order I got the. You should already have the voucher.<\/p>\n

Sandor<\/h2>\n
Not surprisingly the first thing I had in mind were smart pointers, but that would be too evident. And I was also not sure if you mean language or library features. We used to have smart pointers before from boost, etc.<\/div>\n
 <\/div>\n
Keeping that in mind, to me, it’s the override specifier. It makes intentions so much clearer! With virtual you know exactly one thing, that very function can be overridden. But you have no idea whether it’s overriding something or not. Forgetting a const here, using another similar type there, and you have some issues that are very difficult to spot. The override specifier changed that and helped me to catch some subtle bugs in our codebase that I would have never found.<\/div>\n

Tom<\/h2>\n

 <\/p>\n

The most influential feature of C++ 17 for me has been structured bindings.
Structured bindings let me write and refactor flexible code in places like interacting with a std::pair returned from a function (multiple return) or iterating over a map or custom type.
As long as we choose descriptive variable & function names, structured bindings enable us to write concise but readable code using words of intent related to the domain we’re working in instead of only relying on type names.<\/p>\n

I also think structured bindings help C++ be considered as a “modern” language, they’re a convenience that’s almost expected now if you look at how often the same feature is used in languages like Golang and JavaScript. Sure they’re different worlds, but I like to learn and take inspiration from anywhere I can and translate it into my own program design if it fits well.<\/p>\n

Akash<\/h2>\n
 <\/div>\n
The most influential feature for me is the introduction on “thread” support in C++11.<\/div>\n
 <\/div>\n
This is because of the reason that , it is very basic requirement for any good software project. Earlier we had to know and learn platform specific threads like “pthreads” in Linux, Win32 APIs on Windows etc. <\/div>\n
 <\/div>\n
But with thread introduction in C++11 and concurrency support provided for it has made it cross-platform and also lead to advanced concepts like promise\/future.<\/div>\n
 <\/div>\n

Far\u00e9s<\/h2>\n
\n
I mostly know C++11. I would write couples of words about lambda function or expression. It creates an anonymous function.<\/div>\n
A lambda expression is a mechanism for specifying a function object. The primary use for lambda is to specify a simple action to be performed by some function. <\/div>\n
For instance, one can declare the argument [ ] (int x, int y) { return sin( x ) < sin( y ); } with the condition, x and y are between [0 pi]  – this is a “lambda function” or “lambda expression”, which specifies an operation that given two integer arguments x and y returns the result of comparing their sin values.  A lambda expression can as well access local variables in the scope in which it is used.<\/div>\n
 <\/div>\n

Michael<\/h2>\n

my “most influential feature” of the last decade in C++ was the std::shared_ptr (and also the std::unique_ptr). I could never “befriend” the auto_ptr, never used it – but the new kind of smart pointers became real quick my best buddies.<\/p>\n

After working with Java and Android next to C++, the memory management with new and delete felt like being from the stone ages. With a lot of trouble on how, when and where to allocate and to free the memory. Plus how (not) to pass those pointers around in the code.<\/p>\n

Especially using the smart pointers with RAII frees up a lot of cognitive load. I don’t need to think about the memory allocation, the compiler will do this for me. And releases the memory after the last (or only) reference falls out of scope.<\/p>\n

And they are still nice to use even though some of the code got more complex. Simple forward declarations of classes no longer work (the smart pointers need to do a “sizeof()”), and circular dependencies had to be solved in a different way. I do it in Java style with abstract classes emulating interfaces, so the class for the smart pointer is compiled as separate unit.<\/p>\n

Tobias<\/h2>\n

this is a tough question, since there are so many improvements in the C++ language since the advent of C++11. So I thought what feature has altered the way I program C++ the most. The two main features I considered was \u201cauto\u201d and \u201csmart pointers (unique_ptr, shared_ptr)\u201d and I must say that smart pointers transformed my code definitely more than auto. Auto helps a lot but it is mainly syntactic sugar. In contrast smart pointers enable C++ programmers to use a different style of programming. The owner of objects can be clearly expressed also the distinction between single or exclusive ownership in contrast to shared ownership can be expressed with the use of unique_ptr and shared_ptr. The smart pointers also make programming idioms like RAII easier. Lastly smart pointers avoid several security pitfalls if applied correctly. It avoids dangling memory objects since the lifetime of objects is tied to a scope and exiting the scope automatically deletes the object.<\/span><\/p>\n

Adam<\/h2>\n

My vote for the most influential feature of C++11\/14\/17 goes to the specifier<\/span> <\/span>constexpr<\/span><\/code>, <\/span>introduced in C++ 11.<\/span><\/span>
<\/span><\/span><\/p>\n

According to cppreference (<\/span><\/span>https:\/\/en.cppreference.com\/w\/cpp\/language\/constexpr<\/a><\/span><\/span>) “The <\/span>constexpr<\/span> <\/span>specifier declares that it is possible to evaluate the value of the function or variable at <\/span>compile time.”<\/span>.<\/span> <\/span>Trivially, for example we can declare: <\/span><\/span><\/p>\n

constexpr<\/span> <\/span>auto<\/span> <\/span>meaning_of_life{ 42 };<\/span><\/span><\/span><\/span><\/samp><\/div>\n

<\/span><\/samp><\/p>\n

This quite innocuous feature allows you to declare variables that can be evaluated at compile <\/span>time.<\/span> <\/span>Like it<\/span>s runtime counterpart<\/span> <\/span>const<\/span><\/code>,<\/span> <\/span>i<\/span>t allows you to be clear about the meaning of a piece of <\/span>code.<\/span> <\/span>In the best tradition of C++ it allows you to express your intention exactly (say what you <\/span>mean and mean what you say).<\/span><\/span>
<\/span><\/span><\/p>\n

But it is not just limited to variables.<\/span> <\/span>constexpr<\/span> <\/span><\/code>can apply to<\/span> <\/span>functions that can be compile<\/span>–<\/span>time <\/span>evaluated.<\/span> <\/span>For<\/span> <\/span>example<\/span>, given the<\/span> <\/span>following<\/span> <\/span>arrangement<\/span>:<\/span><\/span><\/p>\n<\/div>\n

<\/p>\n

\n
enum<\/span> class<\/span> MediaType<\/span>\r\n{\r\n    Unknown,\r\n    Music,\r\n    Video,\r\n    Book\r\n};\r\nusing<\/span> MediaTypeItem =<\/span> std::<\/span>pair<<\/span>MediaType, std::<\/span>string_view><\/span>;\r\nstruct<\/span> MediaTypeValues\r\n{\r\n    static<\/span> constexpr std::<\/span>array<<\/span>MediaTypeItem, 3<\/span>><\/span> values{\r\n        {{MediaType::<\/span>Book, \"Book\"<\/span>sv},\r\n         {MediaType::<\/span>Music, \"Music\"<\/span>sv},\r\n         {MediaType::<\/span>Video, \"Video\"<\/span>sv}}};\r\n};\r\nconstexpr std::<\/span>string_view GetString(MediaType in)\r\n{\r\n    for<\/span> (const<\/span> auto<\/span> &<\/span>v :<\/span> MediaTypeValues::<\/span>values)\r\n    {\r\n        if<\/span> (v.first ==<\/span> in)\r\n        {\r\n            return<\/span> v.second;\r\n        }\r\n    }\r\n    return<\/span> {};\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
We can take advantage of<\/span> <\/span>constexpr<\/span> <\/span><\/code>to<\/span> <\/span>create a compile<\/span>–<\/span>time evaluated<\/span> <\/span>std::<\/span>array<\/span><\/code> <\/span>to map <\/span>enumerated values to their string counterparts.<\/span> <\/span>constexpr<\/span> <\/span><\/code>allows us to<\/span> <\/span>take code that was once <\/span>evaluated at runtime and make it into compile<\/span>–<\/span>time evaluated code.<\/span> <\/span>And this<\/span> <\/span>is<\/span> <\/span>evalu<\/span>ated at <\/span>compile time<\/span> <\/span>as shown below:<\/span><\/span><\/p>\n
 \"intellise\"<\/p>\n
The function<\/span> <\/span>GetString<\/span><\/code> <\/span>is<\/span> <\/span>evaluated at compile<\/span>–<\/span>time<\/span>, as is displayed by<\/span> <\/span>Visual Studio’s <\/span>I<\/span>ntelli<\/span>S<\/span>ense<\/span>.<\/span><\/span>
<\/span><\/span><\/p>\n
Of course, we’ve always had compile<\/span>–<\/span>time constructs (template metaprogramming uses compile<\/span>–<\/span>time evaluation extensively)<\/span>,<\/span> <\/span>but these have often been esoteric (computing factor<\/span>ials at compile<\/span>– <\/span>time<\/span> <\/span>for example<\/span>).<\/span> <\/span>What makes<\/span> <\/span>constexpr<\/span> <\/span><\/code>so influential is<\/span> <\/span>that it<\/span> <\/span>opens the way to<\/span> <\/span>re<\/span>designing <\/span>whole sections of a codebase from runtime to compile<\/span>–<\/span>time<\/span> <\/span>evaluated code<\/span>.<\/span> <\/span>As<\/span> <\/span>constexpr<\/code> <\/span>permeates the STL, it encourages re<\/span>design and<\/span> <\/span>refactoring.<\/span> <\/span>Where once some code might have <\/span>been runtime evaluated, now we can<\/span> <\/span>use<\/span> <\/span>constexpr<\/span> <\/span><\/code>to redesign it to be compile<\/span>–<\/span>time evaluated <\/span>and<\/span> <\/span>hence<\/span> <\/span>more efficient<\/span>.<\/span><\/span><\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Today, I want to present the five winners of the vouchers for my book “C++ Core Guidelines Explained: Best Practices for Modern C++”.<\/p>\n","protected":false},"author":21,"featured_media":6401,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[360],"tags":[],"class_list":["post-6411","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-news"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6411","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=6411"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6411\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6401"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6411"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6411"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6411"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}