In recent years, there has been much discussion about the "Renaissance of C++". It's undeniable that Microsoft played a significant role in this resurgence.
In 2011, Microsoft announced the comeback of C++ in many articles, and Microsoft C++ experts like Herb Sutter gave many talks to explain why C++ was back, mostly recommending the use of Modern C++. At the same time, the C++11 standard was approved, and we began to talk about C++ as a new language.
By 2011, C++ had been in use for more than 30 years. It was not easy to convince developers that modern C++ actually simplified many frustrating aspects of using C++ and that there was a new modern way to improve C++ code.
For C++ developers who have not yet switched to C++11: you can use clang-tidy to get suggestions on where to modernize the codebase, or try the CppDepend modernization feature. Here are 15 of the most widely used features in open-source C++ libraries.
Let’s take Folly, released six years ago by Facebook: Folly is a large collection of reusable C++ library components used extensively internally at Facebook. Here is how its website explains the motivation behind its creation:
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. 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.Let’s explore 15 C++11 features from its source code:
1. auto
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’s an example from its source code.
Using the auto keyword lets you spend less time writing out things the compiler already knows.
2. nullptr
The constant 0 has traditionally served the dual role of an integer constant and a null pointer constant. C++11 corrects this by introducing a new keyword to serve as a distinguished null pointer constant: nullptr.
In the Folly source code, all null pointers are represented by the new keyword nullptr; there’s no place where the constant 0 is used.
3. shared_ptr
Smart pointers are not a new concept; many libraries implemented them many years ago, the most popular one being boost::shared_ptr. What’s new is their standardization — there is no longer any need to use an external library to work with smart pointers.
Folly uses the standardized shared pointer extensively; only a few raw pointers remain in its source code.
4. Strongly-typed enums
“Traditional” enums in C++ export their enumerators into the surrounding scope, which can lead to name collisions if two different enums in the same scope define enumerators with the same name.
C++11 introduces the enum class keyword. They no longer export their enumerators into the surrounding scope. Moreover, we can now specify the underlying type of an enum.
5. static assert
C++11 introduces a new way to test assertions at compile time, using the new keyword static_assert. This feature is very useful for adding conditions to template parameters, as shown in this template class from the Folly source code:
6. Variadic template
A variadic template is a template that can take an arbitrary number of template arguments of any type. Both classes and functions can be variadic. Folly defines many variadic templates; here are two variadic template functions from the Folly source code:
7. Range-based for loops
C++11 augmented the “for” statement to support the “foreach” paradigm of iterating over collections. It makes the code simpler and cleaner. Folly uses this feature extensively; here’s an example from Folly.
8. Initializer lists
In C++03, initializer lists apply only to arrays; in C++11 they are not just for arrays anymore. The mechanism for accepting a {}-list is a function (often a constructor) accepting an argument of type std::initializer_list<T>. Here’s an example of a function accepting std::initializer_list as an argument.
And here’s how it’s invoked.
9. noexcept
If a function cannot throw an exception or if the program isn’t written to handle exceptions thrown by a function, that function can be declared noexcept.
Here’s an example from Folly’s source code.
10. move
C++11 introduced the concept of rvalue references (specified with &&) to differentiate a reference to an lvalue from a reference to 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). Move semantics allow modifying rvalues.
For that, C++11 introduces two new special member functions: the move constructor and the move assignment operator.
Here’s a good document that better explains the benefits of move semantics.
11. lambda
C++11 provides the ability to create anonymous functions, called lambda functions.
Folly uses them in many functions; here’s an example from its source code:
12. Explicitly defaulted and deleted special member functions
In C++03, the compiler provides, for classes that do not define them themselves, a default constructor, a copy constructor, a copy assignment operator (operator=), and a destructor. The programmer can override these defaults by defining custom versions.
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 without defining them.
In C++11, certain features can be explicitly disabled. For example, the following type is non-copyable, which makes the code simpler and cleaner.
13. override identifier
In C++03, it is possible to accidentally create a new virtual function when one intended to override a base class function.
The override 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 report an error.
Folly uses this new feature extensively:
14. std::thread
A thread class (std::thread) is provided, which takes a function object — and an optional series of arguments to pass to it — to run in the new thread.
In C++11, working with threads is simpler; here’s the new standard way to define a new thread, taken from the Folly source code:
15. Unordered containers
An unordered container is a kind of hash table. C++11 offers four standard ones:
- unordered_map
- unordered_set
- unordered_multimap
- unordered_multiset
Folly uses these new containers in many places.
