{"id":20,"date":"2016-10-14T09:13:43","date_gmt":"2016-10-14T09:13:43","guid":{"rendered":"http:\/\/cppdepend.com\/wordpress\/?p=20"},"modified":"2018-02-09T19:11:26","modified_gmt":"2018-02-09T19:11:26","slug":"learn-from-folly-source-code-the-new-c11-features","status":"publish","type":"post","link":"https:\/\/cppdepend.com\/blog\/learn-from-folly-source-code-the-new-c11-features\/","title":{"rendered":"Learn from Folly source code the new C++11 features."},"content":{"rendered":"

Six\u00a0years ago Facebook released their C++ library named Folly<\/a>\u00a0, it’s a\u00a0large collection of reusable C++ library components that internally at Facebook are used extensively.<\/span><\/p>\n

But many mature C++ open source libraries exist, why introduce another one ? Here’s the motivations from their website behind \u00a0its 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\u00a0<\/span>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.<\/span><\/p><\/blockquote>\n

<\/p>\n

Here’s for example a detailled explanation<\/a> why Folly introduced another vector class FBVector. And as claimed by the Folly developers, it’s a library of C++11 components, which is totally confirmed if you take a look in their source code,\u00a0the C++11 features are extensively used, Moreover almost all new C++11 features are used.\u00a0<\/span><\/p>\n

When c++0x was announced few years ago, I thought that it will not impact a lot the C++ language, but I was wrong, take a look at this code snippet from Folly, it looks like it’s developed using a new language.<\/p>\n

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

The same remark concern almost all the folly source code, \u00a0its implementation \u00a0looks different to \u00a0c++03 source code.<\/p>\n

For developers \u00a0interested to master the\u00a0new C++11 features, a better\u00a0approach is to discover how mature libraries \u00a0use them.Folly is a very good candidate to explore the new features. Let’s discover some of them\u00a0from\u00a0its\u00a0source code.<\/p>\n

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

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

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

Using the auto keyword\u00a0permits to\u00a0\u00a0spend less time having to write out things the compiler already knows.<\/span><\/p>\n

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

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

In the Folly source code all null pointers are represented by the new keyword nullptr, there ‘s no place where the constant 0 is \u00a0used.<\/p>\n

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

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

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

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

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

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

\"c2\"<\/a><\/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-\u00a0Variadic template<\/b><\/strong><\/p>\n

Variadic template\u00a0is a template, which can take an arbitrary number of template arguments of any type. Both the classes & functions can be variadic.<\/span>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 “foreach” paradigm of iterating over collections. it makes the code more simple and cleaner. Folly uses extensively this feature, h<\/span>ere’s an example for 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 any more. The mechanism for accepting a\u00a0<\/span>{}<\/b>-list is a function (often a constructor) accepting an argument of type\u00a0<\/span>std::initializer_list<T><\/b>. Here’s an example of function accepting std::initializer_list as argument<\/span><\/p>\n

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

And here’s how it’s invoked<\/p>\n

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

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

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\u00a0<\/span>noexcept.<\/b><\/p>\n

Here’s an example from Folly 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.<\/span><\/p>\n

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

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

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

Here’s a good document<\/a> that explains better the benefits of\u00a0\u00a0move semantics.<\/p>\n

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

C++11 provides the ability to create\u00a0anonymous functions<\/span>, called lambda functions, you can refer here<\/a> for more details about this new feature.<\/span><\/p>\n

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

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

12-\u00a0Explicitly 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 (<\/span>operator=<\/code>), and a destructor. The programmer can override these defaults by defining custom versions.<\/span><\/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.<\/span><\/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.\u00a0<\/span><\/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.<\/span><\/p>\n

The\u00a0<\/span>override<\/code>\u00a0special 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.<\/span><\/p>\n

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

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

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

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

In C++11 working with threads is more simplified, here’s from Folly source code\u00a0the\u00a0new standard way to defines a new thread:\u00a0<\/span><\/p>\n

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

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

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