Static Members in C++ Explained — Variables, Methods and Real-World Patterns

#include <iostream>
#include <string>

class DatabaseConnection {
public:
    // DECLARATION only — lives in the class, costs no memory here
    static int activeConnections;

    std::string hostName;

    explicit DatabaseConnection(const std::string& host)
        : hostName(host)
    {
        ++activeConnections;  // every new connection increments the shared counter
        std::cout << "[+] Connected to " << hostName
                  << "  |  Active connections: " << activeConnections << "\n";
    }

    ~DatabaseConnection() {
        --activeConnections;  // destructor decrements — even if exception unwinds the stack
        std::cout << "[-] Disconnected from " << hostName
                  << "  |  Active connections: " << activeConnections << "\n";
    }

    // Any code can ask the class — no object needed
    static int getActiveConnections() {
        return activeConnections;
    }
};

// DEFINITION — exactly one, in exactly one .cpp file
// This is where the memory actually lives
int DatabaseConnection::activeConnections = 0;

int main() {
    std::cout << "Connections before any objects: "
              << DatabaseConnection::getActiveConnections() << "\n\n";

    {
        DatabaseConnection primary("prod-db-01");
        DatabaseConnection replica("prod-db-02");

        std::cout << "\nPeak connections inside scope: "
                  << DatabaseConnection::activeConnections << "\n\n";
    }  // both objects destroyed here — destructors fire automatically

    std::cout << "\nConnections after scope exits: "
              << DatabaseConnection::getActiveConnections() << "\n";

    return 0;
}

#include <iostream>
#include <string>

// A lightweight app-wide configuration holder
// Only one set of config values should ever exist — static members enforce that
class AppConfig {
private:
    // Private constructor: nobody can say 'AppConfig cfg;' directly
    AppConfig() = default;

    static AppConfig* instance;      // pointer to the single config object
    static std::string databaseUrl;  // shared config value
    static int maxRetries;           // shared config value

public:
    // Static factory — the ONLY way to get the config object
    // Creates it on first call, returns the same pointer every subsequent call
    static AppConfig* getInstance() {
        if (instance == nullptr) {
            instance = new AppConfig();  // first caller pays the construction cost
            std::cout << "[AppConfig] Instance created for the first time.\n";
        }
        return instance;
    }

    // Static helper: set config without needing an existing instance
    static void initialise(const std::string& dbUrl, int retries) {
        databaseUrl = dbUrl;   // writing to static data member — perfectly legal
        maxRetries  = retries;
        std::cout << "[AppConfig] Initialised with db=" << databaseUrl
                  << ", retries=" << maxRetries << "\n";
    }

    // Getters — non-static because they're called on the instance in real usage,
    // but they could be static too since they only touch static data
    std::string getDbUrl()    const { return databaseUrl; }
    int         getRetries()  const { return maxRetries;  }
};

// Definitions for all static members — note each needs the full class:: prefix
AppConfig*  AppConfig::instance    = nullptr;
std::string AppConfig::databaseUrl = "";
int         AppConfig::maxRetries  = 3;  // sensible default

// Simulates two separate subsystems both accessing the same config
void startWebServer() {
    AppConfig* cfg = AppConfig::getInstance();
    std::cout << "[WebServer] Connecting to: " << cfg->getDbUrl() << "\n";
}

void startWorkerQueue() {
    AppConfig* cfg = AppConfig::getInstance();
    std::cout << "[WorkerQueue] Max retries: " << cfg->getRetries() << "\n";
}

int main() {
    // Set config once at startup — no object needed for this static call
    AppConfig::initialise("postgres://prod-host:5432/mydb", 5);

    std::cout << "\n";

    startWebServer();    // internally calls getInstance() — same object returned
    startWorkerQueue();  // same object again — no second construction logged

    std::cout << "\nSame instance? "
              << (AppConfig::getInstance() == AppConfig::getInstance() ? "Yes" : "No")
              << "\n";

    return 0;
}

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

class ConnectionPool {
public:
    // In-class initialisation — legal for integral static const
    static const int    DEFAULT_POOL_SIZE = 10;

    // constexpr is the modern, preferred way — works for floats and strings too (C++17)
    static constexpr int    MAX_POOL_SIZE     = 50;
    static constexpr int    MIN_POOL_SIZE     = 2;
    static constexpr double CONNECTION_TIMEOUT = 30.0;  // seconds

    // Instance data — each pool has its own capacity
    int capacity;
    std::vector<std::string> connections;

    explicit ConnectionPool(int poolSize = DEFAULT_POOL_SIZE) {
        // Use the class constant to validate the argument — no magic numbers anywhere
        if (poolSize < MIN_POOL_SIZE || poolSize > MAX_POOL_SIZE) {
            throw std::invalid_argument(
                "Pool size must be between " +
                std::to_string(MIN_POOL_SIZE) + " and " +
                std::to_string(MAX_POOL_SIZE)
            );
        }
        capacity = poolSize;
        connections.reserve(static_cast<size_t>(capacity));
        std::cout << "Pool created with capacity: " << capacity << "\n";
    }

    void addConnection(const std::string& connString) {
        if (static_cast<int>(connections.size()) >= capacity) {
            throw std::runtime_error("Pool is at capacity.");
        }
        connections.push_back(connString);
        std::cout << "  Added: " << connString
                  << "  (" << connections.size() << "/" << capacity << ")\n";
    }

    // Static helper — useful for validation before construction
    static bool isValidSize(int size) {
        return size >= MIN_POOL_SIZE && size <= MAX_POOL_SIZE;
    }
};

// constexpr static members don't need out-of-class definitions in C++17
// but static const integral members initialised in-class are fine across all standards

int main() {
    // Access class constants without any object
    std::cout << "Pool size range: ["
              << ConnectionPool::MIN_POOL_SIZE << ", "
              << ConnectionPool::MAX_POOL_SIZE << "]\n";
    std::cout << "Timeout: " << ConnectionPool::CONNECTION_TIMEOUT << "s\n";
    std::cout << "Default size valid? "
              << (ConnectionPool::isValidSize(ConnectionPool::DEFAULT_POOL_SIZE) ? "Yes" : "No")
              << "\n\n";

    ConnectionPool pool(3);  // small pool for demo
    pool.addConnection("conn://db-01");
    pool.addConnection("conn://db-02");
    pool.addConnection("conn://db-03");

    try {
        pool.addConnection("conn://db-04");  // should throw — pool is full
    } catch (const std::runtime_error& e) {
        std::cout << "Caught: " << e.what() << "\n";
    }

    try {
        ConnectionPool badPool(100);  // exceeds MAX_POOL_SIZE
    } catch (const std::invalid_argument& e) {
        std::cout << "Caught: " << e.what() << "\n";
    }

    return 0;
}

#include <iostream>
#include <string>

// This entire class could live in a .h file — no companion .cpp needed (C++17)
class RequestTracker {
public:
    // inline static — defined right here, no separate definition required
    inline static int totalRequests     = 0;
    inline static int failedRequests    = 0;
    inline static int succeededRequests = 0;

    // constexpr is implicitly inline in C++17 — always was okay in headers
    static constexpr int RATE_LIMIT = 1000;  // max requests per minute

    std::string endpoint;
    int         statusCode;

    RequestTracker(const std::string& ep, int code)
        : endpoint(ep), statusCode(code)
    {
        ++totalRequests;  // shared counter — no out-of-class definition needed

        if (code >= 200 && code < 300) {
            ++succeededRequests;
        } else {
            ++failedRequests;
        }
    }

    // Print the current aggregate stats — callable without any object
    static void printStats() {
        std::cout << "--- Request Stats ---\n";
        std::cout << "  Total:     " << totalRequests     << "\n";
        std::cout << "  Succeeded: " << succeededRequests << "\n";
        std::cout << "  Failed:    " << failedRequests    << "\n";
        std::cout << "  Rate limit: " << RATE_LIMIT << " req/min\n";

        double successRate = totalRequests > 0
            ? (100.0 * succeededRequests / totalRequests)
            : 0.0;
        std::cout << "  Success rate: " << successRate << "%\n";
    }
};

int main() {
    // Simulate a burst of incoming HTTP requests
    RequestTracker r1("/api/users",    200);
    RequestTracker r2("/api/orders",   201);
    RequestTracker r3("/api/products", 404);  // not found — counts as failure
    RequestTracker r4("/api/auth",     500);  // server error
    RequestTracker r5("/api/users",    200);

    std::cout << "\n";
    RequestTracker::printStats();  // class-scope call — no object needed

    return 0;
}