static vs global vs extern, Storage & Compilation Pipeline

#include <cstddef>
#include <iomanip>
#include <iostream>

class ServiceRegistry {
    int serviceId_{0};
    // Meaning 3: Class static data member (shared across all instances)
    inline static std::size_t activeCount_{0};

    // Private constructor for singleton control
    ServiceRegistry() : serviceId_(101) {
        ++activeCount_;
    }

public:
    ~ServiceRegistry() {
        if (activeCount_ > 0) --activeCount_;
    }

    // Meaning 1: Function-local static (Meyers Singleton, thread-safe since C++11)
    static ServiceRegistry& instance() {
        static ServiceRegistry s_instance; // Magic static: atomic init guard
        return s_instance;
    }

    // Meaning 4: Class static member function (no hidden 'this' pointer)
    static std::size_t getActiveCount() noexcept {
        return activeCount_;
    }

    int getId() const noexcept { return serviceId_; }
};

// Meaning 2: File-scope internal linkage (private to this translation unit)
static int g_tuPrivateCounter = 0;

void incrementCounter() {
    // Function-local static sequence generator
    static int s_seq = 1000;
    ++s_seq;
    ++g_tuPrivateCounter;
    std::cout << "incrementCounter: s_seq=" << s_seq << ", g_tuPrivateCounter=" << g_tuPrivateCounter << '\n';
}

int main() {
    std::cout << "--- Meyers Singleton Access ---\n";
    ServiceRegistry& reg1 = ServiceRegistry::instance();
    std::cout << "reg1 ID: " << reg1.getId() << ", Active count: " << ServiceRegistry::getActiveCount() << '\n';

    ServiceRegistry& reg2 = ServiceRegistry::instance();
    std::cout << "reg2 ID: " << reg2.getId() << '\n';
    std::cout << "Identity check (&reg1 == &reg2): " << std::boolalpha << (&reg1 == &reg2) << '\n';

    std::cout << "\n--- Static Counter Increments ---\n";
    incrementCounter();
    incrementCounter();
    incrementCounter();

    return 0;
}

#include <cstddef>
#include <print>
#include <thread>

// ============================================================================
// 1. STORAGE DURATION & LINKAGE IN C++
// - Internal Linkage: Symbol visible ONLY within this translation unit (.cpp)
// - External Linkage: Symbol exported and accessible across multiple .cpp files
// - Static Duration: Lives in .data/.bss segment from program start to exit
// - Thread-Local Duration: Distinct instance per OS thread, cleaned up on thread exit
// ============================================================================

// Case 1: File-scope static -> Internal Linkage
// Prevents symbol collisions with other .cpp files having the same variable name.
static const char* kModuleTag = "M1.4-StorageLinkage";

namespace {
    // Case 2: Anonymous namespace -> Modern C++ replacement for file-scope static.
    // Generates a unique compiler-generated namespace name for internal linkage.
    int tuLocalSeed = 999;
}

// Case 3: Class static members
class Widget {
    int id_{0}; // Non-static member: 4 bytes per instance, stored on stack/heap

    // Class static data member (C++17 inline static):
    // Stored once in .data/.bss memory, shared across ALL instances.
    // Does NOT increase sizeof(Widget)! sizeof(Widget) is strictly 4 bytes.
    inline static int activeInstances_{0};

public:
    explicit Widget(int id) : id_(id) {
        ++activeInstances_; // Increments shared global counter on every construction
    }

    ~Widget() {
        --activeInstances_; // Decrements shared counter when any instance is destroyed
    }

    Widget(const Widget&) = delete;
    Widget& operator=(const Widget&) = delete;

    [[nodiscard]] int getId() const noexcept { return id_; }

    // Class static member function:
    // Has NO hidden 'this' pointer! Cannot access 'id_' without an explicit object.
    // Cannot be marked 'const' or 'virtual'. Can be called as Widget::getActiveCount().
    [[nodiscard]] static int getActiveCount() noexcept {
        return activeInstances_;
    }
};

// Case 4: Function-local static variable ("Magic Statics" in C++11)
// Initialized exactly once on the FIRST time the function is called.
// C++11 standard mandates thread-safe initialization with zero double-lock bugs.
int generateTransactionId() {
    static int seq = 1000; // Lives in .data, initialized once
    return ++seq;
}

// Case 5: thread_local storage duration
// Each thread gets its own private, isolated copy of 'tlsCounter'.
thread_local int tlsCounter = 0;

int main() {
    std::println("=== All 4 Meanings of static in C++ ===");

    // Meaning 1: Function-local static sequence generator
    int id1 = generateTransactionId();
    int id2 = generateTransactionId();
    int id3 = generateTransactionId();
    std::println("Function-local static IDs: {}, {}, {}", id1, id2, id3);

    // Meaning 2: Internal linkage
    std::println("Internal linkage: tag={}, seed={}", kModuleTag, tuLocalSeed);

    // Meaning 3 & 4: Class static member and method
    std::println("Initial Widget active count = {}", Widget::getActiveCount());
    std::println("sizeof(Widget) = {} bytes (identical to sizeof(int))", sizeof(Widget));

    {
        Widget w1(101);
        Widget w2(102);
        std::println("Created 2 widgets: active count = {}", Widget::getActiveCount());
        std::println("w1 id={}, w2 id={}", w1.getId(), w2.getId());
    }
    std::println("After block exit: active count = {}", Widget::getActiveCount());

    // thread_local storage isolation across std::threads (deterministic sequence)
    std::thread t1([]() {
        for (int i = 0; i < 3; ++i) ++tlsCounter;
        std::println("Thread 1 finished: tlsCounter = {}", tlsCounter);
    });
    t1.join();

    std::thread t2([]() {
        for (int i = 0; i < 3; ++i) ++tlsCounter;
        std::println("Thread 2 finished: tlsCounter = {}", tlsCounter);
    });
    t2.join();

    std::println("Main thread tlsCounter = {} (completely isolated from workers)", tlsCounter);
    return 0;
}