c/c++ static - 悦读

定义

修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main
函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为
static。
修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。

作用

静态成员变量

静态成员变量是属于类本身的变量，而不是某个具体对象的变量。它只在类中有一份内存拷贝，所有类的对象共享这份内存。

静态成员变量存储在静态存储区，而不是对象的内存中。
所有对象共享一个静态成员变量的拷贝，无论创建多少个对象。
静态成员变量在类外进行定义和初始化，且不能在类内初始化（C++17 之后可以使用 inline 初始化）。
静态成员变量在程序开始时分配内存，直到程序结束才释放。它的生命周期贯穿整个程序运行期间。
可以通过类名直接访问，也可以通过对象访问（推荐使用类名访问以强调静态成员的性质）

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

    // 静态成员函数
    static void Increment() {
        counter++;
    }

    // 获取静态变量值
    static int GetCounter() {
        return counter;
    }
};
使用：
  // 通过类名访问
    MyClass::Increment(); 
     // 输出：Counter: 1
    cout << "Counter: " << MyClass::GetCounter() << endl;

    // 通过对象访问（不推荐）
    MyClass obj1;
    obj1.Increment();
    // 输出：Counter: 2
    cout << "Counter: " << MyClass::GetCounter() << endl; 

    MyClass obj2;
    obj2.Increment();
    // 输出：Counter: 3
    cout << "Counter: " << MyClass::GetCounter() << endl;

静态成员函数
在 C++ 中，静态成员函数（static member function）是属于类本身而不是某个具体对象的成员函数。它使用 static 关键字进行声明，可以在没有创建类的实例时通过类名直接调用。

class MyClass
{
public:
    // 使用关键字 static 声明静态成员函数
    static void print();
};

// 在类外定义静态成员函数时，不需要再次使用 static 关键字：
void MyClass::print() {
    std::cout << "This is a static member function." << std::endl;
}

调用:静态成员函数可以通过类名或对象调用，但推荐通过类名调用

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

静态全局变量
使用 static 修饰的全局变量，只可以使其在声明所在的文件内可见，这样可以避免与其他文件中相同名称的变量产生冲突

static int globalCount;

静态普通函数
需要 static 修饰的函数成为静态函数，这种函数只能在声明所在的文件内部调用，无法被其他文件直接调用，这对一些辅助函数或者实用函数，限制在特定的文件范围内非常有用

static int add(const int& a,const int & b)
{
    return a + b;
}

静态局部变量
在一个函数内部使用 static 的变量，称为局部静态变量，与普通的局部变量不同，局部静态变量在函数调用结束后不会被销毁而是保持其值与存在。
如果你想重复使用一个变量由不想将它声明为全局变量，就可以将它声明为静态局部变量

int getCount()
{
    static int count = 0;
    count++;
    return count;
}

逆向 C++ static

class MyClass {

public:
    MyClass()
    {
        number = 0x111111;
        counter = 0x222222;
    }

public:

    static int counter;
    int number;

    void printNumber()
    {
        std::cout << number << std::endl;
    }

    static void printCounter()
    {
        std::cout << counter << std::endl;
    }    
}

调用：

MyClass obj;
进入构造函数：
00007FF6A94610B3     | 48:8D4C24 20             | lea rcx,qword ptr ss:[rsp+20]   
;public: __cdecl MyClass::MyClass(void)                   
00007FF6A94610B8     | E8 43FFFFFF              |call 0x00007FF6A9461000 

构造函数中看 静态成员变量 counter  和 成员变量 number 

00007FF6A9461000 <te | 48:894C24 08             | mov qword ptr ss:[rsp+8],rcx                  
00007FF6A9461005     | 48:8B4424 08             | mov rax,qword ptr ss:[rsp+8]     
; 成员变量number 赋值   
00007FF6A946100A     | C700 11111100            | mov dword ptr ds:[rax],111111 
; static int MyClass::counter 静态成员变量赋值:
00007FF6A9461010     | C705 1A360000 22222200   | mov dword ptr ds:[0x00007FF6A9464634], 0x222222
00007FF6A946101A     | 48:8B4424 08             | mov rax,qword ptr ss:[rsp+8] 
00007FF6A946101F     | C3                       | ret                                                               

成员函数调用：
obj.printNumber();
00007FF6A94610BD     | 48:8D4C24 20             | lea rcx,qword ptr ss:[rsp+20]  
; void __cdecl MyClass::printNumber(void)                                   
00007FF6A94610C2     | E8 59FFFFFF              | call 0x00007FF6A9461020

 --------------------  printNumber -------------------- 
00007FF6A9461020 <te | 48:894C24 08             | mov qword ptr ss:[rsp+8],rcx              
00007FF6A9461025     | 48:83EC 28               | sub rsp,28 
00007FF6A9461029     | 48:8B4424 30             | mov rax,qword ptr ss:[rsp+30]  
; edx = number = 0x11111
00007FF6A946102E     | 8B10                     | mov edx,dword ptr ds:[rax] 
; 下面是调用 std::cout 打印输出
00007FF6A9461030     | 48:8B0D 69100000         | mov rcx, qword ptr ds:[0x00007FF6A94620A0]
00007FF6A9461037     | FF15 6B100000            | call qword ptr ds:[0x00007FF6A94620A8]
00007FF6A946103D     | 48:8D15 9C000000         | lea rdx, ds:[0x00007FF6A94610E0]
00007FF6A9461044     | 48:8BC8                  | mov rcx,rax  
00007FF6A9461047     | FF15 33100000            | call qword ptr ds:[0x00007FF6A9462080]
00007FF6A946104D     | 48:83C4 28               | add rsp,28
00007FF6A9461051     | C3                       | ret 

静态成员函数调用:
 obj.printCounter();
 call 0x00007FF6A9461060
 --------------------  printCounter  -------------------- 
00007FF6A9461060 <te | 48:83EC 28               | sub rsp,28 
; 静态成员变量 edx = 0x222222
00007FF6A9461064     | 8B15 CA350000            | mov edx, dword ptr ds:[0x00007FF6A9464634]
; std::cout 输出 
00007FF6A946106A     | 48:8B0D 2F100000         | mov rcx, qword ptr ds:[0x00007FF6A94620A0]
00007FF6A9461071     | FF15 31100000            | call qword ptr ds:[0x00007FF6A94620A8]
00007FF6A9461077     | 48:8D15 62000000         | lea rdx, ds:[0x00007FF6A94610E0]
00007FF6A946107E     | 48:8BC8                  | mov rcx,rax 
00007FF6A9461081     | FF15 F90F0000            | call qword ptr ds:[0x00007FF6A9462080]
00007FF6A9461087     | 48:83C4 28               | add rsp,28  
00007FF6A946108B     | C3                       | ret