{"id":319,"date":"2018-02-09T23:24:02","date_gmt":"2018-02-09T23:24:02","guid":{"rendered":"http:\/\/cppdepend.com\/blog\/?p=319"},"modified":"2023-05-31T18:13:30","modified_gmt":"2023-05-31T18:13:30","slug":"15-essential-c11-features-to-enhance-your-c-projects","status":"publish","type":"post","link":"https:\/\/cppdepend.com\/blog\/15-essential-c11-features-to-enhance-your-c-projects\/","title":{"rendered":"15 Essential C++11 Features to Enhance Your C++ Projects."},"content":{"rendered":"

Over recent years, there has been much discussion about the “Renaissance of C++”. It’s undeniable that Microsoft played a significant role in this resurgence.<\/p>\n

In 2011 Microsoft announced in many articles the comeback of C++, and Microsoft C++ experts like Herb Sutter attended many conferences to explain why C++ was back and mostly recommended the use of Modern C++. At the same time, the standard C++11 was approved and we began to talk about C++ as a new language.<\/span><\/span><\/p>\n

By 2011, C++ had been in use for more than 30 years. It was not easy to convince developers that the new C++ actually simplified many frustrating facets of C++ usage and that there was a new modern way to improve the C++ Code.<\/p>\n

For the C++ developers who do not yet switch to C++11, they can use clang-tidy to get suggestions on where they can modernize the codebase or try the CppDepend modernization feature<\/a>. And here are the 15 features mostly used in the C++ open-source libraries.<\/p>\n

Let’s take as an example  Folly<\/a> released six years ago by Facebook, Folly is a large collection of reusable C++ library components that internally at Facebook are used extensively. And  here\u2019s the motivations from their website behind  its utility:<\/p>\n

Folly (acronymed loosely after Facebook Open Source Library) is a library of C++11 components designed with practicality and efficiency in mind. It complements (as opposed to competing against) offerings such as Boost and of course std<\/code>. In fact, we embark on defining our own component only when something we need is either not available, or does not meet the needed performance profile.<\/p><\/blockquote>\n

Let’s explore from its source code 15 C++11 features:<\/p>\n

1- auto<\/strong><\/p>\n

C++11 introduces type inference capability using the auto keyword, which means that the compiler infers the type of a variable at the point of declaration. Folly uses  auto for almost all its variable declarations, here\u2019s an example from its source code<\/p>\n

\"c1\"<\/a><\/p>\n

Using the auto keyword permits you to spend less time having to write out things the compiler already knows.<\/p>\n

2- nullptr<\/strong><\/p>\n

The constant 0 has had the double role of constant integer and null pointer constant.C++11 corrects this by introducing a new keyword to serve as a distinguished null pointer constant:nulptr<\/p>\n

In the Folly source code, the new keyword nullptr represents all null pointers, there\u2018s no place where the constant 0 is used.<\/p>\n

3- shared_ptr<\/strong><\/p>\n

The smart pointer is not a new concept, many libraries implemented it many years ago, the popular one is boost::shared_ptr<\/a>, what\u2019s new is its standardization, and no need anymore to use an external library to work with smart pointers.<\/p>\n

Folly uses extensively the standardized shared pointer, only a few raw pointers remain in its source code.<\/p>\n

4- Strongly-typed enums<\/strong><\/p>\n

\u201cTraditional\u201d enums in C++ export their enumerators in the surrounding scope, which can lead to name collisions if two different enums in the same scope define enumerators with the same name,<\/p>\n

C++11 introduces the enum class keywords. They no longer export their enumerators in the surrounding scope. Moreover, we can also now inherit from an enum.<\/p>\n

\"c2\"<\/a><\/p>\n

[adrotate banner=”3″]<\/p>\n

5- static assert<\/strong><\/p>\n

C++11 introduces a new way to test assertions at compile-time, using the new keyword static_assert, this feature is very useful to add conditions to the template parameters, as shown in this template class from Folly source code:<\/p>\n

\"c3\"<\/a><\/p>\n

6- Variadic template<\/b><\/strong><\/p>\n

The variadic template is a template, which can take an arbitrary number of template arguments of any type. Both the classes & functions can be variadic. Folly defines many variadic templates, here are two variadic template functions from the Folly source code:<\/p>\n

\"c4\"<\/a><\/p>\n

7- Range-based for loops<\/strong><\/p>\n

C++11 augmented the “for” statement to support the \u201cforeach\u201d paradigm of iterating over collections. it makes the code more simple and cleaner. Folly uses this feature extensively, here\u2019s an example of Folly<\/p>\n

\"c6\"<\/a><\/p>\n

8-Initializer lists<\/strong><\/p>\n

In C++03 Initializer lists concern only arrays, in C++11 are not just for arrays anymore. The mechanism for accepting a {}<\/b>-list is a function (often a constructor) accepting an argument of type std::initializer_list<T><\/b>. Here\u2019s an example of a function accepting std::initializer_list as an argument<\/p>\n

\"c7\"<\/a><\/p>\n

And here\u2019s how it\u2019s invoked<\/p>\n

\"c8\"<\/a><\/p>\n

9- noexcept<\/strong><\/p>\n

If a function cannot throw an exception or if the program isn\u2019t written to handle exceptions thrown by a function, that function can be declared noexcept.<\/b><\/p>\n

Here\u2019s an example from Folly’s source code<\/p>\n

\"c9\"<\/a><\/p>\n

10- move<\/strong><\/p>\n

C++11 has introduced the concept of rvalue references (specified with &&) to differentiate a reference to an lvalue or an rvalue. An lvalue is an object that has a name, while an rvalue is an object that does not have a name (a temporary object). The move semantics allow modifying rvalues.<\/p>\n

For that, C++11 introduces two new special member functions: the move constructor <\/em>and the move assignment operator<\/em>.<\/p>\n

\"c12\"<\/a><\/p>\n

\"c10\"<\/a><\/p>\n

Here\u2019s a good document<\/a> that explains better the benefits of move semantics.<\/p>\n

11-lambda<\/strong><\/p>\n

C++11 provides the ability to create anonymous functions, called lambda functions<\/a>.<\/p>\n

Folly uses it in many functions, here\u2019s an example from its source code:<\/p>\n

\"c14\"<\/a><\/p>\n

12- Explicitly defaulted and deleted special member functions<\/strong><\/p>\n

In C++03, the compiler provides, for classes that do not provide them for themselves, a default constructor, a copy constructor, a copy assignment operator (operator=<\/code>), and a destructor. The programmer can override these defaults by defining custom versions.<\/p>\n

However, there is very little control over the creation of these defaults. Making a class inherently non-copyable, for example, requires declaring a private copy constructor and copy assignment operator and not defining them.<\/p>\n

In C++11, certain features can be explicitly disabled. For example, the following type is non-copyable, which makes the code more simple and clean.<\/p>\n

\"c15\"<\/a><\/p>\n

13- override identifier<\/strong><\/p>\n

In C++03, it is possible to accidentally create a new virtual function, when one intended to override a base class function.<\/p>\n

The override<\/code> special identifier means that the compiler will check the base class(es) to see if there is a virtual function with this exact signature. And if there is not, the compiler will indicate an error.<\/p>\n

Folly uses extensively this new feature:<\/p>\n

\"c18\"<\/a><\/p>\n

[adrotate banner=”3″]<\/p>\n

14- std::thread<\/strong><\/p>\n

A thread class (std::thread<\/code>) is provided which takes a function object \u2014 and an optional series of arguments to pass to it \u2014 to run in the new thread.<\/p>\n

In C++11 working with threads is more simplified, here\u2019s from Folly source code the new standard way to define a new thread:<\/p>\n

\"c20\"<\/a><\/p>\n

15- Unordered containers<\/strong><\/p>\n

An unordered container is a kind of hash table. C++11 offers four standard ones:<\/p>\n