问题描述：学习static定义静态变量的用法。
 
程序源码：
 
#include"stdio.h"
varfunc()
{
int var=0;
static int static_var=0;
printf("\40:var equal %d \n",var);
printf("\40:static var equal %d \n",static_var);
printf("\n");
var++;
static_var++;
}
void main()
{int i;
　for(i=0;i<3;i++)
　　varfunc();
}
 
 

局部变量、全局变量和静态变量之间的区别
 
(1)局部变量
 
   定义： 在一个函数内部定义的变量是局部变量，它只在本函数范围内有效。
 
1.主函数main定义的变量也只在主函数有效；
 2.不同函数中可以使用名字相同的变量，它们代表不同的对象，互不干扰；
 3.形式参数也是局部变量；
 4.在一个函数内部，可以在复合语句中定义变量，这些变量只在本复合语句中有效。
 
(2)全局变量
 
   定义：在函数外定义的变量是全局变量，全局变量可以为本文件中其它函数所共用，它的有效范围从定义变
        量的位置开始到本源文件结束。
 
1.设全局变量的作用：增加了函数间数据联系的渠道；
 2.建议不再必要的时候不要使用全局变量，因为
 
    a.全局变量在程序的全部执行过程中都占用存储单元；
    b.它使函数的通用性降低了；
    c.使用全局变量过多，会降低程序的清晰性。
 
3.如果外部变量在文件开头定义，则在整个文件范围内都可以使用该外部变量，如果不在文件开头定义，按上面规定作用范围只限于定义点到文件终了，如果在定义点之前的函数想引用该外部变量，则应该在该函数中用关键字extern作外部变量说明；
 4.如果在同一个源文件中，外部变量与局部变量同名，则在局部变量的作用范围内，外部变量不起作用。
 
(3)静态变量
 
1.静态变量的作用范围要看静态变量的位置，如果在函数里，则就是静态局部变量，作用范围就是这个函数；
 2.静态全局变量，只在本文件可以用，虽然整个程序包含多个文件， 但静态全局变量只能用在定义它的那个文件里，却不能用在程序中的其他文件里。它是定义存储因型为静态型的外部变量，其作用域是从定义点到程序结束，所不同的是存储类型决定了存储地点，静态型变量是存放在内存的数据区中的， 它们在程序开始运行前就分配了固定的字节， 在程序运行过程中被分配的字节大小是不改变的，只有程序运行结束后，才释放所占用的内存。
 
<1>static全局变量与普通的全局变量有什么区别？
 
  全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。
 
<2>static函数与普通函数有什么区别？
 
  static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件。
 
<3>static局部变量和普通局部变量有什么区别？
 
  static局部变量只被初始化一次，下一次依据上一次结果值。
 
总结：
 
 
全局变量的作用域是整个项目，它只需要在一个源文件中定义就可以作用于所有的源文件，其它不包括全局变量定义的文件需要用extern关键字再次声明这个全局变量。
 
 
全局变量、静态全局变量、静态局部变量都是在静态存储区（全局数据区）中分配空间的，而局部变量是在栈上分配空间的。
 
 
全局变量、静态变量的生命期和程序生命期是一样的，在程序结束之后操作系统会回收空间。
 
 
全局变量和静态变量都是保存在静态存储区中，生命期和程序一样，但是不同的是全局变量的作用域是整个项目，而静态全局变量是当前程序文件，静态局部变量则是当前函数体内。全局变量和静态全局变量、静态局部变量默认值都是0，也就是在没有初始化变量值的时候默认为0。
 
 
静态变量包含静态局部变量和静态全局变量。
 
静态局部变量具有局部作用域只对定义自己的函数可见，只被初始化一次，自从初始化一次之后直到程序运行期间一直都在。
 
静态全局变量具有全局作用域作用于定义它的程序文件但是不能作用于项目里的其它文件，这一点和全局变量不同。静态全局变量可以被多次初始化。
 
 
把局部变量改变为静态变量之后是改变了它的存储方式和生命期。
 
把全局变量改变为静态变量之后是改变了它的作用域，限制了使用范围。
 
 
C语言经过编译之后将内存分为以下几个区域：
 
（1）栈（stack）：由编译器进行管理，自动分配和释放，存放函数调用过程中的各种参数、局部变量、返回值以及函数返回地址。操作方式类似数据结构中的栈。
 （2）堆（heap）：用于程序动态申请分配和释放空间。C语言中的malloc和free，C++中的new和delete均是在堆中进行的。正常情况下，程序员申请的空间在使用结束后应该释放，若程序员没有释放空间，则程序结束时系统自动回收。注意：这里的“堆”并不是数据结构中的“堆”。
 （3）全局（静态）存储区：分为DATA段和BSS段。DATA段（全局初始化区）存放初始化的全局变量和静态变量；BSS段（全局未初始化区）存放未初始化的全局变量和静态变量。程序运行结束时自动释放。其中BBS段在程序执行之前会被系统自动清0，所以未初始化的全局变量和静态变量在程序执行之前已经为0。
 （4）文字常量区：存放常量字符串。程序结束后由系统释放。
 （5）程序代码区：存放程序的二进制代码。
 显然，C语言中的全局变量和局部变量在内存中是有区别的。C语言中的全局变量包括外部变量和静态变量，均是保存在全局存储区中，占用永久性的存储单元；局部变量，即自动变量，保存在栈中，只有在所在函数被调用时才由系统动态在栈中分配临时性的存储单元。

静态全局变量
 
作用域仅限于变量被定义的文件中，其他文件即使用 extern 声明也没法使用他。准确地说作用域是从定义之处开始，到文件结尾处结束，在定义之处前面的那些代码行也不能使用它。想要使用就得在前面再加 extern ***。要想直接使用，很简单，直接在文件顶端定义不就得了。
 
静态局部变量
 
在函数体里面定义的，就只能在这个函数里用了，同一个文档中的其他函数也用不了。由于被 static 修饰的变量总是存在内存的静态区，所以即使这个函数运行结束，这个静态变量的值还是不会被销毁，函数下次使用时仍然能用到这个值。
 
例子
 
#include <stdio.h>

static int j;

void fun1(void){
	static int i=0;
	i++;
	printf("i=%d\t",i);
}
void fun2(void){
	j=0;
	j++;
	printf("j=%d\n",j);
}

int main(){
	for( int k=0; k<10; k++){
		fun1();
		fun2();
	}
	return 0;
}

 
执行结果
 
[root@localhost test]# ./static 
i=1	j=1
i=2	j=1
i=3	j=1
i=4	j=1
i=5	j=1
i=6	j=1
i=7	j=1
i=8	j=1
i=9	j=1
i=10j=1

       在C语言中static类型的变量的意思其实和它的本意差不多，表示“静态”或者“全局”的意思，用来修饰变量和函数。经static修饰过后的变量或者函数的作用域或者存储域会发生变化，而由static修饰的变量在初始值方面也会表现出static关键字的优势。
 
C语言中程序的内存分布：
 
    1）正文段 —— CPU执行的机器指令部分；一个程序只有一个副本；只读，防止程序由于意外事故而修改自身指令；
 
    2）初始化数据段（数据段）—— 在程序中所有赋了初值的全局变量，存放在这里。
 
    3）非初始化数据段（bss段）—— 在程序中没有初始化的全局变量；内核将此段初始化为0。
 
    4）栈 —— 增长方向：自顶向下增长；自动变量以及每次函数调用时所需要保存的信息（返回地址；环境信息）。
 
　5）堆 —— 动态存储区。是向高地址扩展的数据类型，是自下向上的扩展方式。
 
 
（此图来源于网络）
 
static修饰的全局变量
 
　　在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。
 
　    　1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）
 
　　    2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）
 
　　    3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。
 
       定义全局静态变量的好处：
 
　　    <1>不会被其他文件所访问，修改
 
　　    <2>其他文件中可以使用相同名字的变量，不会发生冲突。
 
　　注：当static用来修饰全局变量的时候，它就改变了全局变量的作用域（在声明他的文件之外是不可见的），但是没有改变它的存放位置，还是在静态存储区中。
 
static修饰的局部变量
 
       在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。
 
　　    1）内存中的位置：静态存储区
 
　　    2）初始化：未经初始化的局部静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）
 
　　    3）作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。
 
　　注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。
 
Static修饰的函数
 
　    在函数的返回类型前加上关键字static，函数就被定义成为静态函数。函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件中可见，不能被其他文件所用。

 定义静态函数的好处：
 <1> 其他文件中可以定义相同名字的函数，不会发生冲突 
 
<2> 静态函数不能被其他文件所用。
 

        存储说明符auto，register，extern，static，对应两种存储期：自动存储期和静态存储期。auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。
 　　关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期（static storage duration），或静态范围（static extent）。虽然他的值在函数调用之间保持有效，但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。
 
总结
 
（1）第一个作用：隐藏。
 
（2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。
 
（3）static的第三个作用是默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。
 
最后附上，我遇到过的函数段：
 
#define MAX_CALCULATE_COUNT 		   (48)
static int battery_core_calculate_average_voltage(struct battery_core *bat, int cur_voltage)
{

#define BATTERY_VOLTAGE_ERROR_UP       (25 * 1000)
#define BATTERY_VOLTAGE_ERROR_DOWN     (-50 * 1000)

	static int vol_pre = 0;
	static int vol_error = 0;
	static int vol_recover = BATTERY_VOLTAGE_ERROR_UP;
	static unsigned char cur_index = 0;
	static unsigned char max_index = 0;
	static int vol_ma[MAX_CALCULATE_COUNT];
	int average;
  	static int pre_average = 0;
	int dv = 0;
	int i;

	if(!bat->props.present) {	
		vol_pre = 0;
		vol_error = 0;
		vol_recover = BATTERY_VOLTAGE_ERROR_UP;
		cur_index = 0;
		max_index = 0;
		return cur_voltage;
	}

	/*voltage check and auto-correct*/
#if 1
	do {
		if(vol_pre > 0) {
			dv = cur_voltage - vol_pre;
			if(dv <= BATTERY_VOLTAGE_ERROR_DOWN) { /*We assume the battery output big current!*/
				vol_error =   (dv * 9) / 10;
				vol_recover =  - dv / 2;
			} else if(dv >= vol_recover ) { /*We assume the battery recovery from big current output!*/
				vol_error = 0;
				vol_recover = BATTERY_VOLTAGE_ERROR_UP;
			} else {
				vol_error = 0;
				vol_recover = BATTERY_VOLTAGE_ERROR_UP;
			}
		}
		vol_pre = cur_voltage;
		cur_voltage -= vol_error;
	} while(0);
#endif
	pr_err("[jason]vol_pre:%d, cur_voltage:%d\n", vol_pre, cur_voltage);//add by jason

	vol_ma[cur_index] = cur_voltage;
	cur_index ++;
	if(cur_index >= ARRAY_SIZE(vol_ma))
		cur_index = 0;
	if(max_index < ARRAY_SIZE(vol_ma))
		max_index ++;

	average = 0;
	for(i = 0; i < max_index; i++) {
		average += vol_ma[i] ;
	}
	average = average / max_index;


	if(bat->params.debug_mode)
		pr_err(" vol_pre = %dmV - (dv=%d, ev=%d)-> %dmV, avg = %dmV\n", 
			vol_pre/1000, dv/1000, vol_error/1000, cur_voltage/1000, average/1000);

	if( bat->props.state == POWER_SUPPLY_STATUS_DISCHARGING && pre_average > 0 && pre_average < average ) {
		return pre_average;
	}

	pre_average = average;
 
	return average;
}
 
以上函数进行的是平均电压的计算。函数中大量使用static的类型的变量，这样可以保留48组数据进行计算平均电压。
 
本文部分参考https://www.cnblogs.com/zzm1/p/10690465.html