静态类成员函数

dairao123

已于 2024-08-22 00:52:52 修改

阅读量461

点赞数 3

文章标签： c++

于 2024-08-21 22:43:24 首次发布

本文链接：https://blog.csdn.net/dairao123/article/details/141403860

版权

一、静态类成员函数的概述

在C++中，类成员分为两种：普通成员和静态成员。静态成员（包括静态成员变量和静态成员函数）属于整个类，而不是某个特定的对象。这意味着静态成员不依赖于类的实例化对象，而是直接和类本身关联。

二、静态成员函数的常规用法

1. 声明和定义

静态成员函数的声明与普通成员函数相似，只是在前面加上static关键字。

class Example {
public:
    static void staticFunction(); // 静态成员函数声明

};

// 静态成员函数定义
void Example::staticFunction() {
    std::cout << "This is a static member function." << std::endl;
}

2. 调用方式

静态成员函数可以通过类名直接调用，而不需要实例化对象。

class Example {
public:
    static void staticFunction(); // 静态成员函数声明
};


int main()
{
    Example::staticFunction();  // 通过类名调用
    Example obj;
    obj.staticFunction();  // 通过对象调用（不推荐：掩盖了静态成员函数与对象无关的本质）

}

3. 访问静态成员变量

class Example {
public:
    static int staticVar;
    static void staticFunction() {
        std::cout << "Static variable: " << staticVar << std::endl;
    }
};

// 静态成员变量的定义和初始化
int Example::staticVar = 42;

int main()
{

    Example::staticFunction();  // 输出：Static variable: 42
 
    Example::staticVar = 100;
    Example::staticFunction();  // 输出：Static variable: 100

}

三、静态成员函数需要注意的点

1、无法访问非静态成员：静态成员函数由于没有this指针，因此无法直接访问类的非静态成员变量和非静态成员函数。如果需要访问这些非静态成员，通常要通过对象的引用或指针来访问。

#include <iostream>

class Example {
private:
    int nonStaticVar;  // 非静态成员变量

public:
    // setter函数来设置nonStaticVar的值
    void setNonStaticVar(int value) {
        nonStaticVar = value;
    }

    // 通过对象引用访问非静态成员变量
    static void staticFunction(Example& obj) {
        std::cout << "Non-static variable: " << obj.nonStaticVar << std::endl;
    }
};

int main() {
    Example ex1;   
    ex1.setNonStaticVar(100);

    // 通过静态成员函数访问非静态成员变量
    Example::staticFunction(ex1);  // 输出：Non-static variable: 100

    return 0;
}

静态成员函数 staticFunction 通过传入的对象引用，访问了这个对象的非静态成员变量，并输出了之前设置的值 100。

2、不支持虚函数和多态

虚函数依赖于对象的动态类型和 this 指针，用于实现运行时的多态行为。而静态成员函数与类本身相关，没有 this 指针，也不与任何对象关联。因此，静态成员函数不能被声明为虚函数，也无法参与虚函数机制和多态性。

3、与类的生命周期无关：静态成员函数与类的生命周期无关，即便类没有任何对象存在，静态成员函数依然可以被调用。

4、应用场景：

单例模式：核心思想是一个类在整个程序运行期间只有一个实例。静态成员函数的主要作用是负责创建并管理类的唯一实例，并提供一个全局的访问点来获取该实例。

#include <iostream>
#include <string>

class Logger {
public:
    // 静态成员函数，用于获取唯一实例
    static Logger* getInstance() {
        static Logger instance;  // 静态局部变量，只会初始化一次，保证线程安全
        return &instance;  // 返回指向这个单例对象的指针
    }

private:
    Logger() {}  // 私有构造函数，防止外部创建实例

    // 禁止拷贝构造和赋值操作
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

};


int main() {
    Logger* logger1 = Logger::getInstance();  
    Logger* logger2 = Logger::getInstance();  

    // 验证两个指针是否指向同一个实例
    bool result = (logger1 == logger2);  
    std::cout << std::boolalpha << result << std::endl;  // 输出：true


    return 0;
}

四、总结