Modern C++ Fundamentals: Namespaces, Type Modifiers & Auto

#include <iostream>

// A namespace of your own
namespace Graphics {
    void drawTriangle() {
        std::cout << "Graphics::drawTriangle" << std::endl;
    }
}

// A different library that happens to use the same function name
namespace Physics {
    void drawTriangle() {
        std::cout << "Physics::drawTriangle (collision shape)" << std::endl;
    }
}

// Nested namespace, C++17 syntax
namespace Graphics::Engine {
    void initRenderer() {
        std::cout << "Graphics::Engine::initRenderer" << std::endl;
    }
}

int main() {
    // The prefix is what makes the two drawTriangle() distinguishable
    Graphics::drawTriangle();
    Physics::drawTriangle();
    Graphics::Engine::initRenderer();
    return 0;
}

#include <iostream>

// using declaration: pull in ONE name only
using std::cout;
using std::endl;

int main() {
    cout << "Safer than using namespace std" << endl;

    // Scoped to this block only - the safest form
    {
        using std::cin;
        int x;
        cin >> x;
    }

    return 0;
}

namespace fs = std::filesystem;  // Alias
namespace ba = boost::asio;      // Alias

// Now the call sites stay short
fs::path my_path = "/tmp/file.txt";
ba::io_context io;

int main() {
    // A const variable: cannot be reassigned after initialisation
    const int MAX_SIZE = 100;
    // MAX_SIZE = 200;      // ERROR: cannot assign to a const

    int x = 10, y = 20;

    // CONST POINTER: the pointer is fixed, the value it points at is not.
    // Read it right-to-left: "ptr is a const pointer to int".
    int* const ptr = &x;
    *ptr = 30;              // OK - writing through it is allowed
    // ptr = &y;            // ERROR: the pointer itself cannot be repointed

    // POINTER TO CONST: the opposite. The pointer moves, the value is read-only.
    // "to_const is a pointer to const int".
    const int* to_const = &x;
    // *to_const = 40;      // ERROR: cannot write through a pointer-to-const
    to_const = &y;          // OK - repointing is allowed

    return 0;
}

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

int main() {
    // Evaluated at COMPILE time, not at run time
    constexpr int result = factorial(5);  // The compiler computes 5! = 120

    // A compile-time constant array
    constexpr int arr[] = {1, 2, 3, 4, 5};

    return 0;
}

// volatile is for hardware registers and memory written from outside
volatile int hardware_counter = 0;  // May change without this code touching it

// The compiler may not cache it in a register - every read hits memory
while (hardware_counter < 100) {
    // hardware_counter is re-read on every iteration
}

// const volatile: this code may not write it, but something else may
const volatile int* hw_ptr = &hardware_counter;

#include <iostream>
#include <map>
#include <vector>

int main() {
    // auto with ordinary values
    auto x = 42;           // int
    auto name = "John";    // const char*
    auto pi = 3.14159;     // double

    // auto with STL containers
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // Instead of: std::vector<int>::iterator it = numbers.begin();
    // just write:
    auto it = numbers.begin();

    // Range-based for loop with auto
    for (auto num : numbers) {
        std::cout << num << " ";  // auto deduces int here
    }

    // Map iterators get verbose fast - this is where auto really pays
    std::map<std::string, int> scores;
    for (const auto& [name, score] : scores) {  // Structured binding (C++17)
        std::cout << name << ": " << score << std::endl;
    }

    return 0;
}

#include <iostream>
#include <string>
#include <vector>

struct Report {
    std::string title;
    std::string body;   // imagine this is a few hundred KB
    Report(std::string t, std::string b) : title(std::move(t)), body(std::move(b)) {}
    Report(const Report& other) : title(other.title), body(other.body) {
        std::cout << "  [COPY " << title << "]\n";   // count every copy
    }
};

int main() {
    std::vector<Report> reports;
    reports.reserve(2);   // Without reserve the vector reallocates and copies once by itself
    reports.emplace_back("A", "...");
    reports.emplace_back("B", "...");

    std::cout << "auto (copies every element):\n";
    for (auto r : reports) {
        std::cout << "  read " << r.title << "\n";
    }

    std::cout << "const auto& (no copy):\n";
    for (const auto& r : reports) {
        std::cout << "  read " << r.title << "\n";
    }

    std::cout << "auto& (no copy, AND writable):\n";
    for (auto& r : reports) {
        r.title += "!";
    }
    for (const auto& r : reports) std::cout << "  " << r.title << "\n";

    return 0;
}

auto (copies every element):
  [COPY A]
  read A
  [COPY B]
  read B
const auto& (no copy):
  read A
  read B
auto& (no copy, AND writable):
  A!
  B!

#include <iostream>
#include <iomanip>

int main() {
    std::cout << "Hello, C++!" << std::endl;

    // Chaining several values in one statement
    int age = 25;
    double height = 1.75;
    std::cout << "Age: " << age << ", Height: " << height << std::endl;

    // Number formatting
    std::cout << std::fixed << std::setprecision(2) << height << std::endl;

    // Hexadecimal and octal
    std::cout << std::hex << 255 << std::endl;      // ff
    std::cout << std::oct << 255 << std::endl;      // 377
    std::cout << std::dec << 255 << std::endl;      // 255

    return 0;
}

#include <iostream>
#include <string>

int main() {
    // Read an integer
    int x;
    std::cout << "Enter an integer: ";
    std::cin >> x;

    // Read one word (stops at whitespace)
    std::string word;
    std::cout << "Enter a word: ";
    std::cin >> word;

    // Read a whole line, spaces included
    std::string line;
    std::cout << "Enter a sentence: ";
    std::getline(std::cin, line);

    std::cout << "You entered: " << line << std::endl;

    return 0;
}

int main() {
    double d = 3.14159;
    int i = (int)d;  // Truncates to 3 - data lost, and nothing warns you

    // Dangerous: reinterprets a string literal's address as an int*
    int* ptr = (int*) "dangerous string cast";  // UB!

    return 0;
}

int main() {
    double d = 3.14159;
    int i = static_cast<int>(d);  // Explicit conversion, loss of precision OK

    // Between numeric types
    float f = static_cast<float>(42);

    // Up a class hierarchy: Derived* -> Base* is always safe
    class Base {};
    class Derived : public Base {};

    Derived d_obj;
    Base* base_ptr = static_cast<Base*>(&d_obj);  // Derived -> Base (safe)

    return 0;
}

void modifyData(int* ptr) {
    *ptr = 999;
}

int main() {
    const int x = 10;

    // const_cast strips the const qualifier
    modifyData(const_cast<int*>(&x));

    // UNDEFINED BEHAVIOUR - and not only "if x sits in read-only memory".
    // Writing to an object that was DECLARED const is UB, full stop.
    // See what actually happens, measured, right below this block.

    return 0;
}

$ g++ -std=c++17 -O2 constcast.cpp && ./a.out
x doc truc tiep    = 10
x doc qua con tro  = 999
x doc qua p        = 999

#include <iostream>

int main() {
    int x = 42;

    // Turn an address into an integer
    unsigned long long addr = reinterpret_cast<unsigned long long>(&x);

    std::cout << "Address: 0x" << std::hex << addr << std::endl;

    // ...and back again
    int* ptr = reinterpret_cast<int*>(addr);

    // Only reach for this when nothing else can express what you need

    return 0;
}

#include <iostream>

struct Shape {
    virtual ~Shape() = default;   // Needs a virtual function, or dynamic_cast will not compile
};
struct Circle : Shape {
    void area() { std::cout << "  Circle::area\n"; }
};
struct Square : Shape {};

void handle(Shape* shape) {
    // Ask directly: is this object actually a Circle?
    if (Circle* c = dynamic_cast<Circle*>(shape)) {
        std::cout << "yes, it is a Circle\n";
        c->area();
    } else {
        std::cout << "NOT a Circle -> dynamic_cast returned nullptr\n";
    }
}

int main() {
    Circle c;
    Square sq;
    handle(&c);
    handle(&sq);

    // static_cast checks NOTHING: it takes your word for it, and stays silent.
    Circle* wrong = static_cast<Circle*>(static_cast<Shape*>(&sq));
    std::cout << "static_cast gave a non-null pointer? " << (wrong != nullptr) << "\n";

    return 0;
}

yes, it is a Circle
  Circle::area
NOT a Circle -> dynamic_cast returned nullptr
static_cast gave a non-null pointer? 1