使用C++静态变量实现数据共享

一、静态变量的基本概念

静态变量在C++中一般被用来表示类变量或者全局变量，不同于动态变量，静态变量的内存空间只在程序运行期间被初始化一次，而不是每次执行到它所在的函数时都会重新分配一块内存。因此，静态变量可以用来共享数据。

静态变量有两种声明方式：在函数中声明和在类中声明。在函数中声明的静态变量可以用来保存在函数调用之间需要持久存储的数据，比如一个计数器。在类中声明的静态变量则可以被所有的实例对象所共享。

#include <iostream>
using namespace std;

void func() {
  static int counter = 0;
  counter++;
  cout << "函数被执行了 " << counter << " 次" << endl;
}

int main() {
  for(int i=0; i<5; i++) {
    func();
  }
  return 0;
}

以上代码演示了在函数中使用静态变量实现计数器的效果：

函数被执行了 1 次
函数被执行了 2 次
函数被执行了 3 次
函数被执行了 4 次
函数被执行了 5 次

二、静态变量的生命周期

静态变量在程序运行期间一直存在，直到程序退出才会被销毁。

当在函数中声明一个静态变量时，该静态变量的声明周期与程序的生命周期相同，但是作用域只在函数内部。对于在类中声明的静态变量，它的生命周期与类的生命周期相同，但是作用域是全局的，可以被所有实例对象所调用。

#include <iostream>
using namespace std;

class MyClass {
   public:
      static int counter;

      void func() {
          counter++;
      }
};

int MyClass::counter = 0; // 静态变量初始化

int main() {
    Myclass obj1;
    Myclass obj2;
    obj1.func();
    obj2.func();
    cout << "obj1调用函数 " << obj1.counter << " 次" << endl;
    cout << "obj2调用函数 " << obj2.counter << " 次" << endl;
    return 0;
}

以上代码演示了在类中使用静态变量实现数据共享的效果：

obj1调用函数 2 次
obj2调用函数 2 次

三、静态变量的线程安全

多线程环境下使用静态变量时，需要注意静态变量的线程安全性。如果多个线程同时访问同一个静态变量，有可能会引发线程安全问题。为了解决这个问题，可以使用互斥锁（mutex）来控制静态变量的访问。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

static mutex mtx;
static int sharedData = 0;

void func() {
    for (int i = 0; i < 1000000; i++) {
        mtx.lock();
        sharedData++;
        mtx.unlock();
    }
}

int main() {
    thread t1(func);
    thread t2(func);
    t1.join();
    t2.join();
    cout << "sharedData = " << sharedData << endl;
    return 0;
}

以上代码演示了在多线程环境下使用静态变量实现数据共享的效果。为了保证sharedData的线程安全性，使用了互斥锁。

sharedData = 2000000

四、静态变量的使用注意事项

使用静态变量时，需要注意以下几点：

1、尽量避免在函数中定义静态变量。在多线程环境下，会导致静态变量的线程安全性难以保证。

2、静态变量的初始化需要在第一次使用之前进行。如果忘记初始化，会导致程序运行出错。

3、静态变量会一直存在于程序的内存中，因此需要合理使用静态变量，避免造成内存浪费。