Modern C++ Basics: auto, const, constexpr, nullptr and the Type System (C++23)

#include <vector>
#include <map>
#include <string>

int main() {
    // Without auto — verbose and brittle
    std::map<std::string, std::vector<int>>::iterator it1 = my_map.begin();
    
    // With auto — clear intent, resilient to type changes
    auto it2 = my_map.begin();     // Same type, compiler deduces it
    
    // Fundamental types
    auto i  = 42;          // int
    auto d  = 3.14;        // double
    auto f  = 3.14f;       // float  (suffix forces float)
    auto l  = 42LL;        // long long
    auto u  = 42U;         // unsigned int
    auto b  = true;        // bool
    
    // auto with explicit reference/const
    auto  x = get_value(); // Copy (auto strips references and const)
    auto& r = get_value(); // Reference to returned value
    const auto& cr = get_expensive_object(); // const reference — no copy
    auto&& fwd = get_value(); // Forwarding reference
    
    // Range-for loops — auto is essential here
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    for (auto n : numbers)       { /* n is int (copy) */ }
    for (auto& n : numbers)      { /* n is int& (modifiable) */ }
    for (const auto& n : numbers){ /* n is const int& (efficient read) */ }
    
    return 0;
}

int x = 5;
int& ref = x;
const int cx = 5;

auto a = ref;    // int (NOT int&!) — auto strips references
auto b = cx;     // int (NOT const int!) — auto strips top-level const

auto& c = ref;   // int& — explicit reference preserved
const auto& d = x; // const int& — explicit const reference

// auto and initializer_list:
auto e = {1, 2, 3};   // std::initializer_list<int>  ← common surprise!
auto f{1};             // int (single-element brace init — C++17)

// Return type deduction:
auto add(int a, int b) -> int { return a + b; } // Trailing return type
auto mul(int a, int b) { return a * b; }        // Deduced return type (C++14)

// Auto in lambdas:
auto square = [](auto x) { return x * x; };  // Generic lambda (C++14)
square(5);    // -> 25 (int)
square(3.14); // -> 9.8596 (double)

// const variable — value cannot change after initialization
const int MAX_SIZE = 1024;
// MAX_SIZE = 2048; // ERROR: assignment of read-only variable

// const pointer (pointer itself is const, data is mutable)
int value = 42;
int* const ptr = &value;  // ptr cannot point elsewhere
*ptr = 100;               // OK: data is mutable

// pointer to const (data is const, pointer is mutable)
const int* cptr = &value; // cptr can point elsewhere
// *cptr = 100;           // ERROR: data is read-only
cptr = &MAX_SIZE;         // OK: pointer is mutable

// const reference — enables const with complex types at zero cost
void print_name(const std::string& name) {
    // name cannot be modified
    // No copy of the string is made (reference)
    std::cout << name << '\n';
}

// const method — does not modify the object
class Temperature {
    double celsius_;
public:
    Temperature(double c) : celsius_(c) {}
    double to_fahrenheit() const {    // const method
        return celsius_ * 9.0/5.0 + 32.0;
    }
    void set(double c) { celsius_ = c; } // Non-const method
};

#include <array>

// constexpr variable — computed at compile time
constexpr int BUFFER_SIZE = 4 * 1024;   // 4096
constexpr double PI = 3.14159265358979;

// constexpr function — can be called at compile OR runtime
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int F10 = factorial(10); // Computed at compile time: 3628800
// static_assert ensures the value is compile-time:
static_assert(F10 == 3628800, "Factorial computation failed");

// constexpr array — fully computed at compile time
constexpr std::array<int, 10> FIBONACCI = []() {
    std::array<int, 10> arr{};
    arr[0] = 0; arr[1] = 1;
    for (int i = 2; i < 10; i++) arr[i] = arr[i-1] + arr[i-2];
    return arr;
}();  // Immediately Invoked Function Expression (IIFE)

// constexpr class
class Vector2D {
    double x_, y_;
public:
    constexpr Vector2D(double x, double y) : x_(x), y_(y) {}
    constexpr double magnitude() const {
        // Note: sqrt is not constexpr in C++17; use std::sqrt in C++23
        return x_*x_ + y_*y_;  // Return squared for constexpr demo
    }
};

constexpr Vector2D unit_x{1.0, 0.0};
constexpr auto len_sq = unit_x.magnitude(); // Compile-time: 1.0

// consteval: function MUST be evaluated at compile time
// (constexpr can also run at runtime; consteval cannot)
consteval int must_be_compile_time(int n) {
    return n * n;
}

constexpr int runtime_or_compile = must_be_compile_time(5); // OK: 25
// int runtime_val = must_be_compile_time(argc); // ERROR: runtime argument

// constinit: variable MUST be initialized at compile time,
// but CAN be modified at runtime (unlike constexpr)
constinit int global_counter = 0;  // Initialized at compile time
// Prevents "static initialization order fiasco" for global variables

// C-style NULL ambiguity (dangerous):
void overloaded(int n);
void overloaded(int* p);

overloaded(NULL);   // Calls overloaded(int)! NOT overloaded(int*)
// This is a silent bug — NULL == 0 (integer)

// C++ nullptr — type-safe null pointer constant:
overloaded(nullptr); // Calls overloaded(int*) — correct!

// nullptr has type nullptr_t — implicitly converts to any pointer type
int* p = nullptr;           // int* null pointer
std::string* s = nullptr;   // string* null pointer
void (*fn)(int) = nullptr;  // Function pointer — also works

// Type safety:
// int n = nullptr; // ERROR: nullptr cannot be assigned to non-pointer
// This prevents accidental integer/pointer confusion

// Smart pointer usage:
#include <memory>
auto uptr = std::unique_ptr<int>(nullptr);  // Null unique_ptr
if (uptr == nullptr) { /* check null */ }
if (!uptr) { /* same check */ }

#include <map>
#include <tuple>
#include <string>

// Decompose std::pair
std::pair<std::string, int> person = {"Alice", 30};
auto [name, age] = person;  // name = "Alice", age = 30

// Decompose std::tuple
auto [x, y, z] = std::make_tuple(1.0, 2.0, 3.0);

// Iterate map — elegant, readable
std::map<std::string, int> scores = {{"Alice", 95}, {"Bob", 82}};
for (const auto& [student, score] : scores) {
    std::cout << student << ": " << score << '\n';
}

// Decompose struct/class (C++17)
struct Color { uint8_t r, g, b; };
Color red{255, 0, 0};
auto [r, g, b] = red; // r=255, g=0, b=0

// Return multiple values cleanly
auto get_stats(const std::vector<int>& v) {
    return std::tuple{*std::min_element(v.begin(), v.end()),
                      *std::max_element(v.begin(), v.end()),
                      std::reduce(v.begin(), v.end()) / (int)v.size()};
}

auto [min, max, avg] = get_stats({1, 5, 3, 8, 2});