前言

如果說 static 變量讓函數“記住”上一次的狀態，那么 static 成員變量就像是整個類的“共享記憶”。這次，我們將從類的角度來聊聊 static 成員變量和函數，幫你徹底搞懂它們是什么，怎么用。

什么是 static 成員變量？

在 C++ 中，類的成員變量通常是屬于某個具體對象的，每個對象都會有一份獨立的成員變量。而 static 成員變量 可不一樣，它是所有對象共享的一個變量。

舉個例子：

假設我們有一個類 Car，它有一個成員變量 carCount 用來統計車的數量。

如果每個 Car 對象都單獨存儲這個數量，那就沒什么意義了。因為 carCount 應該是所有 Car 對象共享的，而不是每個對象都自有一份。這個時候，就可以用 static 來聲明 carCount。

#include <iostream>
using namespace std;

class Car {
public:
    static int carCount;  // 聲明靜態成員變量

    Car() {
        carCount++;
    }
};

// 靜態成員變量需要在類外定義
int Car::carCount = 0;

int main() {
    Car car1;
    Car car2;

    cout << "Number of cars: " << Car::carCount << endl;  // 輸出：2
    return 0;
}

在這個例子中，carCount 變量是靜態的，所有 Car 對象共享同一個 carCount，所以無論創建多少個 Car 對象，它都會累加。

如何訪問 static 成員？

靜態成員的訪問和普通成員稍微有些不同。普通成員變量需要通過對象來訪問，而靜態成員變量可以通過 類名:: 來直接訪問，甚至不需要創建對象。

訪問靜態成員：

class Car {
public:
    static int carCount;  // 靜態成員變量

    Car() {
        carCount++;
    }
};

// 在類外定義靜態成員
int Car::carCount = 0;

int main() {
    // 直接通過類名訪問靜態成員
    cout << "Initial car count: " << Car::carCount << endl;  // 輸出：0

    Car car1;
    cout << "After one car: " << Car::carCount << endl;  // 輸出：1
    Car car2;
    cout << "After two cars: " << Car::carCount << endl;  // 輸出：2

    return 0;
}

你可以看到，靜態成員 carCount 通過 Car::carCount 來訪問，不需要創建 Car 對象。這樣就避免了不必要的內存浪費。

靜態成員函數

什么是靜態成員函數？

靜態成員函數 是屬于類的，而不是某個對象的。也就是說，你可以通過類名來調用它，而不需要先創建對象。這一點與普通的成員函數不同，普通成員函數是通過對象來調用的。

它有什么特點？

1、類級別的函數：靜態成員函數屬于類級別，不依賴于任何對象。你不需要創建類的實例，就能通過類名直接調用。

2、只能訪問靜態成員：靜態成員函數只能訪問類中的靜態成員變量和其他靜態成員函數，因為它沒有綁定到任何具體的對象，也就無法訪問屬于對象的非靜態成員。

3、沒有 this 指針：普通成員函數有一個隱含的 this 指針，指向調用該函數的對象，而靜態成員函數沒有 this 指針。

與普通成員函數的區別是什么？

• 普通成員函數：普通成員函數是與對象關聯的，它可以訪問類的靜態和非靜態成員。訪問非靜態成員時，它依賴于對象的 this 指針。
• 靜態成員函數：靜態成員函數沒有 this 指針，它不能直接訪問非靜態成員，只能訪問靜態成員。

舉個例子：

#include <iostream>
using namespace std;

class Car {
public:
    static int carCount;  // 靜態成員變量

    Car() {
        carCount++;
    }

    // 靜態成員函數
    static void printCarCount() {
        cout << "Number of cars: " << carCount << endl;
    }
};

// 靜態成員變量需要在類外定義
int Car::carCount = 0;

int main() {
    Car car1;
    Car car2;

    // 通過類名調用靜態成員函數
    Car::printCarCount();  // 輸出：2
    return 0;
}

在上面的代碼中，printCarCount() 是一個靜態成員函數，它只能訪問靜態成員變量 carCount，不能直接訪問非靜態成員變量。如果嘗試訪問非靜態成員，編譯器會報錯。

靜態成員函數不能訪問非靜態成員：

class Car {
public:
    int speed;  // 非靜態成員變量
    static int carCount;  // 靜態成員變量

    static void printSpeed() {
        // 編譯錯誤：靜態成員函數無法訪問非靜態成員變量
        cout << "Speed: " << speed << endl;
    }
};

那為什么靜態成員函數不能訪問非靜態成員？

這個問題其實很好理解，關鍵在于靜態成員函數的“身份”問題。

1、靜態成員函數屬于類，而不是對象：靜態成員函數是在類層面上定義的，它沒有綁定到具體的對象。所以，當你調用靜態成員函數時，它是通過類名來調用的，不依賴于任何特定的對象。

2、非靜態成員屬于對象：而非靜態成員變量和普通成員函數是屬于具體對象的。當你創建一個對象時，非靜態成員才會存在，并且只有通過這個對象才能訪問這些成員。

靜態成員函數無法訪問非靜態成員的原因就是，它不屬于任何特定的對象，所以無法知道該訪問哪個對象的非靜態成員。換句話說，靜態成員函數沒有“this”指針，它無法指向具體的對象，也就不能訪問屬于某個對象的成員。

舉個例子來說明：

還是上面 Car 類的例子，speed 是一個非靜態成員變量，而 carCount 是一個靜態成員變量。

• 當你調用靜態成員函數 printSpeed() 時，它是通過類名來調用的。這個函數沒有“this”指針，無法知道是哪個 Car 對象的 speed 變量。
• 但是，靜態成員函數可以訪問類中的靜態成員 carCount，因為靜態成員是屬于類的，不依賴于具體的對象。

所以，靜態成員函數只能訪問靜態成員變量和其他靜態函數，無法訪問非靜態成員。

小結：

靜態成員函數和對象沒關系，它不屬于某個具體對象，所以它不能直接操作對象的非靜態成員變量。

static 成員的應用場景：

了解了靜態成員變量和靜態成員函數的基本概念，接下來我們來聊聊它們的實際應用場景。雖然在很多情況下，我們的類對象都有自己獨立的成員變量和成員函數，但在某些特定場景下，靜態成員就能派上大用場。

1. 全局共享數據

假設我們有一個程序需要統計不同用戶的訪問次數，而這個次數應該對所有用戶共享，而不是每個用戶都有一份。這時，靜態成員變量就能幫助我們做到這一點。

例如，我們可以在用戶類中創建一個靜態的訪問計數器，所有用戶對象共享這個計數器，這樣每當有用戶訪問時，計數器就會增加，而不需要每個對象都單獨保存一份。

class User {
public:
    static int visitCount;  // 所有用戶共享

    User() {
        visitCount++;
    }
};

// 在類外定義靜態變量
int User::visitCount = 0;

int main() {
    User user1;
    User user2;
    cout << "Total visits: " << User::visitCount << endl;  // 輸出：2
    return 0;
}

在這個例子中，不管你創建多少個 User 對象，它們都會共享同一個 visitCount，這樣就避免了每個用戶對象都存儲計數的重復工作。

2. 工廠模式中的靜態成員

有些時候，類中的靜態成員函數可以幫助你創建對象。工廠模式就是一個常見的例子，它允許你通過靜態成員函數來創建類的實例，而不需要在外部直接調用構造函數。

class Product {
public:
    static Product* createProduct() {
        return new Product();
    }
};

int main() {
    Product* product = Product::createProduct();
    // 使用 product
    delete product;
    return 0;
}

在這里，createProduct 是一個靜態成員函數，用來創建 Product 對象。這種做法能夠封裝對象創建的細節，提供更靈活的控制。

3. 配置類中的靜態成員

在很多程序中，我們可能會有一個配置類，用來保存一些全局的配置數據（如程序的設置、資源路徑、日志級別等）。這些配置信息往往是固定的，不會因為對象的創建而變化。此時，靜態成員變量非常適合用來保存這些共享的數據。

例如，一個全局的日志配置類可以用靜態成員來記錄當前的日志級別：

class Logger {
public:
    static int logLevel;

    static void log(const string& message) {
        if (logLevel >= 2) {
            cout << "Log: " << message << endl;
        }
    }
};

// 在類外定義靜態變量
int Logger::logLevel = 2;

int main() {
    Logger::log("Program started");
    Logger::logLevel = 1;
    Logger::log("Another log");
    return 0;
}

在這個例子中，logLevel 是一個靜態成員，所有日志都根據這個靜態設置來決定是否輸出。

總結：

靜態成員變量和靜態成員函數讓我們在 C++ 中能更方便地管理共享數據和功能。它的一個關鍵特點是：它們屬于整個類，而不是某個具體的對象。所以，多個對象之間能共享同一份數據，避免了每個對象都要獨占一份的情況。這不僅節省內存，也讓代碼更加簡潔高效。

今天我們了解了靜態成員變量和靜態成員函數的基本用法，知道了如何共享數據、訪問靜態成員，還明白了為什么靜態成員函數不能訪問非靜態的成員。