And the Five Winners for “C++ Core Guidelines: Best Practices for Modern C++”

Michael

my “most influential feature” of the last decade in C++ was the std::shared_ptr (and also the std::unique_ptr). I could never “befriend” the auto_ptr, never used it – but the new kind of smart pointers became real quick my best buddies.

After working with Java and Android next to C++, the memory management with new and delete felt like being from the stone ages. With a lot of trouble on how, when and where to allocate and to free the memory. Plus how (not) to pass those pointers around in the code.

Especially using the smart pointers with RAII frees up a lot of cognitive load. I don’t need to think about the memory allocation, the compiler will do this for me. And releases the memory after the last (or only) reference falls out of scope.

And they are still nice to use even though some of the code got more complex. Simple forward declarations of classes no longer work (the smart pointers need to do a “sizeof()”), and circular dependencies had to be solved in a different way. I do it in Java style with abstract classes emulating interfaces, so the class for the smart pointer is compiled as separate unit.

Tobias

this is a tough question, since there are so many improvements in the C++ language since the advent of C++11. So I thought what feature has altered the way I program C++ the most. The two main features I considered was “auto” and “smart pointers (unique_ptr, shared_ptr)” and I must say that smart pointers transformed my code definitely more than auto. Auto helps a lot but it is mainly syntactic sugar. In contrast smart pointers enable C++ programmers to use a different style of programming. The owner of objects can be clearly expressed also the distinction between single or exclusive ownership in contrast to shared ownership can be expressed with the use of unique_ptr and shared_ptr. The smart pointers also make programming idioms like RAII easier. Lastly smart pointers avoid several security pitfalls if applied correctly. It avoids dangling memory objects since the lifetime of objects is tied to a scope and exiting the scope automatically deletes the object.

Adam

My vote for the most influential feature of C++11/14/17 goes to the specifier constexpr, introduced in C++ 11.

According to cppreference (https://en.cppreference.com/w/cpp/language/constexpr) “The constexpr specifier declares that it is possible to evaluate the value of the function or variable at compile time.”. Trivially, for example we can declare:

constexpr auto meaning_of_life{ 42 };

This quite innocuous feature allows you to declare variables that can be evaluated at compile time. Like its runtime counterpart const, it allows you to be clear about the meaning of a piece of code. In the best tradition of C++ it allows you to express your intention exactly (say what you mean and mean what you say).

But it is not just limited to variables. constexpr can apply to functions that can be compile–time evaluated. For example, given the following arrangement:

enum class MediaType
{
    Unknown,
    Music,
    Video,
    Book
};
using MediaTypeItem = std::pair<MediaType, std::string_view>;
struct MediaTypeValues
{
    static constexpr std::array<MediaTypeItem, 3> values{
        {{MediaType::Book, "Book"sv},
         {MediaType::Music, "Music"sv},
         {MediaType::Video, "Video"sv}}};
};
constexpr std::string_view GetString(MediaType in)
{
    for (const auto &v : MediaTypeValues::values)
    {
        if (v.first == in)
        {
            return v.second;
        }
    }
    return {};
}