C/C++ static修饰变量时的作用

废话不多说，直接一步到位来说明吧。

作用

变量前加上static有 两个 作用：
1、使当前变量的作用域变为当前变量所定义的作用域
2、使当前变量本质上变成全局变量

使当前变量的作用域变为当前变量所定义的作用域

1、修饰全局变量时

话不多说，show the code
直接举栗子，看下面代码

#include <iostream>
using namespace std;
//这是一个全局变量。加上static后会让变量a的作用域限制于main.cpp里
static int a = 10;

int main(int argc, const char * argv[]) {
	return 0;
}

从上面代码知道，这里定义了一个全局变量a。加上static后会让变量a的作用域限制于main.cpp里。可能有些小伙伴会觉得很纳闷了，这个全局变量a的作用域不就是在main.cpp里吗？其实呢并不是这样的，众所周知，在C/C++里，我们可以直接在其他的文件里通过以下这样的操作就访问main.cpp里的全局变量a
我们先在test.cpp里定义并初始化一个全局变量testA:

//test.cpp
#include "test.h"

int testA = 22;

void test()
{
}

之后，我们甚至都可以不在main.cpp里**#include “test.h”**文件，都可以直接在main.cpp里使用test.cpp里的testA变量，也就是使用extern，代码如下：

//main.cpp
#include <iostream>
using namespace std;
extern int testA;

int main(int argc, const char * argv[]) {
  cout << "testA = " << testA << endl;
  return 0;
}

打印结果如下图

但是，当你在testA变量前加上static的话，就能让testA变量的作用域被限制在test.cpp内，也就是说，外部再通过extern int testA 的方式就无法testA进行访问了，在编译过程中就会直接报错
代码如下：

//test.cpp
#include "test.h"

static int testA = 22;

void test()
{
}

报错截图如下：

我这里用的是Xcode，他底层会自动将全局变量名加上下划线，所以这里看到的就是_testA

2、修饰局部变量时

那么如果static本身修饰的就是局部变量呢？
如下代码：

//test.cpp
#include "test.h"

void test()
{
  static int a = 10;
}

其实对于这条规则仍然适用，仍然会将局部变量a的作用域变为当前定义的作用域，但是由于当前a定义的作用域就是在test函数里，因此改变之后和改变之前是一样的（就相当于没有改变）

使当前变量本质上变成全局变量

1、修饰局部变量时

如下代码：

//main.cpp
#include <iostream>
using namespace std;

int globalA = 10;

int main(int argc, const char * argv[]) {
  int a = 20;
  cout << "globalA的地址 = " << & globalA << endl;
  cout << "a的地址 = " << & a << endl;
  return 0;
}

上面代码，我们定义了一个全局变量globalA = 10和一个局部变量a = 20。并且对其相应的地址进行了打印
打印结果如下图：

可以看到：globalA和a的地址值是相差非常大的，因为他们一个是在全局区，一个是在栈区
我们现在将局部变量a加上static进行修饰，看看结果如何，代码如下：

//main.cpp
#include <iostream>
using namespace std;

int globalA = 10;

int main(int argc, const char * argv[]) {
  static int a = 20;
  cout << "globalA的地址 = " << & globalA << endl;
  cout << "a的地址 = " << & a << endl;
  return 0;
}

打印截图如下：

从上图可以看出：加上static修饰后的局部变量a的地址值就跟全局变量globalA的地址值相差4个字节，也就是说，a是紧挨着globalA存储的
不信可以接着查看他们在内存空间上是不是这样的，截图如下：

从上图红框里，明显能够看出，16进制的0A就是十进制的10，也就是globalA，16进制的14也就是十进制的20，也就是a。明显能看出来：他们是紧紧挨在一起存储的，也就是都存储在了全局区

从这里终于也能知道一个东西的原因了，那就是为啥被static修饰的局部变量的值可以被重复的访问和修改

常见的代码栗子如下：

//main.cpp
#include <iostream>
using namespace std;

void test() {
    static int a = 0;
    cout << "a = " << a++ << endl;
}

int main(int argc, const char * argv[]) {
    for (int i = 0; i < 20; i++) {
        test();
    }
    return 0;
}

打印结果如下:

2、修饰全局变量时

如果static本身是修饰全局变量呢
如下代码：

//main.cpp
#include <iostream>
using namespace std;

int globalA = 10;
int globalB = 20;

int main(int argc, const char * argv[]) {
  cout << "globalA的地址 = " << & globalA << endl;
  cout << "globalB的地址 = " << & globalB << endl;
  return 0;
}

这里是定一个了两个全局变量，并且还未对任何一个全局变量用static进行修饰，打印如下：

打印结果很正常，因为两个都是全局变量，因此就是紧紧挨在一起存储的。
现在对globalB用static进行修饰，代码如下：

//main.cpp
#include <iostream>
using namespace std;

int globalA = 10;
static int globalB = 20;

int main(int argc, const char * argv[]) {
  cout << "globalA的地址 = " << & globalA << endl;
  cout << "globalB的地址 = " << & globalB << endl;
  return 0;
}

打印结果如下：

可以看到，打印结果还是和刚才一毛一样。

其实对于这条规则仍然适用，仍然会将全局变量的本质变为全局变量，但是由于当前定义的就是一个全局变量，因此改变之后和改变之前是一样的（就相当于没有改变）

总结

1、使当前变量的作用域变为当前变量所定义的作用域

2、使当前变量本质上变成全局变量

static无论修饰的是局部变量还是全局变量，只要套用这两句话，结果都是对的