[C++]static静态成员变量和静态成员方法的使用

精神病不行计算机不上班

已于 2024-12-08 12:47:10 修改

阅读量1.7k

点赞数 25

CC 4.0 BY-SA版权

分类专栏： C++初阶学习文章标签： c++ 开发语言

于 2024-12-07 12:49:38 首次发布

本文链接：https://blog.csdn.net/2302_80281315/article/details/144307713

C++初阶学习专栏收录该内容

15 篇文章

订阅专栏

在 C++ 中，静态成员变量和静态成员方法（又叫静态方法、静态成员函数）是类的特殊成员，它们与普通成员变量和成员方法有所不同。静态成员变量和方法不依赖于类的对象，它们属于类本身而不是类的某个实例。

一、静态成员变量

1. 静态成员变量的定义：

静态成员变量是与类相关联的变量，而不是与类的具体实例相关联。它是类的所有对象共享的变量。

静态成员变量的声明使用 static 关键字。
它们在类的所有实例之间共享相同的内存位置。
静态成员变量的初始化只能在类外部进行（通常在类外的实现文件中）。

2. 特点：

共享性：所有类的对象共享静态成员变量，即静态成员变量只有一份副本，所有对象访问的都是同一个数据。
内存：静态成员变量会在程序开始时分配内存，且类的每个对象实例都不会为其单独分配内存。它们由类本身持有，而不是由类的实例持有。
初始化：静态成员变量必须在类外进行初始化，即使它们在类内部定义了初始值。

3. 静态成员变量的使用：

1.代码示例：

#include <iostream>
using namespace std;

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

    MyClass() {
        count++;  // 每创建一个对象，count自增
    }

    static void showCount() {
        cout << "Object count: " << count << endl;
    }
};

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

int main() {
    MyClass obj1;  // 创建第一个对象
    MyClass obj2;  // 创建第二个对象

    MyClass::showCount();  // 输出：Object count: 2
    return 0;
}

2.代码详细分析：

1. 静态成员变量的定义与初始化

1.定义：

static int count; // 静态成员变量声明

这行代码声明了一个静态成员变量 count，它是类 MyClass 的一部分，但不属于任何单一的对象实例。它是 类级别 的变量，也就是说，所有 MyClass 类的对象共享一个 count 变量。

2.初始化：

静态成员变量需要在类外部定义和初始化：

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

这行代码完成了静态成员变量 count 的定义，并初始化为 0。

3. 构造函数

MyClass() 
{ 
    count++; // 每创建一个对象，count自增 
}

每当我们创建 MyClass 的一个对象时，构造函数就会被调用。在构造函数内，count++ 表示每创建一个 MyClass 对象，静态变量 count 就增加 1。因为 count 是静态变量，所以它是 类的所有对象共享的。

4. 静态成员方法

static void showCount() 
{ 
    cout << "Object count: " << count << endl; 
}

showCount 是一个静态成员函数，它也属于整个类，而不是某个对象实例。静态方法可以通过类名直接调用（MyClass::showCount()），而不需要创建对象实例。

静态方法能够访问静态成员变量 count，因为 count 是类的所有对象共享的。

5. 创建对象并调用静态方法

在 main() 函数中，我们创建了两个对象：

MyClass obj1; // 创建第一个对象 
MyClass obj2; // 创建第二个对象

每创建一个对象，构造函数都会执行一次，因此 count 会增加一次。具体过程如下：

当 obj1 被创建时，构造函数执行，count++，count 变成 1。
当 obj2 被创建时，构造函数再次执行，count++，count 变成 2。

然后，我们调用静态成员方法 showCount()：

MyClass::showCount(); // 输出：Object count: 2

此时，count 的值是 2，因此输出结果是：

Object count: 2

6.代码执行过程：

int MyClass::count = 0; — 初始化静态成员变量 count 为 0。
MyClass obj1; — 创建第一个对象 obj1，调用构造函数，count 自增，count 变为 1。
MyClass obj2; — 创建第二个对象 obj2，调用构造函数，count 自增，count 变为 2。
MyClass::showCount(); — 调用静态成员方法 showCount，输出当前的 count 值，即 2。

3. 静态成员变量和方法总结

静态成员变量：属于类而不是某个对象，它被所有对象共享。在类外部初始化一次后，可以通过类名或者对象访问。
静态成员方法：同样属于类而非某个对象，它不能访问对象的实例成员，但可以访问静态成员变量。

4. 静态成员变量的应用场景：

计数器：例如，跟踪某个类被实例化的次数。
常量值：在类中设置常量的值（虽然 C++ 也支持常量成员，但静态成员常量值会在类的所有对象之间共享）。

二、静态成员方法

1. 定义静态成员方法

静态成员方法是与类相关联的函数，不依赖于类的对象进行调用。静态方法只能访问静态成员变量和其他静态方法，不能访问类的实例成员。

静态成员方法的声明和定义使用 static 关键字。
静态成员方法不可以访问非静态成员（也就是需要类对象才能调用的成员）。

2. 特点：

只能访问静态成员：静态成员方法只能访问静态成员变量和其他静态成员方法，不能访问实例化对象的成员变量和成员函数。
调用方式：静态成员函数可以通过类名直接调用，也可以通过对象调用。推荐通过类名调用静态成员方法。
不需要实例化对象：静态成员方法可以在没有创建类对象的情况下调用。

3.静态成员方法的代码示例和使用直接看上面静态成员的代码示例和使用就可以了哈，上面那个代码示例是包括了静态成员方法(showCount()方法)和静态成员变量（cout变量）的使用的。

三、静态成员变量与方法的关系

1. 静态成员方法如何访问静态成员变量？

静态成员方法可以直接访问静态成员变量，因为它们都属于类，而不是某个对象。

class MyClass 
{ 
    public: 
        static int count; 
        static void showCount() 
        { 
            cout << "Current count: " << count << endl; // 可以访问静态成员变量 
        } 
}; 

int MyClass::count = 0;

2. 静态成员方法不能访问非静态成员变量或方法

静态成员方法不能访问非静态成员变量或方法，因为它们是依赖于对象实例的，而静态方法并不依赖于对象实例。

class MyClass 
{ 
    public: 
    int age; // 非静态成员变量 
        static void showAge() 
        { 
            // cout << "Age: " << age; // 错误：不能在静态方法中访问非静态成员 
        } 
};

四、静态成员的初始化和内存管理

1. 静态成员变量的初始化：

静态成员变量在类内部声明，但必须在类外部进行初始化。例如：

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

// 在类外部初始化静态成员变量 
int MyClass::count = 0;

2. 静态成员变量的内存管理：

静态成员变量的生命周期是从程序开始到程序结束。它们在程序的整个执行过程中一直存在。

五、静态成员变量和方法的访问

1.访问静态成员变量：

静态成员变量可以通过类名或对象来访问。但通常推荐通过类名来访问。

MyClass::count = 10; // 通过类名访问静态成员变量 
obj.count = 10; // 通过对象访问静态成员变量

2.访问静态成员方法：

静态成员方法最好通过类名来调用，而不需要创建类的对象。

MyClass::showCount(); // 推荐通过类名调用静态方法 
obj.showCount(); // 也可以通过对象调用，但不推荐

六、关于静态成员函数和静态成员变量与this的使用

1. 静态成员函数与非静态成员函数的区别

非静态成员函数：属于类的实例，每个对象都有一份独立的非静态成员函数。非静态成员函数在执行时，会隐式地拥有一个 this 指针，指向当前对象实例。因此，非静态成员函数能够访问类的所有成员变量和成员函数。
静态成员函数：属于类本身，而不是类的任何实例。静态成员函数没有 this 指针，因为它不依赖于任何对象实例，而是通过类直接调用。静态成员函数只能访问静态成员，因为它没有 this 指针，无法访问实例的成员变量和成员函数。

2. 为什么静态成员函数不能访问非静态成员

静态成员函数没有 this 指针，因为它是属于类的，而不是某个具体的对象实例。this 指针是一个指向当前对象的指针，因此，静态成员函数没有 this，它就无法知道当前对象的状态，也就无法访问该对象的成员变量和成员函数。

3. 静态成员函数与 `this` 的关系

因为静态成员函数没有 this 指针，所以它不能访问非静态成员（包括非静态成员变量和非静态成员函数）。只有通过类的实例，才能访问这些非静态成员。

4. 代码示例：

#include <iostream> 
using namespace std; 
class MyClass 
{ 
    public: 
        int instanceVar; // 非静态成员变量 
        static int staticVar; // 静态成员变量 

        // 构造函数，初始化成员变量 
        MyClass(int val) : instanceVar(val) {} 

       // 非静态成员函数 
        void instanceMethod() 
        { 
            cout << "Instance Method: instanceVar = " << instanceVar << endl; 
        } 

        // 静态成员函数 
        static void staticMethod() 
        { 
            // 下面的代码会出错：静态成员函数不能访问非静态成员 
            // cout << "Static Method: instanceVar = " << instanceVar << endl; // 错误！ 

            // 可以访问静态成员 
            cout << "Static Method: staticVar = " << staticVar << endl; 
        } 
}; 

// 静态成员变量需要单独定义 
int MyClass::staticVar = 42; 

int main() 
{ 
    // 创建对象 obj 
    MyClass obj(100); 

    // 调用非静态成员函数，访问实例成员 
    obj.instanceMethod(); 

    // 调用静态成员函数，通过类名调用 
    MyClass::staticMethod(); 

    // 通过对象也可以调用静态成员函数 
    obj.staticMethod(); // 这个也是可以的，虽然静态成员函数最好通过类名来调用 

    return 0; 
}

5. 代码分析：

instanceVar 是非静态成员变量，属于对象实例，每个对象都有一份独立的 instanceVar。
staticVar 是静态成员变量，属于类本身，类的所有对象共享同一个 staticVar。
instanceMethod 是非静态成员函数，它可以访问当前对象的成员变量 instanceVar。
staticMethod 是静态成员函数，它没有 this 指针，因此不能访问 instanceVar。如果你试图在静态成员函数中访问 instanceVar，编译器会报错。
静态成员函数可以访问静态成员变量（如 staticVar），因为静态成员变量也是属于类本身的。

6. 为什么不能访问非静态成员：

当你调用静态成员函数时，没有明确指定是哪个对象调用的这个函数。因此，静态成员函数不能通过 this 指针来访问对象的成员变量。它不知道对象的状态，因为静态成员函数是通过类名调用的，而不是通过某个具体的对象来调用的。
this 指针指向当前的对象实例，而静态成员函数不依赖于某个具体的对象实例，它是直接通过类名调用的。因此，静态成员函数没有 this 指针，也不能访问非静态成员。

7. 总结：

非静态成员函数：属于对象，拥有 this 指针，可以访问类的实例成员和静态成员。
静态成员函数：属于类本身，没有 this 指针，不能访问非静态成员，只能访问静态成员。

静态成员函数的作用通常是处理一些不依赖于具体对象的操作，比如类的工厂方法、类的工具方法等。它们与类的实例无关，只与类本身的静态数据相关。

8.扩展：类的工厂方法和类的工具方法

在面向对象编程中，工厂方法（Factory Method） 和 工具方法（Utility Method） 都是常见的设计模式或编程技巧，它们的作用和使用场景各不相同。下面我将分别解释这两者的概念，并提供一些示例。

1.工厂方法

工厂方法是一种设计模式，属于创建型模式。它的主要目的是提供一个创建对象的接口，而不直接暴露对象创建的逻辑，允许子类来决定实例化哪一个类。简单来说，工厂方法就是通过调用特定的方法来创建对象，而不是直接在代码中通过 new 来实例化对象。

1. 工厂方法的特点：

封装对象的创建过程：工厂方法将对象的创建过程封装起来，客户端无需知道如何创建对象，只需要通过工厂方法来获取实例。
灵活性：工厂方法可以根据不同的输入参数或环境条件来决定实例化哪个具体类，这样可以提高程序的扩展性和灵活性。
分离了对象的创建和使用：使用工厂方法后，客户端代码只关心如何使用对象，而不需要关注对象如何创建。

2. 工厂方法的示例：

假设我们有一个 Shape 类，它有几个子类：Circle、Rectangle 和 Triangle。我们希望通过一个工厂方法来创建不同类型的 Shape 对象。

#include <iostream>
using namespace std;

// 基类：Shape
class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
};

// 圆形类
class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle" << endl;
    }
};

// 矩形类
class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing a rectangle" << endl;
    }
};

// 工厂类：ShapeFactory
class ShapeFactory {
public:
    // 工厂方法，根据输入类型返回不同的Shape对象
    static Shape* createShape(const string& shapeType) {
        if (shapeType == "circle") {
            return new Circle();
        } else if (shapeType == "rectangle") {
            return new Rectangle();
        } else {
            return nullptr;
        }
    }
};

int main() {
    // 使用工厂方法创建不同的形状对象
    Shape* shape1 = ShapeFactory::createShape("circle");
    shape1->draw();  // 输出：Drawing a circle
    
    Shape* shape2 = ShapeFactory::createShape("rectangle");
    shape2->draw();  // 输出：Drawing a rectangle

    // 释放内存
    delete shape1;
    delete shape2;
    
    return 0;
}

1.解释：

在这个示例中，ShapeFactory::createShape() 是工厂方法，它根据传入的 shapeType 字符串来决定创建哪种类型的 Shape 对象。
main 函数中，客户端代码调用工厂方法来获取对象，而不直接创建对象。这样做的好处是，如果将来我们需要添加新的形状（如 Triangle），只需要修改工厂方法而不需要修改客户端代码。

2.工具方法

工具方法（或称为辅助方法、工具类方法）通常是一些提供通用功能的方法。它们通常是静态方法，且不会依赖于类的实例。工具方法用于执行一些不依赖于对象状态的操作，比如字符串操作、数学计算、日期处理等。

1. 工具方法的特点：

静态方法：工具方法通常是静态的，这样可以不需要实例化类就直接调用。
独立性：工具方法通常是独立的，操作的是输入参数，而不依赖于类的实例状态。
通用性：工具方法通常用于一些常见的、通用的功能，适用于多种情境。

2. 工具方法的示例：

假设我们要实现一个工具类 MathUtils，提供一个静态方法来计算两个数的最大公约数（GCD）。

#include <iostream>
using namespace std;

class MathUtils {
public:
    // 计算最大公约数
    static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
};

int main() {
    int a = 56, b = 98;
    int result = MathUtils::gcd(a, b);  // 使用工具方法
    cout << "GCD of " << a << " and " << b << " is " << result << endl;  // 输出：GCD of 56 and 98 is 14
    return 0;
}

3.解释：

MathUtils::gcd() 是一个工具方法，它是一个静态方法，不依赖于 MathUtils 类的实例。我们只需通过类名调用该方法，并传入参数。
这个方法是通用的，可以用于任何两个整数的最大公约数计算。

七、总结

静态成员变量：
- 属于类本身，所有对象共享。
- 在类外定义和初始化。
- 静态成员变量只能在类内部声明，外部需要初始化。
静态成员方法：
- 通过 static 关键字声明。
- 可以通过类名或对象调用，但通常推荐通过类名调用。
- 只能访问静态成员变量和静态成员方法，不能访问实例成员。
常见应用：
- 用于实现类的计数器、全局访问控制、工具方法等功能。