C++11 New Features and Their Practical Usage

C++11, the 2011 standard of the C++ language, introduces a wide range of new features that improve code readability, safety, and performance. The standard adds about 140 new language features and fixes roughly 600 defects from C++98.

1. List Initialization

Brace‑enclosed initializer lists can now be used for any built‑in type, standard containers, and user‑defined types that provide a constructor taking std::initializer_list . Example:

int a = {1};
std::vector
v = {1,2,3,4,5};
std::list
lt{"hello","world"};
int* arr = new int[5]{1,2,3,4,5};

2. Type Deduction

The auto keyword lets the compiler infer a variable’s type from its initializer, while decltype yields the exact type of an expression. Example:

auto x = 10;               // int
decltype(a+b) c;          // type of a+b

3. final and override

final prevents further overriding of a virtual function, and override forces the compiler to check that a function truly overrides a base‑class virtual function.

4. New Containers

C++11 adds std::array , std::forward_list , and the unordered associative containers ( unordered_set , unordered_map ) which use hash tables for faster look‑ups.

5. Controlling Defaulted Functions

Special member functions can be explicitly defaulted with =default or deleted with =delete , giving programmers fine‑grained control over copy/move semantics.

6. Rvalue References and Move Semantics

Rvalue references ( T&& ) enable move constructors and move assignment operators, allowing resources to be transferred instead of copied. The std::move utility casts an lvalue to an rvalue, while noexcept on move operations lets containers such as std::vector use moves during reallocation.

class Person {
    std::string name;
public:
    Person(std::string n) : name(std::move(n)) {}
    Person(Person&& other) noexcept : name(std::move(other.name)) {}
};

7. Perfect Forwarding

Perfect forwarding preserves the value category of arguments when forwarding them from a template function to another function. It relies on universal (forwarding) references ( T&& in a deduced context) and std::forward :

template<typename T>
void callFoo(T&& arg) {
    foo(std::forward<T>(arg));
}

8. Smart Pointers

C++11 provides four smart pointers:

std::unique_ptr – exclusive ownership, movable but not copyable.

std::shared_ptr – reference‑counted shared ownership.

std::weak_ptr – non‑owning reference to break cyclic dependencies.

std::auto_ptr – deprecated.

Typical usage:

auto up = std::make_unique<Widget>();
std::shared_ptr
sp = std::make_shared<Widget>();

9. Lambda Expressions

Lambdas are anonymous function objects with the syntax [capture](params) mutable -> ret { body } . Captures can be by value or reference, and the mutable specifier allows modification of captured values.

auto add = [=](int a, int b) { return a + b; };
std::for_each(v.begin(), v.end(), [](int n){ std::cout << n << " "; });

10. The Four C++ Casts

static_cast performs compile‑time checked conversions (e.g., up/down class hierarchy, numeric conversions). dynamic_cast safely down‑casts within a polymorphic hierarchy, returning nullptr on failure. reinterpret_cast reinterprets the bit pattern of a value without checks, useful for low‑level pointer tricks. const_cast removes or adds constness.

// dynamic_cast example
Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b); // safe down‑cast

Overall, C++11 equips developers with modern language constructs that simplify resource management, enable efficient generic programming, and provide safer, more expressive ways to write high‑performance code.