// cpp11_demo.cpp

#include <iostream>

#include <memory>

#include <string>

#include <vector>

// ---------- Feature 1: auto & decltype ----------

auto add(int a, int b) -> int

{ // trailing return type (C++11)

return a + b;

}

decltype(42) get_forty_two()

{ // decltype deduces int

return 42;

}

void demo_auto_decltype()

{

std::cout << "\n=== auto & decltype ===\n";

auto x = add(3, 4); // auto = int

decltype(3.14) y = 3.14; // double

decltype(x) z = x;

std::cout << "auto x = " << x << "\n";

std::cout << "decltype(3.14) y = " << y << "\n";

std::cout << "decltype(x) z = " << z << "\n";

}

// ---------- Feature 2: range-based for loops ----------

void demo_range_for()

{

std::cout << "\n=== range-based for loops ===\n";

std::vector<int> vec{1, 2, 3, 4, 5};

int sum = 0;

// Clean iteration (no iterators!)

for (int val : vec) {

sum += val;

}

std::cout << "sum = " << sum << "\n";

// Modifiable refs

for (int &val : vec) {

++val;

}

std::cout << "vec now: ";

for (int val : vec) {

std::cout << val << " ";

}

std::cout << "\n";

}

// ---------- Feature 3: lambda expressions ----------

void demo_lambda()

{

std::cout << "\n=== lambda expressions ===\n";

int factor = 10;

std::vector<int> vec{1, 2, 3};

// Capture by value/reference

auto multiply = [factor](int x) { return x * factor; }; // [=] or [&] for all

for (int val : vec) {

std::cout << "multiply(" << val << ") = " << multiply(val) << "\n";

}

}

// ---------- Feature 4: nullptr ----------

void demo_nullptr()

{

std::cout << "\n=== nullptr ===\n";

int *ptr = nullptr; // type-safe null (not 0)

std::cout << "ptr == nullptr: " << (ptr == nullptr) << "\n";

}

// ---------- Feature 5: smart pointers ----------

struct DemoObj

{

int value;

DemoObj(int v)

: value(v)

{

std::cout << "DemoObj(" << v << ") created\n";

}

~DemoObj() { std::cout << "~DemoObj() destroyed\n"; }

};

void demo_smart_ptrs()

{

std::cout << "\n=== smart pointers ===\n";

// unique_ptr: exclusive ownership

{

auto up = std::make_unique<DemoObj>(

1); // C++14 make_unique, but unique_ptr raw new ok in C++11

std::cout << "unique_ptr value: " << up->value << "\n";

// auto-destroys on scope exit

} // destroyed here

// shared_ptr: shared ownership

std::shared_ptr<DemoObj> sp1 = std::make_shared<DemoObj>(2);

{

std::shared_ptr<DemoObj> sp2 = sp1; // refcount=2

std::cout << "shared_ptr value: " << sp2->value << "\n";

} // refcount=1

// sp1 destroyed after main

}

// ---------- Feature 6: constexpr & static_assert ----------

constexpr int factorial(int n)

{

return (n <= 1) ? 1 : (n * factorial(n - 1));

}

void demo_constexpr_assert()

{

std::cout << "\n=== constexpr & static_assert ===\n";

static_assert(factorial(5) == 120, "factorial(5) must be 120");

std::cout << "factorial(5) = " << factorial(5) << "\n"; // compile-time computable

}

// ---------- main ----------

int main()

{

std::cout << "C++11 feature tour\n";

demo_auto_decltype();

demo_range_for();

demo_lambda();

demo_nullptr();

demo_smart_ptrs();

demo_constexpr_assert();

std::cout << "\nDone.\n";

return 0;

}