大话C++：第14篇 静态类成员

在C++中，静态成员（包括静态成员变量和静态成员函数）是类的一部分，但它们的行为与普通的非静态成员不同。静态成员是与类本身相关联的，而不是与类的任何特定对象实例相关联的。这意味着无论创建多少个类的对象，都只有一个静态成员的副本。

1 静态成员变量

静态成员变量是类的所有对象共享的。它们是类的全局变量，但只能在类内部声明和定义。静态成员变量在整个程序运行期间只存在一份拷贝，无论创建多少个类的对象实例。

静态成员变量在类内声明，但必须在类外定义和初始化。定义和初始化通常在类的实现文件中进行。

// 类声明
class MyClass 
{
public:
    static int count; // 声明静态成员变量
    // ...
};

// 定义和初始化静态成员变量
int MyClass::count = 0; 

静态成员变量可以通过类名和作用域解析运算符（::）来访问，也可以通过类的对象来访问。

// 通过类名访问
MyClass::count = 10; 

// 通过对象访问
MyClass obj;
obj.count = 20; 

静态成员变量的完整代码示例：

// my_class.h
#ifndef __MYCLASS_H__
#define __MYCLASS_H__

class MyClass 
{
public:
    // 静态成员变量声明
    static int count;

    // 构造函数
    MyClass() 
    {
        // 每次创建对象时，增加静态成员的计数
        count++;
    }

    // 静态成员函数声明
    static void PrintCount();
};

// my_class.cpp
#include "my_class.h"
#include <iostream>

// 静态成员变量定义和初始化
int MyClass::count = 0;

// 静态成员函数定义
void MyClass::PrintCount() 
{
    std::cout << "count=" << count << std::endl;
}

// main.cpp
#include "my_class.h"

int main() 
{
    // 创建MyClass对象
    MyClass obj1;
    MyClass obj2;
    MyClass obj3;

    // 调用静态成员函数来打印对象的数量
    MyClass::PrintCount();

    // 通过对象来访问静态成员变量（不推荐，因为通常我们直接通过类名访问静态成员）
    std::cout << "对象obj1中的count=" << obj1.count << " objects." << std::endl;

    return 0;
}

2 const 静态成员变量

在C++中，const静态成员变量是一种特殊的静态成员，它的值在编译时就被设定，并且在程序的生命周期内不能改变。这意味着const静态成员变量必须在类声明时就被初始化，且初始化只能进行一次。

// my_class.h
#ifndef __MYCLASS_H__
#define __MYCLASS_H__

class MyClass 
{
private:
    // 静态成员变量，用于跟踪创建的实例数量
    static int instanceCount;

    // const静态成员变量，定义最大实例数量
    static const int kMaxInstances = 5;

public:
    // 构造函数
    MyClass();

    // 析构函数
    ~MyClass();

    // 静态成员函数，返回当前实例数量
    static int GetInstanceCount() 
    {
        return instanceCount;
    }

    // 静态成员函数，检查是否可以创建新实例
    static bool CreateInstance() 
    {
        return instanceCount < kMaxInstances;
    }
};

// my_class.cpp
#include <iostream>
#include "my_class.h"

// 初始化静态成员变量
int MyClass::instanceCount = 0;

MyClass::MyClass() 
{
    // 检查是否超过了最大实例数量
    if (!CreateInstance()) 
    {
        std::cout << "实例创建已经达到上限，无法创建!" << std::endl;
    } 
    else 
    {
        // 增加实例计数
        ++instanceCount;
        std::cout << "创建实例 " << instanceCount << std::endl;
    }
}

MyClass::~MyClass() 
{
    // 减少实例计数
    if (instanceCount > 0) 
    {
        --instanceCount;
        std::cout << "销毁实例 " << (instanceCount + 1) << std::endl;
    }
}

// main.cpp
#include "my_class.h"

int main() 
{
    // 尝试创建MyClass的实例
    if (MyClass::CreateInstance()) 
    {
        MyClass obj1;
        MyClass obj2;
        MyClass obj3;
        MyClass obj4;
        MyClass obj5;

        // 尝试创建第6个实例，应该失败
        if (!MyClass::CreateInstance()) 
        {
            std::cout << "无法创建更多的实例." << std::endl;
        }
    } 
    else
    {
        std::cout << "无法创建任何实例." << std::endl;
    }

    // 销毁对象以演示析构函数的工作
    obj1.~MyClass();
    obj2.~MyClass();
    obj3.~MyClass();
    obj4.~MyClass();
    obj5.~MyClass();

    return 0;
}

3 静态成员函数

静态成员函数是只能访问静态成员变量和其他静态成员函数的成员函数。它们不能访问类的非静态成员（包括非静态成员变量和非静态成员函数），因为非静态成员需要通过类的对象来访问。

静态成员函数在类内声明和定义，就像普通的成员函数一样。

// 类声明
class MyClass 
{
public:
    // 静态成员变量声明
    static int count;
    // 声明静态成员函数
    static void IncrementCount(); 
    // ...
};

// 静态成员函数的定义
void MyClass::IncrementCount() 
{
    // 只能访问静态成员变量
    count++; 
}

静态成员函数可以通过类名和作用域解析运算符（::）来调用，也可以通过类的对象来调用。

// 通过类名调用
MyClass::IncrementCount(); 
// 通过对象调用
MyClass obj;
obj.IncrementCount(); 

静态成员函数的完整代码示例：

// bank_account.h
#ifndef __BANKACCOUNT_H__
#define __BANKACCOUNT_H__

class BankAccount 
{
private:
    static double totalBalance; // 静态成员变量
    double balance;             // 非静态成员变量

public:
    BankAccount(double initialDeposit); // 构造函数
    void Deposit(double amount);        // 存款函数
    void WithDraw(double amount);       // 取款函数

    // 静态成员函数，用于获取所有账户的总余额
    static double GetTotalBalance() {
        return totalBalance;
    }
};

// bank_account.cpp
#include <iostream>
#include "bank_account.h"

// 静态成员变量初始化
double BankAccount::totalBalance = 0.0;

BankAccount::BankAccount(double initialDeposit)
{
    balance = initialDeposit;
    // 更新总余额
    totalBalance += initialDeposit;
}

void BankAccount::Deposit(double amount)
{
    balance += amount;
    // 更新总余额
    totalBalance += amount; 
}

void BankAccount::WithDraw(double amount) 
{
    if (balance >= amount) 
    {
        balance -= amount;
        // 更新总余额
        totalBalance -= amount; 
    } 
    else {
        std::cout << "无效账户!" << std::endl;
    }
}

// main.cpp
#include "bank_account.h"

int main()
{
    // 创建第一个账户并初始存款1000
    BankAccount account1(1000.0); 
    // 创建第二个账户并初始存款500
    BankAccount account2(500.0);

    std::cout << "交易前的账户余额: " << BankAccount::GetTotalBalance() << std::endl;

    // 第一个账户存款200
    account1.Deposit(200.0);  
    // 第二个账户取款100
    account2.WithDraw(100.0);    

    std::cout << "交易后的账户余额: " << BankAccount::GetTotalBalance() << std::endl;

    return 0;
}

注意，静态成员函数不能访问非静态成员变量，因为它们不与任何特定的对象实例相关联。如果静态成员函数需要访问非静态成员变量，那么它就需要一个对象实例作为参数，或者它本身就应该被设计为非静态的。

4 注意事项

静态类成员是C++中类的重要组成部分，它们有一些特定的注意事项，包括以下几个方面：

• 存储位置：静态成员变量在内存中只存储一份，无论创建多少个类的对象实例。静态成员变量是在全局数据区分配的，而不是在类的对象实例中分配的。

• 初始化：静态成员变量必须在类外部进行初始化，不能在类声明时直接初始化。初始化通常在一个源文件中进行，而且只能初始化一次。如果需要在多个源文件中使用静态成员变量，则需要在一个源文件中定义，并在其他源文件中使用extern关键字声明。

• 访问：静态成员变量可以通过类名和作用域解析运算符::来访问，也可以通过类的对象实例来访问。静态成员函数只能访问静态成员变量和其他静态成员函数，不能访问非静态成员。

• 生命周期：静态成员变量的生命周期是整个程序的运行期间，而不是局限于某个对象的生命周期。当程序结束时，静态成员变量会被销毁。

• 线程安全：在多线程环境中，对静态成员变量的访问需要进行适当的同步，以避免竞态条件。例如，可以使用互斥锁（mutex）来保护对静态成员变量的访问。

• 静态成员函数：静态成员函数不能访问类的非静态成员变量和非静态成员函数，因为静态成员函数不与任何对象实例相关联。静态成员函数只能通过类名或对象实例来调用。

• const和constexpr静态成员：如果静态成员变量是const或constexpr类型的，则可以在类声明时直接初始化。这样的静态成员变量实际上是在编译时计算的，因此它们在编译时就已经确定了值。

• 继承：在继承关系中，派生类不能访问基类的静态成员，除非基类将其静态成员声明为protected或public。派生类可以定义与基类同名的静态成员，但它们是两个完全不同的静态成员。

• 静态成员与友元：静态成员函数不能作为类的友元函数。友元函数通常是普通函数，它们可以访问类的私有和保护成员，但静态成员函数不是类的实例，因此不能作为友元函数。

---

欢迎您同步关注我们的微信公众号！！！