static关键字可用于声明变量、函数、类数据成员和类函数。其主要影响着它们的生命周期、作用域和存储位置。
static在普通变量和函数中的使用
-
static修饰局部变量
默认情况下 static修饰后 作用域 函数内部 函数内部 存储位置 栈 静态区 生命周期 局部（函数调用开始，函数执行完成时结束） 全局（函数调用开始，到程序执行完成时结束） 默认情况下，局部变量（定义在函数内部的变量）的作用域仅限于函数内部，只有函数被调用的时候才被初始化（存储于栈空间）和使用，函数执行完毕的时候被释放，而被
static修饰后，其作用域不变，但是存储位置变为静态区，且生命周期延长（直到程序运行结束后才被释放）。#include <iostream> 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 <iostream> 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 <iostream> void fn1() { std::cout<<"this is non-static func in a.cpp."<<std::endl; } static void fn2() { std::cout<<"this is static func in a.cpp."<<std::endl; } //------main.cpp------- #include <iostream> 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 <iostream>
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 如果喜欢话，可以关注一下
