C++避坑---关键字static的使用及注意事项

static关键字可用于声明变量、函数、类数据成员和类函数。其主要影响着它们的生命周期、作用域和存储位置。

static在普通变量和函数中的使用

• static修饰局部变量

  	默认情况下	static修饰后
  作用域	函数内部	函数内部
  存储位置	栈	静态区
  生命周期	局部（函数调用开始，函数执行完成时结束）	全局（函数调用开始，到程序执行完成时结束）

  默认情况下，局部变量（定义在函数内部的变量）的作用域仅限于函数内部，只有函数被调用的时候才被初始化（存储于栈空间）和使用，函数执行完毕的时候被释放，而被static修饰后，其作用域不变，但是存储位置变为静态区，且生命周期延长（直到程序运行结束后才被释放）。

  #include 
  
  void fun()
  {
    int a = 0;//在函数每次调用的时候都会重新初始化
    static int b = 0;//在函数第一次调用的时候只初始化一次
    a++;
    b++;
    std::cout << "a = " << a << ", b = " << b << std::endl;
  }
  int main()
  {
    int i = 5;
    while (i--)
    {
      fun();
    }
  
    return 0;
  }
  

  输出结果为：

  a = 1, b = 1
  a = 1, b = 2
  a = 1, b = 3
  a = 1, b = 4
  a = 1, b = 5
  

• static修饰全局变量

  	默认情况下	static修饰后
  作用域	整个程序	当前文件
  存储位置	静态区	静态区
  生命周期	全局	全局

  默认情况下，全局变量（在所有块的外部定义变量）的作用域是整个程序，存储位置为静态区，生命周期也与程序的生命周期相同。当其被static修饰后，其存储位置和生命周期不会改变，但其作用域变为当前文件。

  //--------a.cpp--------
  int a = 1;
  static int b = 1; //仅在该文件内部可见
  
  //------main.cpp-------
  #include 
  
  extern int a;
  // extern int b;
  
  int main()
  {
    std::cout << a << std::endl;
    // std::cout << b << std::endl; // 错误，导致程序编译报错
    return 0;
  }
  

• static修饰函数

  static修饰函数的作用与修饰全局变量的作用类似，即将函数的作用域由整个程序变为当前文件。

  //--------a.cpp--------
  #include  
   
  void fn1()
  {
    std::cout<<"this is non-static func in a.cpp."<
  
  extern void fn1(); // 使用extern声明其他文件的fn(),供main.cpp使用
  // extern void fn2();
  int main()
  {
    fn1();
    // fn2(); // 错误，编译报错
    return 0;
  }
  

static在类中的使用

在类定义中，关键字static声明不绑定到类的实例对象。static在类中常用的使用场景主要有：

• 修饰类的数据成员：即静态成员，该成员不关联到任何对象，即使不定义该类的任何对象它也存在，其生存周期大于该类的对象，其作为类的成员，由该类的所有对象共同访问。静态成员存储于全局数据区，由于要给静态成员分配空间，因此普通的静态成员不能在类的声明中定义。其定义以及使用方法如下：

  //普通的静态成员
  class X { static int n; }; // 声明（用 'static'）
  int X::n = 1;              // 定义（不用 'static'）
  
  //常量静态成员
  /*如果整型或枚举类型的静态数据成员
  被声明为 const（且非 volatile），
  那么它能以其中的每个表达式均为常量表达式
  的初始化器直接在类定义内初始化：*/
  struct X
  {
      const static int n = 1;
      const static int m{2}; // C++11 起
      const static int k;
  };
  const int X::k = 3;
  
  //inline 静态数据成员
  /*静态数据成员可以声明为 inline。 
  inline 静态数据成员可以在类定义中定义，
  而且可以指定初始化器。它不需要类外定义。*/
  struct X
  {
      inline static int n = 1; // C++17 起
  };
  

• 修饰类的成员函数：即静态成员函数，该函数与静态成员一样，不关联到任何对象。调用时，它们没有this指针。静态成员函数不能是virtual、const 或volatile 的。静态成员函数的地址可以存储在常规的函数指针中，但不能存储在成员函数指针中。其定义及使用方法如下：

  struct X {
      static void sf(){};  
      void f(){};          
      static int n;      // 声明
  };
  
  int X::n = 7;  // 定义
  
  
  X x;
  x.sf(); // 通过对象进行调用
  X::sf(); // 通过类名::函数名进行调用
  void (X::*pf)() = &X::f;
  // void (X::*psf)() = &X::sf; //错误，静态成员函数的地址不能存储在成员函数指针中。
  void (*psf)() = &X::sf;  // 静态成员函数的地址可以存储在常规的函数指针中
  (x.*pf)(); 
  (*psf)();
  

介绍完static的使用方式和方法后，我们通过一个完整的例子，总结一下其使用时的注意事项，例子如下：

#include 

using namespace std;

class A {
    public:
    A(int a) {
        a_ = a;
        s_sum_ += a;
    }

    int getSum() { return s_sum_; }
    void showA() { cout << "a = " << a_ << ", s_sum_ = " << s_sum_ << endl; }
    //static void showA() { cout << "a = " << a_ << ", sum = " << s_sum_ << endl; } //错误，静态成员函数不能访问非静态成员和非静态成员函数。
    static void showSum() { cout << "s_sum_ = " << s_sum_ << endl; }

    private:
    int a_;
    static int s_sum_;
    //static int s_sum_ = 0;  // 错误，non-const static成员不能在类的内部初始化
    /*【注：C++17起，inline 静态数据成员可以在类定义中定义
         (即inline static int s_sum_ = 0;)，
         而且可以指定初始化器。它不需要类外定义】*/
};

int A::s_sum_ = 0;  // 初始化 【非const静态成员必须在类的外面初始化】

int main() {
    A::showSum();
    cout << "sizeof(A) = " << sizeof(A) << endl;
    A a1(1);
    cout << "sizeof(a1) = " << sizeof(a1) << ", s_sum_ = " << a1.getSum() << endl;
    a1.showA();

    A a2(2);
    cout << "sizeof(a2) = " << sizeof(a2) << ", s_sum_ = " << a2.getSum() << endl;
    a2.showA();

    a1.showSum();
    a2.showSum();
    A::showSum();

    return 0;
}

输出结果如下：

s_sum_ = 0
sizeof(A) = 4
sizeof(a1) = 4, s_sum_ = 1
a = 1, s_sum_ = 1
sizeof(a2) = 4, s_sum_ = 3
a = 2, s_sum_ = 3
s_sum_ = 3
s_sum_ = 3
s_sum_ = 3

从上述例子和输出结果可以得出：

• 静态数据成员不关联到类对象，且只初始化一次，单独存储。
• 普通的静态成员不能在类的声明中定义，需要在类的外面单独初始化。
• 静态成员函数能够访问静态成员，但不能访问非静态数据成员和非静态成员函数（因为非静态数据成员和函数是与类的对象绑定的，但静态成员函数不关联任何对象，且调用时，它们没有this指针。）。

总 结

在使用关键字static的时候，我们需要注意一下几个原则：

• 被static修饰的变量的存储位置都在静态区，且生命周期延长至整个程序运行结束。
• static具有隔离作用，被static修饰的全局变量和全局函数的作用域由全局变为当前文件。
• 静态变量虽然具有全局变量的生命周期，但只能作用于自己的作用域。
• 普通静态成员需要在类的外面进行初始化。
• 静态成员函数不能调用类的非静态成员，包括非静态成员和非静态成员函数。

参考文献

《C++ reference》

文章首发公众号：iDoitnow 如果喜欢话，可以关注一下