Modern C++ Features Every Developer Should Know

C++ has evolved dramatically over the past decade, especially with the advent of C++11, C++14, C++17, and C++20. As a seasoned C++ developer who has worked on large-scale systems across multiple domains, I‘ve seen firsthand how these modern features can revolutionize the way we write C++ code. In this post, I‘ll share some of the most impactful modern C++ features that every developer should learn and adopt.

The Power of Auto

One of the most significant quality-of-life improvements in modern C++ is the auto keyword. auto lets the compiler deduce the type of a variable from its initializer expression. This reduces verbosity, improves readability, and makes refactoring easier.

Consider a simple example of iterating through a map:

std::map<std::string, int> scores = {{"Alice", 100}, {"Bob", 95}, {"Charlie", 98}};

// Old C++
for (std::map<std::string, int>::const_iterator it = scores.begin(); it != scores.end(); ++it) {
    std::cout << it->first << ": " << it->second << std::endl;
}

// Modern C++ with auto
for (auto it = scores.cbegin(); it != scores.cend(); ++it) {
    std::cout << it->first << ": " << it->second << std::endl;
}

The auto version is much more concise and readable. We don‘t have to worry about spelling out the verbose iterator type.

But auto is useful for more than just iterators. It can make complex type declarations much simpler:

auto result = someComplexFunction();
// vs 
SomeLongNamespace::SomeTemplateType<int, double, std::string> result = someComplexFunction();

According to the C++ Foundation‘s 2021 Developer Survey^1, 77% of C++ developers use auto always or frequently in their code. Auto is supported by all major compilers and static analysis tools.

Best practice is to use auto wherever the type is clear from the context, and especially for complex types. But avoid using auto for numeric literals or in very wide scopes where the type may not be obvious to readers.

Lambdas: Functions Without a Name

Another transformative feature in modern C++ is lambda expressions. Lambdas allow defining anonymous function objects inline, which is perfect for writing short, one-off functions to pass to STL algorithms or asynchronous APIs.

Here‘s an example of using a lambda with std::find_if to search a vector:

std::vector<int> v = {1, 2, 3, 4, 5};
auto it = std::find_if(v.begin(), v.end(), [](int i) { return i > 3; });

The [](int i) { return i > 3; } is the lambda expression. It takes an int parameter i and returns a bool indicating whether i is greater than 3. We pass this lambda directly to find_if to search for the first element greater than 3.

Lambdas are incredibly powerful and expressive. You can capture local variables from the surrounding scope, either by value or reference. In C++14 generic lambdas were introduced, allowing auto parameters. And in C++20 template lambdas were added^2.

auto greaterThan = [](auto a, auto b) { return a > b; };
std::sort(v.begin(), v.end(), greaterThan); 

GitHub code search shows lambdas are used in over 10 million C++ repos^3, demonstrating their widespread adoption. Lambdas are ideal for any scenario needing a lightweight, locally-scoped function. However, they can harm readability if overused or made too complex. Stick to short, focused lambdas and split into named functions where appropriate.

Compile-Time Computation with constexpr

Moving computation from runtime to compile-time is a key way to improve C++ performance. constexpr lets you mark a function or variable as being evaluatable at compile-time, given compile-time inputs.

constexpr int factorial(int n) {
    return n <= 1 ? 1 : (n * factorial(n - 1));
}

constexpr int fact5 = factorial(5);  // Computed at compile-time

The compiler will evaluate factorial(5) and substitute the literal result 120 for the variable fact5. This moves the computation cost from runtime to compile-time, and allows using the result in contexts requiring a constant expression like template parameters or array bounds.

C++14 relaxed the requirements on constexpr functions, allowing local variables, loops, and branches. C++20 further expanded constexpr to allow dynamic allocation, virtual functions, and more^4. Now most computations that can be done at runtime can also potentially be done at compile-time.

Major compilers like GCC, Clang, and MSVC have invested heavily in constexpr evaluation performance. Techniques like memoization are used to avoid redundant compilation work^5. With constexpr-heavy code bases, build times can actually improve by moving computation from many separate runtime calls to a single shared compile-time evaluation.

Best practice is using constexpr on pure functions with cheap inputs/outputs. Overuse of constexpr on complex functions can cause code bloat and slow build times. A good balance is making low-level utilities constexpr while keeping most application logic dynamic.

Safe, Smart Pointers

Incorrect dynamic memory management is the root cause of countless C++ bugs, crashes, and security vulnerabilities over the decades. Raw pointers are simply too error-prone for most use cases.

Modern C++ provides safer and smarter alternatives: std::unique_ptr, std::shared_ptr, and std::weak_ptr. These manage the lifetimes of dynamically-allocated objects, prevent leaks and dangling pointers, and clarify ownership semantics.

unique_ptr is for exclusive ownership. Only one unique_ptr can manage an object at a time, and the object is deleted when the unique_ptr is destroyed. It cannot be copied, only moved.

auto p = std::make_unique<MyClass>();
auto p2 = std::move(p); // Transfers ownership to p2

shared_ptr allows shared ownership. Multiple shared_ptr can point to the same object, and the object is deleted only when all shared_ptr to it are gone. shared_ptr maintains a reference count internally.

auto p = std::make_shared<MyClass>();
auto p2 = p; // Both own the MyClass object now

weak_ptr is a non-owning observer. It can access an object owned by a shared_ptr but doesn‘t keep it alive.

According to a 2019 survey^6, 64% of C++ developers use smart pointers always or frequently in new code, and another 24% use them sometimes. All major static analyzers and linters recommend using smart pointers by default over raw pointers.

For most application-level C++ code, smart pointers suffice for dynamic memory management needs. Prefer unique_ptr for clearly owned resources, shared_ptr for shared resources, and only fall back to raw pointers when unavoidable (e.g. interfacing with legacy C APIs).

Structured Bindings

Unpacking values from structures or containers is a common task in C++. Historically this required verbose, manual destructuring:

std::map<std::string, int> scores = {{"Alice", 100}, {"Bob", 95}};
for (const auto& [name, score] : scores) {
    std::string name = kv.first;
    int score = kv.second;
    ProcessScore(name, score);
}

C++17 introduced structured bindings^7, which allow directly declaring variables for sub-objects:

for (const auto& [name, score] : scores) {
    ProcessScore(name, score);
}

This works for array-like types (std::array, std::tuple, std::pair), public data members of classes/structs, and for any type where specializing std::tuple_size, std::tuple_element is valid. Structured bindings make code terser, more readable, and less error-prone.

Conclusion

This is just a sampling of the dozens of significant new features in modern C++. From small quality-of-life improvements like type inference and structured bindings, to major paradigm shifts like smart pointers and compile-time programming, C++ has become a remarkably powerful and expressive language.

Compared to legacy C++98 code, modern C++ is safer, more maintainable, more performant, and frankly more fun to write. If you haven‘t kept up with the evolution of C++, I highly recommend investing some time to learn about the new features and best practices. It‘s well worth the effort.

Some great resources to learn more:

• "Effective Modern C++" by Scott Meyers ^8
• "C++ Crash Course" by Josh Lospinoso ^9
• CppCon conference talks ^10
• Abseil C++ Tips of the Week ^11

Embracing modern C++ will make you a more productive and capable C++ programmer. The language is still as challenging and complex as ever, but now we have more powerful tools to write high-quality, maintainable, and performance code. So modernize your C++ today!