c++ 静态特性（static）

在之前的文章中有写过C++的动态特性，静态特性也是C++中是一种重要的概念，可以用于实现各种功能和设计模式。

下面我会详细解释静态变量和静态函数，并提供代码示例。

静态变量（Static Variables）：

静态变量在程序的整个生命周期内存在，并且只会被初始化一次。它们可以在函数内部或类内部声明，使用关键字static进行标记。

在函数内部的静态变量：

#include <iostream>

void increment() {
    static int count = 0; // 静态变量，在函数调用结束后不会被销毁，程序结束后销毁
    count++;
    std::cout << "Count: " << count << std::endl;
}

int main() {
    increment(); // 输出 Count: 1
    increment(); // 输出 Count: 2
    return 0;
}

在类内部的静态变量：

#include <iostream>

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

int MyClass::staticVar = 0; // 定义并初始化静态变量

int main() {
    MyClass obj1;
    MyClass obj2;
    obj1.staticVar = 10;
    std::cout << obj2.staticVar << std::endl; // 输出 10，因为静态变量被所有对象共享
    return 0;
}

注意：
类中声明的静态成员变量，在初始化此变量时，需要用 类名::变量名 的方式进行初始化，且该变量是被所有对象共享的。如上面代码示例，一个对象中改变了此值，另一个对象在获取时，也是同样的结果。

静态函数（Static Functions）：

静态函数属于类本身，而不是类的实例。它们可以直接通过类名调用，而无需创建类的对象实例。 静态函数不能访问类的非静态成员变量，也不能使用this指针。

#include <iostream>

class MyClass {
public:
    static void staticFunc() {
        std::cout << "Static function" << std::endl;
    }
};

int main() {
    MyClass::staticFunc(); // 直接通过类名调用静态函数
    return 0;
}

注意： 静态函数和非静态函数有一些关键区别，其中之一是它们如何与类的实例进行交互。

1.静态函数不依赖于类的实例：
静态函数是属于整个类的，而不是属于类的实例的。因此，静态函数无法访问任何特定实例的非静态成员变量，因为它们在没有实例的情况下也可以被调用。

2.this指针：
在C++中，this指针是一个指向调用成员函数的对象的指针。在非静态成员函数中，this指针被隐式传递，它指向调用该成员函数的对象。但是，由于静态函数不依赖于任何特定的实例，因此它们无法访问this指针，因为没有实例可以指定。

因此，由于静态函数不与特定的对象实例相关联，它们无法访问非静态成员变量或使用this指针。

静态变量和静态函数的使用

静态变量和静态函数在C++中的应用非常广泛，它们可以用于实现单例模式、全局变量、类成员的计数等功能。

1.全局变量（Global Variables）：

静态变量可用于实现全局变量的效果。

#include <iostream>

class Global {
public:
    static int count;
};

int Global::count = 0; // 静态成员变量初始化

int main() {
    Global::count++;
    std::cout << "Global count: " << Global::count << std::endl; // 输出 Global count: 1
    return 0;
}

2. 类成员的计数（Counting Class Members）：

静态变量可用于跟踪类实例的数量（当前类创建了多少个对象）。

#include <iostream>

class Counter {
private:
    static int count;

public:
    Counter() {
        count++;
    }

    static int getCount() {
        return count;
    }
};

int Counter::count = 0; // 静态成员变量初始化

int main() {
    Counter obj1;
    Counter obj2;
    Counter obj3;

    std::cout << "Number of objects: " << Counter::getCount() << std::endl; // 输出 Number of objects: 3

    return 0;
}

3.单例模式（Singleton Pattern）：

单例模式确保一个类只有一个实例，并提供全局访问点。

#include <iostream>

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数，防止外部实例化

public:
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }

    void showMessage() {
        std::cout << "Hello from Singleton!" << std::endl;
    }
};

Singleton* Singleton::instance = nullptr; // 静态成员变量初始化

int main() {
    Singleton* obj1 = Singleton::getInstance();
    obj1->showMessage();

    Singleton* obj2 = Singleton::getInstance();
    obj2->showMessage();

    return 0;
}

以上就是 静态变量和静态函数在C++中常常会使用到的点，熟悉以上知识点，静态特性就了解的差不多了。