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;
}
输出结果为：
代码语言：javascript复制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在类中常用的使用场景主要有：
修饰类的数据成员：即静态成员，该成员不关联到任何对象，即使不定义该类的任何对象它也存在，其生存周期大于该类的对象，其作为类的成员，由该类的所有对象共同访问。静态成员存储于全局数据区，由于要给静态成员分配空间，因此普通的静态成员不能在类的声明中定义。其定义以及使用方法如下：
代码语言：javascript复制//普通的静态成员
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;
}
输出结果如下：
代码语言：javascript复制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》
