• 当static用来修饰类成员变量时，这个变量会成为类的所有实例之间共享的全局变量，不依赖于任何类实例。因此，它不是通过类实例访问，而是通过类名直接访问。由于不占用类实例的内存，因此它存储在全局数据区。
• 当static用来修饰类成员函数时，这个函数与具体的类实例无关，只能访问类的静态成员变量和其他静态成员函数。它没有this指针，因此不能访问非静态成员。

#include <iostream>

class MyClass {
private:
    static int staticVar; // 静态成员变量
    int nonStaticVar; // 非静态成员变量

public:
    MyClass(int val) : nonStaticVar(val) {}

    static void staticFunc() { // 静态成员函数
        // 由于没有this指针，不能访问nonStaticVar
        std::cout << "Static variable value: " << staticVar << std::endl;
    }

    void nonStaticFunc() { // 非静态成员函数
        std::cout << "Non-static variable value: " << nonStaticVar << std::endl;
    }
};

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

int main() {
    MyClass obj(20);
    obj.nonStaticFunc(); // 输出非静态成员变量的值

    MyClass::staticFunc(); // 调用静态成员函数
    return 0;
}

• 当static用来修饰局部变量时，这个变量的生命周期会延长到程序运行结束，它会在静态存储区分配内存。这意味着函数调用结束后，这个变量的值会保持，直到程序结束。下次进入该函数时，这个变量会保持上次的值。

#include <iostream>

void func() {
    static int count = 0; // 局部静态变量
    count++;
    std::cout << count << std::endl;
}

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

• 当static用来修饰全局变量或函数时，这意味着这些变量或函数的链接属性是内部的（internal linkage），它们只在定义它们的文件中可见，其他文件不能通过extern声明来引用它们。这样可以避免在其他文件中意外重定义同名变量或函数。

// file1.cpp
static int globalVar = 10; // 文件作用域的静态全局变量

static void globalFunc() { // 文件作用域的静态函数
    std::cout << "This is a static global function." << std::endl;
}

// file2.cpp
#include <iostream>

extern int globalVar; // 尝试声明file1.cpp中的静态全局变量
extern void globalFunc(); // 尝试声明file1.cpp中的静态函数

int main() {
    globalFunc();
    std::cout << globalVar << std::endl;
    return 0;
}
//这样子file2.cpp会发生报错

• 在静态存储时期，未被显式初始化的static变量会被默认初始化为0。这包括全局静态变量、局部静态变量和类的静态成员变量。

#include <iostream>

int a;

int main()
{

    char str[10];

    std::cout << a << std::endl;
    std::cout << str << std::endl;

}

//输出
//0
//烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫?(Q?