第七章---C++ static 关键字、static 函数与普通函数的区别

在C++中，static关键字有多种用途，它可以用于变量、函数、类成员和类本身。

1.static 关键字

1. 静态变量

• 局部静态变量
  定义：在函数内部定义的静态变量。
  特性：
  • 只在第一次调用函数时初始化，之后每次调用函数时不会重新初始化。
  • 在程序的生命周期内，局部静态变量的值会一直保持，直到程序结束。
  • 局部静态变量的作用域仍然局限于定义它的函数内部，但它的生命周期是程序级别的。

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

• 全局静态变量
  定义：在所有函数外部定义的静态变量。
  特性：
  • 在程序的生命周期内，全局静态变量的值会一直保持。
  • 全局静态变量的作用域仅限于定义它的文件内部，不能在其他文件中使用extern关键字来引用。

  static int global_count = 0; // 全局静态变量
  

2. 静态函数

定义：在类内部定义的静态成员函数。
特性：

• 静态成员函数不依赖于类的对象，可以直接通过类名调用。
• 静态成员函数不能访问非静态成员变量或成员函数，因为它没有this指针。

class MyClass {
public:
    static void staticFunc() {
        // 静态成员函数
    }
};
MyClass::staticFunc(); // 通过类名调用

3. 静态成员变量

定义：在类内部定义的静态成员变量。
特性：

• 静态成员变量是所有对象共享的，不属于任何一个对象。
• 静态成员变量必须在类外部进行定义和初始化。
• 可以通过类名和作用域解析运算符来访问静态成员变量。

class MyClass {
public:
    static int staticVar; // 静态成员变量声明
};
int MyClass::staticVar = 0; // 静态成员变量定义和初始化
MyClass::staticVar = 10; // 通过类名访问静态成员变量

4. 静态成员函数的访问权限

静态成员函数可以具有不同的访问权限，就像类的其他成员一样。这包括public、protected和private：

• public：可以被类的外部访问。
• protected：可以被类本身、子类以及友元函数或类访问。
• private：只能被类本身访问，不能被外部访问，也不能通过对象访问。

class MyClass {
public:
    static void publicStaticFunc() {
        // 可以被外部访问的静态成员函数
    }
protected:
    static void protectedStaticFunc() {
        // 受保护的静态成员函数
    }
private:
    static void privateStaticFunc() {
        // 私有的静态成员函数
    }
};

5. 静态成员的初始化

静态成员变量必须在类的外部定义和初始化，通常在包含类的头文件的实现文件中进行。初始化时，不需要使用static关键字：

// MyClass.h
class MyClass {
public:
    static const int STATIC_VAR;
};
// MyClass.cpp
#include "MyClass.h"
const int MyClass::STATIC_VAR = 10;

6. 静态成员的线程安全性

由于静态成员变量是所有类的实例共享的，因此在多线程环境中访问和修改静态成员时需要特别小心。通常需要使用同步机制（如互斥锁）来确保线程安全：

#include <mutex>
class MyClass {
public:
    static int sharedValue;
    static std::mutex mutex;
    static void setValue(int value) {
        std::lock_guard<std::mutex> lock(mutex);
        sharedValue = value;
    }
};
int MyClass::sharedValue = 0;
std::mutex MyClass::mutex;

7. 静态局部变量的线程局部存储

在某些情况下，你可能希望每个线程都有自己的静态局部变量的副本。C++11引入了thread_local关键字，它可以将静态局部变量存储在线程局部存储（TLS）中：

void func() {
    thread_local static int threadLocalVar = 0; // 线程局部存储的静态变量
    threadLocalVar++;
    std::cout << threadLocalVar << std::endl;
}

8. 静态成员的析构函数

静态成员变量通常不需要析构函数，因为它们不是通过new分配的。但是，如果静态成员变量需要释放资源，可以提供一个静态成员函数来手动释放这些资源。

class MyClass {
public:
    static void cleanup() {
        // 清理静态成员变量的资源
    }
};
// 在程序结束时调用
MyClass::cleanup();

9. 静态成员的继承

静态成员可以被继承，但它们不是实例化的对象的一部分，而是类的一部分。这意味着，如果基类有一个静态成员，派生类也会继承这个静态成员。但是，静态成员的行为不会因为继承而改变，它们仍然属于基类。

class Base {
public:
    static int baseStaticVar;
};
class Derived : public Base {
    // 继承了baseStaticVar
};
int Base::baseStaticVar = 1;
Derived::baseStaticVar = 2; // 修改基类的静态成员变量

2.static 函数与普通函数的区别

在C或C++中，static函数与普通函数有几个关键的区别：

1. 作用域（Scope）

• 静态函数：
  • 在C中，静态函数的作用域仅限于其定义所在的文件。这意味着静态函数在文件外部是不可见的，它不能被其他文件中的函数调用。
  • 在C++中，类内部的静态成员函数的作用域是类的所有实例共享的，但它们不能访问非静态成员变量或非静态成员函数。
• 普通函数：
  • 普通函数（非静态）具有外部链接（external linkage），它们可以在定义它们的文件之外被其他文件中的函数调用。

2. 访问权限

• 静态函数：
  • 在类内部，静态成员函数可以通过类名直接调用，无需创建类的实例。
  • 静态成员函数可以访问类内的静态成员变量和静态成员函数，但不能直接访问非静态成员。
• 普通函数：
  • 普通成员函数必须通过类的实例来调用。
  • 普通成员函数可以访问类的所有成员，包括静态和非静态成员。

3. 存储和生命周期

• 静态函数：
  • 在C中，静态函数存储在程序的静态存储区，它们在程序开始执行时被分配，在程序结束时释放。
  • 在C++中，类内部的静态成员函数不依赖于类的实例，它们在程序的生命周期内只存在一份副本。
• 普通函数：
  • 普通成员函数的代码是共享的，不是为每个实例分配的。

示例
以下是一个简单的示例，展示了C++中静态成员函数和普通成员函数的区别：

class MyClass {
public:
    static void staticFunc() {
        // 静态成员函数
        std::cout << "Static function called." << std::endl;
    }
    void normalFunc() {
        // 普通成员函数
        std::cout << "Normal function called." << std::endl;
    }
};
int main() {
    MyClass::staticFunc(); // 调用静态成员函数，无需实例化对象
    MyClass obj;
    obj.normalFunc(); // 调用普通成员函数，需要通过实例化对象
    return 0;
}

总结

静态函数与普通函数的主要区别在于它们的作用域、访问权限、存储和生命周期以及调用方式。正确选择使用静态函数还是普通函数取决于具体的应用场景和设计需求。