{"id":171,"date":"2017-06-29T10:53:27","date_gmt":"2017-06-29T10:53:27","guid":{"rendered":"http:\/\/cppdepend.com\/wordpress\/?p=171"},"modified":"2017-08-11T16:36:58","modified_gmt":"2017-08-11T16:36:58","slug":"the-rise-of-the-new-language-mc","status":"publish","type":"post","link":"https:\/\/cppdepend.com\/blog\/the-rise-of-the-new-language-mc\/","title":{"rendered":"The rise of the new language MC++"},"content":{"rendered":"

During the last few years we talk about the \u201cC++ Renaissance\u201d. We have to admit that Microsoft was a major part of this movement, I remember this video<\/a> where\u00a0Craig Symonds and Mohsen Agsen talked about it.<\/p>\n

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

By\u00a02011, C++ had been in use for\u00a0more 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

Let\u2019s take the memory management as example, which is maybe the most criticized mechanism in C++. For many years the object allocation was done by the new keyword, and the developer must never forget to invoke delete somewhere in the code. \u00a0The \u201cModern C++\u201d resolved this issue and promotes the use of a shared pointer.<\/p>\n

When c++0x was announced a few years ago, I thought that it would\u00a0not impact the C++ language, but I was wrong. Take a look at this code snippet from Folly. It looks like it\u2019s developed using a new language.<\/p>\n

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

The same situation\u00a0occurs in almost all the folly source code; its implementation looks very different to c++03 source code.<\/p>\n

How to prevent the big impact of the C++ past?<\/strong><\/p>\n

There\u2019s no magic solution. We can hope that C++ compilers could help us by emitting some warnings related to the deprecated usage, like the old string manipulation (strcpy,strcat,\u2026). But this solution \u00a0will not have a big impact. The modern C++ is more new idioms to learn and practice.<\/p>\n

Another solution would\u00a0be to consider that a new language named\u00a0\u201cModern C++<\/strong>\u201d should be\u00a0created. Let\u2019s do the same search on the web as before, but this time we search for \u201cModern C++\u201d object allocation, the first link\u00a0will talk about smart pointers.<\/p>\n

Discovering the new language MC++<\/strong><\/p>\n

The better approach to discover the power of MC++ is to explore the source code of a mature project using its features. Folly from facebook is a very good candidate.<\/p>\n

Let’s discover some MC++ \u00a0features used in Folly:<\/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 for almost all its variable declarations, here\u2019s an example from its source code<\/p>\n

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

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

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

The constant\u00a00\u00a0has 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 all null pointers are represented by the new keyword nullptr, there \u2018s 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>.\u00a0What\u2019s new is its standardization and no further\u00a0use of an external library to work with smart pointers.<\/p>\n

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

4-\u00a0Strongly-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 have scope defined 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\u00a0we 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. 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 simpler and cleaner. Folly uses this feature extensively. Here\u2019s an example:<\/p>\n

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

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

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

Here\u2019s 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 of rvalues.<\/p>\n

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

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

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

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

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

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

Folly uses it in many functions. Here\u2019s 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 (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\u00a0override<\/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.<\/p>\n

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

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

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

A thread class (std::thread<\/code>) is provided which takes a\u00a0function object\u00a0\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.\u00a0This is the new standard way to define a new thread, taken from Folly source code:<\/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:<\/p>\n