static && extern-静态变量解析

C语言静态变量和普通变量

1. 思维导图

静态变量和普通变量又可以分为全局的和局部的，所以在了解静态变量和普通变量的时候，我们需要简单了解一下C语言作用域

2. C语言作用域

2.1 代码块作用域

• 代码块作用域就是大括号"{ }"之间的一段代码

#include<stdio.h>
int main()
{
   {
       int a = 10;//在一个大括号里面定义了变量a,
       //变量的生命周期就在定义的" { "  到 " } " 内
       printf("大括号内的a = %d\n", a);//正确
   }
   printf("大括号外的 a = %d\n", a);//代码会报错，因为在上一个大括号结束的时候
   //变量 a 生命周期已经结束，此时报错会显示未定义 a
   return 0;
}

• 大括号内部的代码可以访问大括号外部的数据，反之不行

#include<stdio.h>
int main()
{
   int a = 10;
   {
       printf("大括号内部的 a = %d\n", a);//正确
   }
   printf("大括号外部的 a = %d\n", a);//正确
   return 0;
}

• 大括号外部和大括号内部的定义了同一个变量名的情况

#include<stdio.h>
int main()
{
   int a = 10;
   {
       int a = 20;
       printf("大括号内部的 a = %d\n", a);//正确
   }
   printf("大括号外部的 a = %d\n", a);//正确
   return 0;
}

程序数据结果为下：

大括号内部的 a = 20
大括号外部的 a = 10

这段程序我们可以这样理解，在学校里面有两个叫做张三的人，一个在你们的班级，一个在另外的班级，如果你们在班级里面提到的张三这个名字，大家会默认是距离自己最近的张三，而不是其他班级的张三（就近原则）。

2.2 函数作用域

• 在一个函数内部定义的数据，只能够在自己的函数中访问

#include<stdio.h>
void test1()
{
   int a = 10;
   printf("test1中的a = %d",a);
}
void test2()
{
   printf("test2中的a = %d",a);//错误, a 未定义
}
int main()
{
   test1();
   test2();
   return 0;
}

2.3 文件作用域

在集成开发环境中，我们创建一个C语言项目的时候，同一个项目中我们可能会创建多个 .cpp文件，每个 .cpp文件就算一个文件作用域，在下文会有具体的示例：

3. 普通变量

3.1 局部变量

特点：

• 在" { } "内定义
• 生命周期从定义开始，到最近的一个" } "，当大括号结束后，变量就会被释放
• 局部变量如果没有初始化，值是随机的，也就是乱码，使用未初始化的变量可能会导致程序运行结果错误或者崩溃

3.2 全局变量

• 定义在函数外面的变量
• 作用范围：作用范围很广，在整个程序中都可以使用，需要使用其他文件的全局变量，需要加extern关键字修饰
• 生命周期：需要在程序结束之后才能释放
• 注意事项：如果全局变量未初始化，数值型系统自动初始化为 0 ，字符型自动初始化为空字符串

• 普通访问方式

#include<stdio.h>
int a = 10;//全局变量
void test1()
{
   printf("test1函数中的 a = %d",a);
}
int main()
{
   test1();
   printf("main函数中的 a = %d",a);
   return 0;
}

程序运行结果为：

test1函数中的 a = 10
main函数中的 a = 10

可以看出，虽然在两个函数中我们都没有定义 a，但是两个函数都能成功的访问全局变量 a

• 其他文件访问方式

在vs2019或者其他集成开发环境中，我们新建一个控制台应用，在一个项目下可以新建多个.cpp文件，我们仍然可以访问在其他.cpp文件中定义的全局变量。

在test.cpp中定义一个全局变量test_a:

在静态变量和普通变量.cpp中调用在test.cpp定义的test_a：

这里有一个常见的错误，如果你骗编译器（你extern了一个其他文件不存在的变量），那么就会有一个叫做“无法解析的外部命令”的错误，有过C基础的人应该知道代码在变成可执行程序的时候，中间有四个步骤，预处理，编译，汇编，链接，当编译器在链接阶段时无法找到你 extern 的那个变量，那么编译错误

小知识：在定义全局变量的时候，编译器会默认加一个extern 关键字；

4. 静态变量

4.1 静态局部变量

特点：

• 定义：在"{ }“中定义，在普通的定义方式前加上关键字static，作用域也同样是在定义的”{ }"内有效
• 生命周期：整个程序结束后释放
• 注意事项：静态局部变量没有初始化，系统自动赋值为 0；字符类型就自动赋值为空字符串
• 注意事项：静态局部变量只能够初始化一次

接下来会涉及到一点很简单的指针的内容，这是一篇指针基础文章链接：指针基础 有兴趣可以看看

#include<stdio.h>
int* test1()
{
   int a = 10;//定义了局部变量
   printf("%d",&a);
   return &a;//返回了这个局部变量的地址
}
int main()
{
   int* p = test1();//利用一个指针接收这个地址
   /*以下操作为打印指针p指向的内存空间中的数字*/
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   return 0;
}

程序运行结果如下：

指针p指向的数字为：10
指针p指向的数字为：10164674
指针p指向的数字为：10164674
指针p指向的数字为：10164674
指针p指向的数字为：10164674

可以看出来，局部变量 a 所在的地址在函数 test1()结束之后，a 所在的内存立即被回收，a的值10已经消失，但是第一个打印能打印出来10，这个是因为编译器会保留一次 a 的值，调用了一次之后就不会再保存这值了，所以在设计程序的时候，我们不要返回普通局部变量的地址,如果一定要返回，请用拷贝的方式接收。

当我们把普通局部变量改成静态局部变量的时候

#include<stdio.h>
int* test1()
{
   static int a = 10;//定义了静态局部变量
   printf("%d",&a);
   return &a;//返回了这个静态局部变量的地址
}
int main()
{
   int* p = test1();//利用一个指针接收这个地址
   /*以下操作为打印指针p指向的内存中的数字*/
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   printf("指针p指向的数字为：%d\n", *p);
   return 0;
}

程序运行结果如下：

指针p指向的数字为：10
指针p指向的数字为：10
指针p指向的数字为：10
指针p指向的数字为：10
指针p指向的数字为：10

发现打印出的数字全部为10，这个是因为在函数结束以后，静态局部变量所在的那块内存空间并不会被编译器清空，而是会以特殊的手段保留那块内存空间，当我们使用指针间接访问这块内存的时候，这个时候静态的局部变量不会消失成为乱码，而是会被打印出来。

为了更加直观的感受到静态局部变量只能初始化一次的效果，设计程序如下：

#include<stdio.h>
void test01()
{
   int a = 10;//定义了一个局部变量
   a++;
   printf("a = %d\n", a);
}
int main()
{
   for (int i = 0; i < 5; i++)
   {
       test01();
   }
   return 0;
}

程序运行结果如下：

a = 11
a = 11
a = 11
a = 11
a = 11

因为我们定义的 a 是局部变量，每次test01()结束运行之后，a 所在的内存空间都被回收了，当我们再重新调用test01函数的时候，又会重新分配一次空间，重新定义一个 a = 10， 然后 a ++，所以每次都是的结果都是11

当我们把普通局部变量换成静态局部变量之后

#include<stdio.h>
void test01()
{
   static int a = 10;//定义了一个局部变量
   a++;
   printf("a = %d\n", a);
}
int main()
{
   for (int i = 0; i < 5; i++)
   {
       test01();
   }
   return 0;
}

程序运行结果为：

a = 11
a = 12
a = 13
a = 14
a = 15

因为我们在test01()函数中定义的 a 是静态局部变量 ,函数结束之后会被特殊手段保留下来，当下次遇到static关键字的时候，编译器就会发现这个变量我们以前定义过，就会找到以前定义的 a 的地址，然后把 以前定义过并且操控过的 a 拿出来继续使用。

4.2 静态全局变量

特点：

• 定义：函数外部定义，使用static关键字修饰
• 作用范围：仅在当前文件作用域内使用
• 生命周期：整个程序结束后释放
• 注意事项：未初始化结果为 0，并且只能初始化一次

静态全局变量和普通全局变量使用方法相似，唯一的不同就是，上文中我们可以访问同一个项目下的其它的.cpp文件中的全局变量，但是我们不可以访问其它的.cpp文件中的静态全局变量

5. 静态函数和全局函数

在C语言中，函数默认为全局函数，而在函数返回值前加上static修饰，则将这个函数申明为静态全局函数，那么这个函数就不能被其他.cpp文件调用

全局函数可以被其他.cpp文件调用，在VS2019环境下的测试：

在test.cpp文件中编写一个简单的test02()函数

在静态变量和普通变量.cpp中调用test.cpp中的test02()函数，甚至都不用包含头文件就能调用

如果test.cpp文件中的test02()函数被申明为静态函数，那么在静态变量和普通变量.cpp中调用test.cpp中的test02()函数也同样会发生无法解析的外部命令的错误，在静态变量和普通变量.cpp中就算不调用test02()函数，只是申明有这个函数(使用了extern)，不调用，也会报错

6. 总结

学习不总结，等于没有学，下面是一张简单的表格概括了静态变量和普通变量的特性