C++ 静态成员与非静态成员详解

一、静态成员

静态成员是在成员变量和成员函数前面加上关键字 static。

二、静态成员变量

1. 静态成员变量的性质

作为静态成员变量，符合以下特点：

• 所有对象共享同一份数据；
• 在编译阶段分配内存，在主函数之前进行构造；
• 类内声明，类外初始化；
• 存放在静态区，不占用对象内存；
• 在发生继承时，静态成员变量不会被继承，父类子类共享同一个静态成员。

#include <iostream>
using namespace std;

class Person {
public:
    static int a;
    Person() {
        this->a++;
    }
};

// 类外初始化
int Person::a = 1;

int main() {
    // 所有对象共享一份数据
    Person a1, a2, a3, a4;
    cout << a1.a << " " << a2.a << " " << a3.a << " " << a4.a << endl; // 输出 5 5 5 5
    
    // 存放在静态区，不占用对象内存
    cout << sizeof(a1); // 输出 1
    return 0;
}

代码中将静态变量 a 初始化为 1，在无参构造函数中，通过自增变量进行初始化。按理来说创建四个类的对象 a1、a2、a3、a4，每次都会调用无参构造方法，这样分别输出四个对象的变量 a，得到的值应该是 2、3、4、5 才对，那为什么实际输出的结果不是这样呢？

这是因为'针对静态变量而言，所有对象都会共享同一份数据'，所以静态变量 a 的最终态（a=5）是所有对象时刻共享的。

2. 静态成员变量的访问

两种方式：1. 通过对象访问；2. 通过类名访问。

class Person {
public:
    static int a;
};

int main() {
    Person a1;
    // 通过对象访问
    a1.a = 100;
    // 通过类名访问
    Person::a = 100;
}

三、静态成员函数

作为静态成员函数，存在以下性质：

• 所有对象共享同一个函数；
• 静态成员函数只能访问静态成员变量；
• 没有 this 指针，所以静态成员函数内部不能访问成员变量和成员函数。

注： 这是因为静态成员函数中没有 this 指针，也就不能区分哪个变量属于哪个对象，进而不能访问非静态成员变量。

据上述几条性质，分别对下面代码中的语句 1、2、3 进行分析如下：

#include <iostream>
using namespace std;

class Person {
    static int a;
    int b;
    void work() { }
    static void fun() {
        a = 100; // 1
        b = 100; // 2
        work();  // 3
        cout << "fun" << endl;
    }
};

• 语句 1：正常执行，因为静态成员函数能够访问静态成员变量。
• 语句 2：报错，因为静态成员函数 Person 中没有 this 指针，不能访问非静态成员变量。
• 语句 3：报错，静态成员函数不能调用非静态成员函数，因为无法给 work() 中的隐藏参数 this 传参。

四、静态成员编程练习

1. 【例】统计对象个数

设计一个类 Counter，要求：

• （1）使用静态成员变量来记录对象的数量；
• （2）提供静态成员函数来获取当前对象的数量。

#include <iostream>
using namespace std;

class Counter {
public:
    static int num;
    Counter() {
        num++;
        cout << "创建对象，当前总数：" << num << endl;
    }
    ~Counter() {
        num--;
        cout << "销毁对象，剩余总数：" << num << endl;
    }
    static int getNum() {
        return num;
    }
};

int Counter::num = 0;

int main() {
    Counter c1, c2, c3, c4, c5;
    cout << "块内对象数：" << Counter::getNum() << endl;
    return 0;
}

程序如上，这里需要注意的点如下：

1. 调用析构函数的时候，对象会自动销毁，所以需要添加对象减少的逻辑；
2. 静态成员变量的初始化应该在类外。

2. 【例】银行账户

设计一个 BankAccount 类，模拟银行账户的基本操作：

• （1）使用静态成员变量记录所有账户的总余额，每个账户对象有自己的余额属性；
• （2）每个账户能够存取；
• （3）提供静态成员函数来查询余额；
• （4）在构造函数和析构函数中更新总余额。

#include <iostream>
using namespace std;

class BankAccount {
public:
    static double sum;
    BankAccount() {}
    BankAccount(double sum) {
        this->sum = sum;
    }
    void addA(double sum) {
        if (sum > 0) {
            cout << "成功存入" << sum << "元" << endl;
            this->sum += sum;
        } else {
            cout << "存储失败" << endl;
            return;
        }
    }
    void disaddA(double sum) {
        if (this->sum >= sum) {
            cout << "成功取出" << sum << "元" << endl;
            this->sum -= sum;
        } else {
            cout << "取出失败，余额不足" << endl;
            return;
        }
    }
    static void getAInf() {
        cout << "余额为：" << sum << "元" << endl;
    }
    ~BankAccount() {
        cout << "余额为：" << sum << endl;
    }
};

double BankAccount::sum = 0;

int main() {
    BankAccount b1;
    b1.addA(100);
    b1.disaddA(78.5);
    b1.getAInf();
    return 0;
}

五、成员与对象大小的关系

在 C++ 中，类里的成员变量和成员函数是分开存储的，只有非静态成员变量才属于类的对象上。也就是说，非静态成员函数、静态成员函数、静态成员变量都不属于类的对象中。可以通过直接输出 sizeof(对象) 来验证该结论，这里不做赘述。

六、空指针访问成员函数

在 C++ 中，空指针也是能调用成员函数的，但是要注意有没有用到 this 指针，如果用到 this 指针，就需要加以判断来保证代码的健壮性。

通过下面代码能够看到空指针访问成员函数的两种不同情况的区别：

#include <iostream>
class MyClass {
public:
    void safeMethod() { }
    void unsafeMethod() {
        std::cout << "Value: " << value << std::endl; // 危险：访问成员变量
    }
private:
    int value = 42;
};

int main() {
    MyClass* ptr = nullptr;
    // 安全调用：空对象不访问成员变量
    ptr->safeMethod(); // 可以正常运行
    // 危险调用：访问成员变量
    ptr->unsafeMethod(); // 运行时崩溃
    return 0;
}

在成员函数 unsafeMethod() 中使用了成员变量 value（使用了 this 指针），程序崩溃。

为了避免这种情况的发生，需要事先判断是否为空指针，再继续下面的程序，如下：

#include <iostream>
using namespace std;

class MyClass {
public:
    void safeMethod() { }
    void unsafeMethod() {
        if (this == nullptr) {
            cout << "空指针不能访问成员变量" << endl;
            return;
        }
        std::cout << "Value: " << value << std::endl;
    }
private:
    int value = 42;
};

int main() {
    MyClass* ptr = nullptr;
    // 安全调用：空指针不访问成员变量
    ptr->safeMethod(); // 可以正常运行
    // 危险调用：访问成员变量
    ptr->unsafeMethod(); // 运行时崩溃
    return 0;
}

七、常函数和常对象

1. 常函数

在成员函数后加 const 就变成了常量成员函数，即常函数。常函数的性质如下：

• 常函数内不可以修改成员属性，也不可以调用非常函数；

注： 这样能够使常函数无法通过修改成员属性来修改自己内部的值，不会因此失去常量性。

• 成员属性声明时加关键字 mutable 后，在常函数中可以修改；
• 如果两个函数名字相同、参数相同，但是一个是常函数，一个是非常函数，那么这两个函数属于函数重载（函数重载的特殊情况），非常对象优先调用非常函数，常对象只能调用常函数。

（1）下面的代码报错，是因为常函数内不能修改成员属性。

#include <iostream>
using namespace std;

class People {
public:
    int num;
    People(int num) { this->num = num; }
    void S() const {
        num = 1;
    }
};

int main() {
    return 0;
}

解决方法是在成员属性处声明 mutable：

#include <iostream>
using namespace std;

class People {
public:
    mutable int num;
    People(int num) { this->num = num; }
    void S() const {
        num = 1;
    }
};

int main() {
    return 0;
}

（2）下面的代码报错，是因为常函数中只能调用常函数。

#include <iostream>
using namespace std;

class People {
public:
    mutable int num;
    People(int num) { this->num = num; }
    void Q() { }
    void S() const {
        this->Q();
    }
};

int main() {
    return 0;
}

2. 常对象

声明对象前加 const 称该对象为常量成员对象，即常对象。常对象的性质如下：

• 常对象只能调用常函数。

下面的代码报错，是因为常对象只能调用常函数，而非常对象既能调用常函数也能调用非常函数，非常对象优先调用非常函数。

#include <iostream>
using namespace std;

class People {
public:
    mutable int num;
    People() {}
    People(int num) { this->num = num; }
    void S() { }
};

int main() {
    const People p;
    p.S();
    return 0;
}

解决方法是将 People 类中的 S() 函数设置为常函数，或者将对象 p 设置为非常对象。