Two years ago Facebook released their C++ library named Folly , it’s a large collection of reusable C++ library components that internally at Facebook are used extensively.
But many mature C++ open source libraries exist, why introduce another one ? Here’s the motivations from their website behind its utility:
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.
Here’s for example a detailled explanation 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, the C++11 features are extensively used, Moreover almost all new C++11 features are used.
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.
The same remark concern almost all the folly source code, its implementation looks different to c++03 source code.
For developers interested to master the new C++11 features, a better approach is to discover how mature libraries use them.Folly is a very good candidate to explore the new features. Let’s discover some of them from its source code.
1- auto
C++11 introduces type inference capability using the auto keyword, which means that the compiler infer 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 permits to spend less time having to write out things the compiler already knows.
2- nullptr
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
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 pointer is not a new concept, many libraries implemented it many years ago, the popular one is boost::shared_ptr, what’s new is its standardization, and no need anymore to use an external library to work with smart pointers.
Folly uses extensively the standardized shared pointer, only few raw pointers remain in its source code.
4- Strongly-typed enums
“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,
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.
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 to add conditions to the template parameters, as shown in this template class from Folly source code:
6- Variadic template
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:
7- Range-based for loops
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, here’s an example for Folly
8-Initializer lists
In C++03 Initializer lists concern only arrays, in C++11 are not just for arrays any more. 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 function accepting std::initializer_list as 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 source code
10- move
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.
For that C++11 introduces two new special member functions: the move constructor and the move assignment operator.
Here’s a good document that explains better the benefits of move semantics.
11-lambda
C++11 provides the ability to create anonymous functions, called lambda functions, you can refer here for more details about this new feature.
Folly uses it 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 provide them for 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 and not defining them.
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.
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 indicate an error.
Folly uses extensively this new feature:
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 more simplified, here’s from Folly source code the new standard way to defines a new thread:
15- Unordered containers
A unordered container is a kind of hash table. C++11 offers four standard ones:
- unordered_map
- unordered_set
- unordered_multimap
- unordered_multiset
Folly uses in many places these new containers
Conclusion
Folly uses almost all the new C++11 features, exploring its source code will give you a better idea of the new C++ capabilities, and how they are implemented.
I encourage any C++ developer interested in the C++11 to downlad the Folly source code and discover the power of the new language.