第四节 · 公共场所 · 类作用域与静态成员

我们知道，每个对象都有自己的成员变量副本。但有时候，我们需要所有对象共享某些数据，比如统计创建了多少个对象、存储类级别的配置信息等。

这就是静态成员的用武之地。

---

类作用域

在深入静态成员之前，让我们先了解类作用域。

类作用域是指类定义的花括号内的范围。在这个范围内定义的名字，都属于该类：

class MyClass
{
public:
    int value;           // 成员变量，属于 MyClass 作用域
    
    void func()          // 成员函数，属于 MyClass 作用域
    {
        int local = 10;  // 局部变量，属于函数作用域
        value = local;   // 可以访问类成员
    }
    
    typedef int MyInt;   // 类型别名，属于 MyClass 作用域
};

int main()
{
    MyClass obj;
    obj.value = 5;           // 通过对象访问成员
    obj.func();
    MyClass::MyInt x = 10;   // 通过 :: 访问类作用域中的类型
    return 0;
}

在类外引用类作用域中的名字，需要使用作用域解析运算符 ::。

---

静态成员变量

静态成员变量是属于类本身而不是某个对象的变量。所有对象共享同一个静态成员变量。

class Counter
{
public:
    static int count;  // 声明静态成员变量
    
    Counter()
    {
        count++;  // 每创建一个对象，计数加 1
    }
    
    ~Counter()
    {
        count--;  // 每销毁一个对象，计数减 1
    }
};

// 在类外定义和初始化静态成员变量
int Counter::count = 0;

int main()
{
    cout << "当前对象数: " << Counter::count << endl;  // 0
    
    Counter c1;
    cout << "当前对象数: " << Counter::count << endl;  // 1
    
    Counter c2;
    Counter c3;
    cout << "当前对象数: " << Counter::count << endl;  // 3
    
    {
        Counter c4;
        cout << "当前对象数: " << Counter::count << endl;  // 4
    }  // c4 在这里被销毁
    
    cout << "当前对象数: " << Counter::count << endl;  // 3
    
    return 0;
}

静态成员变量的特点：

1. 所有对象共享同一份数据

2. 在程序启动时创建，程序结束时销毁

3. 必须在类外定义（除了 const 静态成员）

4. 可以通过类名或对象访问

// 访问方式
Counter::count;  // 通过类名访问（推荐）
c1.count;        // 通过对象访问（不推荐，容易误解为普通成员）

---

静态常量成员

如果静态成员是常量，可以在类内直接初始化：

class Config
{
public:
    static const int MAX_SIZE = 100;         // OK
    static const double PI;                  // const double 需要在类外定义
    static constexpr int VALUE = 42;         // C++11，constexpr 可以直接初始化
    static constexpr double E = 2.71828;     // OK
};

// const double 仍然需要在类外定义
const double Config::PI = 3.14159;

int main()
{
    cout << Config::MAX_SIZE << endl;  // 100
    cout << Config::PI << endl;        // 3.14159
    return 0;
}

---

静态成员函数

静态成员函数是不依赖于任何对象的函数。它没有 this 指针，只能访问静态成员。

class MathUtil
{
public:
    static const double PI;
    
    // 静态成员函数
    static double circleArea(double radius)
    {
        return PI * radius * radius;
    }
    
    static double circleCircumference(double radius)
    {
        return 2 * PI * radius;
    }
};

const double MathUtil::PI = 3.14159;

int main()
{
    // 不需要创建对象，直接通过类名调用
    cout << "面积: " << MathUtil::circleArea(5) << endl;
    cout << "周长: " << MathUtil::circleCircumference(5) << endl;
    return 0;
}

静态成员函数的特点：

1. 没有 this 指针

2. 只能访问静态成员（变量和函数）

3. 可以在没有对象的情况下调用

4. 不能是 const 或 virtual

class Example
{
private:
    int normalVar;
    static int staticVar;
    
public:
    static void staticFunc()
    {
        // normalVar = 10;  // 错误！不能访问非静态成员
        staticVar = 10;     // OK，可以访问静态成员
    }
    
    // static void func() const;  // 错误！静态函数不能是 const
};

---

静态成员的应用场景

1. 单例模式

确保一个类只有一个实例：

class Singleton
{
private:
    static Singleton* instance;
    
    // 私有构造函数，禁止外部创建对象
    Singleton() {}
    
public:
    // 删除拷贝构造和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton* getInstance()
    {
        if (instance == nullptr)
            instance = new Singleton();
        return instance;
    }
    
    void doSomething()
    {
        cout << "Singleton doing something" << endl;
    }
};

Singleton* Singleton::instance = nullptr;

int main()
{
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    
    cout << (s1 == s2) << endl;  // 1，两个指针指向同一个对象
    
    s1->doSomething();
    
    return 0;
}

2. 工厂方法

class Shape
{
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
    
    // 静态工厂方法
    static Shape* create(const string& type);
};

class Circle : public Shape
{
public:
    void draw() override { cout << "Drawing Circle" << endl; }
};

class Rectangle : public Shape
{
public:
    void draw() override { cout << "Drawing Rectangle" << endl; }
};

Shape* Shape::create(const string& type)
{
    if (type == "circle")
        return new Circle();
    else if (type == "rectangle")
        return new Rectangle();
    return nullptr;
}

3. 工具类

class StringUtil
{
public:
    static string toUpper(const string& s)
    {
        string result = s;
        for (char& c : result)
            c = toupper(c);
        return result;
    }
    
    static string toLower(const string& s)
    {
        string result = s;
        for (char& c : result)
            c = tolower(c);
        return result;
    }
    
    static vector<string> split(const string& s, char delimiter)
    {
        vector<string> result;
        string token;
        istringstream stream(s);
        while (getline(stream, token, delimiter))
            result.push_back(token);
        return result;
    }
};

int main()
{
    cout << StringUtil::toUpper("hello") << endl;  // HELLO
    cout << StringUtil::toLower("WORLD") << endl;  // world
    
    auto parts = StringUtil::split("a,b,c,d", ',');
    for (const string& p : parts)
        cout << p << " ";  // a b c d
    cout << endl;
    
    return 0;
}

---

类内静态成员初始化（C++17）

C++17 允许使用 inline 关键字在类内直接定义静态成员：

class Modern
{
public:
    inline static int value = 42;        // C++17
    inline static string name = "test";  // C++17
};
// 不需要在类外定义了

---

静态成员让我们能够在类级别存储数据和定义行为，是组织代码的重要工具。

习题

• 设计一个 BankAccount 类，使用静态成员变量存储银行的总存款金额，每次存款或取款时更新。

• 设计一个 ID Generator 类，使用静态成员自动为每个对象分配唯一的 ID。

• 实现一个简单的单例日志类 Logger，提供静态方法记录日志信息。