静态存储变量通常是在变量定义时就分定存储单元并一直保持不变，
		直至整个程序结束。5.5.1节中介绍的全局变量即属于此类存储方式。动态存储变量是在程序执行过程中，使用它时才分配存储单元，
		使用完毕立即释放。
		典型的例子是函数的形式参数，在函数定义时并不给形参分配存储单元，只是在函数被调用时，才予以分配，
		调用函数完毕立即释放。如果一个函数被多次调用，则反复地分配、
		释放形参变量的存储单元。从以上分析可知，
		静态存储变量是一直存在的，
		而动态存储变量则时而存在时而消失。我们又把这种由于变量存储方式不同而产生的特性称变量的生存期。
		生存期表示了变量存在的时间。
		生存期和作用域是从时间和空间这两个不同的角度来描述变量的特性，这两者既有联系，又有区别。
		一个变量究竟属于哪一种存储方式，
		并不能仅从其作用域来判断，还应有明确的存储类型说明。
	
 
 
在Ｃ语言中，对变量的存储类型说明有以下四种：
 
 
auto 自动变量
		
 
 
register 　　寄存器变量
		
 
 
 
 
在C语言编程中，static的一个作用是信息屏蔽！
	
 
 
比方说，你自己定义了一个文件 -- 该文件中有一系列的函数以及变量的声明和定义！
	
 
 
你希望该文件中的一些函数和变量只能被该文件中的函数使用，那么，你可以在该函数、变量的前面加上static，代表他们只能被当前文件中的函数使用！
	
 
 
 
 
而在C++中，用static来作为信息屏蔽就显得没有必要了！因为，C++有了信息屏蔽的利器 -- class机制！
	
 
 
类中的private属性的变量和函数就对外禁止访问！
	
 
 
 
 
然后是C/C++通用的函数作用域的static型的变量！其目的，也是为了信息的屏蔽！
	
 
 
 
 
int fun() {
    static int a = 1;
    a++;
}
 
 
在第一次进入这个函数的时候，变量a被初始化为1！并接着自增1！
	
 
 
以后每次进入该函数，a就不会被再次初始化了，仅进行自增1的操作！
	
 
 
在static发明前，要达到同样的功能，则只能使用全局变量：
	
 
 
int a = 1;
 
 
int fun() {
    a++;
}
 
 
那么，a的值就有可能被其他函数所改变！
	
 
 
 
 
 
 
最后，说说类中的static变量和函数。
	
 
 
 
 
这种存储属性的变量和函数是同一种类的不同实例之间通信的桥梁！
 
 
 
 
#include 
using namespace std;
 
 
class A {
public:
     static int num;     //     统计创建了多少个实例
	
     A () {num++};     //     每创建一个实例，就让num自增1
 
 
     //     返回通过构造函数所创建过的A类实例的数目
	
     static int how_many_instance() {
         return num;
     }
}
 
 
static A::num = 0;     //     需要在类申明的外部单独初始化！
	
 
 
 
 
int main() {
     cout << A::how_many_instance() << endl;
     A a, b, c, d;
     cout << A::how_many_instance() << endl;
     system("pause");
}
 
 
 
 
一般，在类内部，是通过static属性的函数，访问static属性的变量！
	
 
 
补充一点，在类中，static型的成员函数，由于是类所拥有的，而不是具体对象所有的，这一点对于windows的回调机制非常有用。
	
因为对于回调函数而言，windows不会借助任何对象去调用它，也就不会传递this指针，那么对于一般成员函数作为回调函数的后果，就是堆栈中有一个随机的变量会成为this指针，这当然会引发程序的崩溃。
	
而static函数，由于是整个类的，屏蔽了this指针。因此，如果成员函数作为回调函数，就应该用static去修饰它。
	
 
 
(

		使用回调函数的编程模式，可以根据不同的需求传递不同的回调函数地址，或者定义各种回调函数的原形（同时也需要改变使用回调函数的参数和返回值约定），实现多种回调事件处理，可以使程序的控制灵活多变，也是一种高效率的，清晰的程序模块之间的耦合方式。在一些异步或复杂的程序系统里尤其有用 -- 你可以在一个模块（如DLL）里专心实现模块核心的业务流程和技术功能，外围的扩展的功能只给出一个回调函数的接口，通过调用其他模块传递过来的回调函数地址的方式，将后续处理无缝地交给另一个模块，随它按自定义的方式处理。
	
)
 
 

				静态局部变量属于静态存储方式，它具有以下特点： (1)静态局部变量在函数内定义
				它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后，
				尽管该变量还继续存在，但不能使用它。 (2)允许对构造类静态局部量赋初值
				例如数组，若未赋以初值，则由系统自动赋以0值。 (3)对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。
				根据静态局部变量的特点，
				可以
				看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用，
				而且保存了前次被调用后留下的
				值。
				因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成
				意外的副作用，因此仍以采用局部静态变量为宜。
			
 
 
3.静态全局变量全局变量(外部变量)的说明之前再冠以static 就构
				成了静态的全局变量。全局变量本身就是静态存储方式，
				静态全局变量当然也是静态存储方式。
				这两者在存储方式上并无不同。这两者的区别虽在于非静态全局
				变量的作用域是整个源程序，
				当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
				而静态全局变量则限制了其作用域，
				即只在
				定义该变量的源文件内有效，
				在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，
				因此
				可以避免在其它源文件中引起错误。从以上分析可以看出，
				把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量
				后是改变了它的作用域，
				限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。
			
 
 
 
 
-------------------------------------------------------------------------------
 
 
 
 
 
 
静态变量的类型说明符是static。
				静态变量当然是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量，
				例如外部变量虽属于静态存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。
				对于自动变量，它属于动态存储方式。
				但是也可以用static定义它为静态自动变量，或称静态局部变量，从而成为静态存储方式。
			
由此看来，
				一个变量可由static进行再说明，并改变其原有的存储方式。
			
1. 静态局部变量
			
在局部变量的说明前再加上static说明符就构成静态局部变量。
			
例如：
static int a,b;
static float array[5]={1,2,3,4,5}；
			
静态局部变量属于静态存储方式，它具有以下特点：
(1)静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。
			
(2)静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，
				尽管该变量还继续存在，但不能使用它。
			
(3)允许对构造类静态局部量赋初值。若未赋以初值，则由系统自动赋以0值。
			
(4)对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。
				根据静态局部变量的特点，
				可以看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用，
				而且保存了前次被调用后留下的值。
				因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成意外的副作用，因此仍以采用局部静态变量为宜
			
2.静态全局变量
			
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，
				静态全局变量当然也是静态存储方式。
				这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，
				当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
				而静态全局变量则限制了其作用域，
				即只在定义该变量的源文件内有效，
				在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，
				因此可以避免在其它源文件中引起错误。从以上分析可以看出，
				把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，
				限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。应予以注意。
			
静态变量
除范围之外，变量还有存活期，在这一期间变量能够保持它们的值。在应用程序的存活期内一直保持模块级变量和公用变量的值。但是，对于 Dim 声明的局部变量以及声明局部变量的过程，仅当过程在执行时这些局部变量才存在。通常，当一个过程执行完毕，它的局部变量的值就已经不存在，而且变量所占据的内存也被释放。当下一次执行该过程时，它的所有局部变量将重新初始化。
			
但可将局部变量定义成静态的，从而保留变量的值。在过程内部用 Static 关键字声明一个或多个变量，其用法和 Dim 语句完全一样：
			
Static Depth
例如，下面的函数将存储在静态变量 Accumulate 中的以前的运营总值与一个新值相加，以计算运营总值。
			
Function RunningTotal (num)
Static ApplesSold
ApplesSold = ApplesSold + num
RunningTotal = ApplesSold
End Function
如果用 Dim 而不用 Static 声明 ApplesSold，则以前的累计值不会通过调用函数保留下来，函数只会简单地返回调用它的那个相同值。
			
在模块的声明段声明 ApplesSold，并使它成为模块级变量，由此也会收到同样效果。但是，这种方法一旦改变变量的范围，过程就不再对变量排他性存取。由于其它过程也可以访问和改变变量的值，所以运营总值也许不可靠，代码将更难于维护。
			
声明所有的局部变量为静态变量
				
为了使过程中所有的局部变量为静态变量，可在过程头的起始处加上 Static 关键字。例如：
			
Static Function RunningTotal (num)
这就使过程中的所有局部变量都变为静态，无论它们是用 Static、Dim 或 Private 声明的还是隐式声明的。可以将 Static 放在任何 Sub 或 Funtion 过程头的前面，包括事件过程和声明为 Private 的过程。
			
 
 
 
 
 
 
 
 

1.定义
动态变量：int a；

静态变量：static int a;
2.静态存储与动态存储
2.1静态存储
静态变量，全局动态变量都是静态存储，

存储在全局数据区，在变量定义时就分定存储单元并一直保持不变，直至整个程序结束。静态存储变量是一直存在的，只会初始化一次。
2.2动态存储
局部动态变量是动态存储，

动态存储变量是在程序执行过程中，使用它时才分配存储单元，存储在内存出栈数据区，使用完毕立即释放
总结：静态存储，只初始化一次，每次调用从变化后的值继续改变；动态存储，每次调用都从初始值开始
3.动态变量
3.1全局动态变量
1）在所有函数的外部定义（包括主函数），定义之后的所有函数都能使用，属于静态存储

2）生命周期为从程序运行到程序退出，贯穿整个运行时间

3）无显式初始化时默认初始化值为0
3.2局部动态变量
1）在函数内部定义，属于动态存储，作用于为当前函数

2）生命周期为从函数调用到函数退出

3）无显式初始化时默认初始化值为随机值
4.静态变量
4.1全局静态变量
1）作用域为当前文件，从定义位置到文件结尾

2）生命周期为从程序运行到程序退出，即贯穿整个运行时间

3）无显式初始化时默认初始化值为0
动态全局变量可以通过extern关键字在外部文件中使用，静态全局变量不可以在外部文件中使用。
4.2局部静态变量
1）作用域为当前函数

2）生命周期为从程序运行到程序退出，即贯穿整个运行时间，当下次函数调用时，静态局部变量不会被再次初始化，而是沿用上次函数退出时的值

变量的存储方式可分为“静态存储”和“动态存储”两种


　        静态存储变量通常是在变量定义时就分定存储单元并一直保持不变， 直至整个程序结束。5.5.1节中介绍的全局变量即属于此类存储方式。动态存储变量是在程序执行过程中，使用它时才分配存储单元， 使用完毕立即释放。 典型的例子是函数的形式参数，在函数定义时并不给形参分配存储单元，只是在函数被调用时，才予以分配， 调用函数完毕立即释放。如果一个函数被多次调用，则反复地分配、 释放形参变量的存储单元。从以上分析可知，
 静态存储变量是一直存在的， 而动态存储变量则时而存在时而消失。我们又把这种由于变量存储方式不同而产生的特性称变量的生存期。 生存期表示了变量存在的时间。 生存期和作用域是从时间和空间这两个不同的角度来描述变量的特性，这两者既有联系，又有区别。 一个变量究竟属于哪一种存储方式， 并不能仅从其作用域来判断，还应有明确的存储类型说明。


　　在Ｃ语言中，对变量的存储类型说明有以下四种：


auto　　　　 自动变量


register 　　寄存器变量


extern 　　　外部变量


static 　　　静态变量 


　　自动变量和寄存器变量属于动态存储方式， 外部变量和静态变量属于静态存储方式。在介绍了变量的存储类型之后， 可以知道对一个变量的说明不仅应说明其数据类型，还应说明其存储类型。 因此变量说明的完整形式应为： 存储类型说明符 数据类型说明符 变量名，变量名…； 例如：


static int a,b; 　　　　　　　　　 说明a,b为静态类型变量


auto char c1,c2; 　　　　　　　　　说明c1,c2为自动字符变量


static int a[5]={1,2,3,4,5}; 　　　说明a为静整型数组


extern int x,y; 　　　　　　　　　 说明x,y为外部整型变量


下面分别介绍以上四种存储类型：


一、自动变量的类型说明符为auto。


　　这种存储类型是Ｃ语言程序中使用最广泛的一种类型。Ｃ语言规定， 函数内凡未加存储类型说明的变量均视为自动变量， 也就是说自动变量可省去说明符auto。 在前面各章的程序中所定义的变量凡未加存储类型说明符的都是自动变量。例如：

{ int i,j,k;


char c;


……


}等价于： { auto int i,j,k;


auto char c;


……


}

　　自动变量具有以下特点：


1. 自动变量的作用域仅限于定义该变量的个体内。在函数中定义的自动变量，只在该函数内有效。在复合语句中定义的自动变量只在该复合语句中有效。 例如： 

int kv(int a)


{


auto int x,y;


{ auto char c; 


} /*c的作用域*/


……


} /*a,x,y的作用域*/




2. 自动变量属于动态存储方式，只有在使用它，即定义该变量的函数被调用时才给它分配存储单元，开始它的生存期。函数调用结束，释放存储单元，结束生存期。因此函数调用结束之后，自动变量的值不能保留。在复合语句中定义的自动变量，在退出复合语句后也不能再使用，否则将引起错误。例如以下程序： 

main()


{ auto int a,s,p;


printf(\"\\ninput a number:\\n\");


scanf(\"%d\",&a);


if(a>0){


s=a+a;


p=a*a;


}


printf(\"s=%d p=%d\\n\",s,p);


}

s,p是在复合语句内定义的自动变量，只能在该复合语句内有效。而程序的第9行却是退出复合语句之后用printf语句输出s,p的值，这显然会引起错误。


3. 由于自动变量的作用域和生存期都局限于定义它的个体内( 函数或复合语句内)， 因此不同的个体中允许使用同名的变量而不会混淆。 即使在函数内定义的自动变量也可与该函数内部的复合语句中定义的自动变量同名。例5.14表明了这种情况。


[例5.14]

main()


{


auto int a,s=100,p=100;


printf(\"\\ninput a number:\\n\");


scanf(\"%d\",&a);


if(a>0)


{


auto int s,p;


s=a+a;


p=a*a;


printf(\"s=%d p=%d\\n\",s,p);


}


printf(\"s=%d p=%d\\n\",s,p);


}

　　本程序在main函数中和复合语句内两次定义了变量s,p为自动变量。按照Ｃ语言的规定，在复合语句内，应由复合语句中定义的s,p起作用，故s的值应为a+ a，p的值为a*a。退出复合语句后的s,p 应为main所定义的s,p，其值在初始化时给定，均为100。从输出结果可以分析出两个s和两个p虽变量名相同， 但却是两个不同的变量。


4. 对构造类型的自动变量如数组等，不可作初始化赋值。

 


动态存储方式与静态动态存储方式：



从变量的作用域（即从空间）角度来分，可以分为全局变量和局部变量。

从另一个角度，从变量值存在的作时间（即生存期）角度来分，可以分为静态存储方式和动态存储方式。
静态存储方式：是指在程序运行期间分配固定的存储空间的方式。
动态存储方式：是在程序运行期间根据需要进行动态的分配存储空间的方式。
用户存储空间可以分为三个部分：
1)        程序区；2)        静态存储区；3)        动态存储区；
全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。在程序执行过程中它们占据固定的存储单元，而不动态地进行分配和释放；
动态存储区存放以下数据：
1)        函数形式参数；
2)        自动变量（未加static声明的局部变量）；
3)        函数调用实的现场保护和返回地址；
对以上这些数据，在函数开始调用时分配动态存储空间，函数结束时释放这些空间。
在c语言中，每个变量和函数有两个属性：数据类型和数据的存储类别。

从变量的作用域角度可以对变量进行分类为【全局变量】和【局部变量】
从变量值的生存期可以对变量进行分类为【静态存储方式】和【动态存储方式】
用户的存储空间可大致分为以下三种

1、程序区

2、静态区

3、动态区

一、  静态存储
1、基本概念

静态存储方式：指在程序运行时，给变量分配固定的存储空间的方式

2、 静态存储区存放以下变量：

全局变量：在程序开始执行时给全局变量分配存储区，程序运行完毕之后释放。在程序运行过程中它们占据固定的存储单元而不动态进行分配和释放。
静态局部变量：有时希望局部变量的值在函数调用结束后不消失而保留原值，这时就应该指定局部变量为“静态局部变量”了，用关键字static进行生命

二、动态存储
1、基本概念
动态存储方式：指在程序运行时，根据需要给变量分配动态的存储空间的方式
2、动态存储区存放以下变量。

函数形式的参数
自动变量（未加static声明的局部变量）：函数中的局部变量，如不声明为static存储类别的变量，则都是动态存储类别的。函数的形参和函数体中定义的变量都属于此类。在调用函数的时候系统给他自动分配空间，在函数调用结束后，自动释放存储空间。这类局部变量称为自动变量，用关键字auto声明存储类别。
函数调用时的现场保护和返回地址。

三、示例脚本代码
1、示例脚本代码
static int c;
int prine(register int number)//判断是否为素数函数
{
	register int flag =1;
	auto int n;
	for(n=2;n<number/2  && flag==1;n++)
		if (number%n==0)
			flag=0;
		return flag;
}
demo (int a )//static、auto变量的演示函数
{
	auto int b=0;
	int d;
	static c=3;
	b=b+1;
	c=c+1;
	lr_output_message("demo()函数中的d=%d",d);
	lr_output_message("demo()函数中的static c=%d",c);
	return a+b+c;
}

Action()
{
	int a=2,i;
	for(i=0;i<3;i++)
	{
		lr_output_message("demo()函数部分第%d运行情况如下：",i+1);
		lr_output_message("函数demo运行结果为：%d",demo(a));
		lr_output_message("------------------\n\r");
	}
	
	//判断13是否为素数，并输出提示信息
	if(prime(13)==0) lr_output_message("13不是素数！");
	else lr_output_message("13是素数！");
	
	lr_output_message("c=%d",c);//输出静态变量的值
	
	return 0;
}

2、以上代码的输出信息
Running Vuser...
Starting iteration 1.
Starting action Action.
Action.c(30):demo()函数部分第1运行情况如下：
Action.c(18):demo()函数中的d=25362920;
Action.c(19):demo()函数中的static c=4;
Action.c(31):函数demo运行结果为：7
Action.c(32):---------------------

Action.c(30):demo()函数部分第2运行情况如下：
Action.c(18):demo()函数中的d=25362920;
Action.c(19):demo()函数中的static c=5;
Action.c(31):函数demo运行结果为：8
Action.c(32):---------------------

Action.c(30):demo()函数部分第3运行情况如下：
Action.c(18):demo()函数中的d=25362920;
Action.c(19):demo()函数中的static c=6;
Action.c(31):函数demo运行结果为：9
Action.c(32):---------------------

Action.c(36):13是素数！
Action.c(38):c=0
Ending action Action.
Ending iteration 1.
Ending Vuser...

3、解析

在demo()函数中，d未被赋值，则输出的是值应该是随机数
如果没给自动变量赋初值，则在它的值为一个不确定值，自动变量在函数调用的时候，每调用一次，给函数重新赋一次值。
静态局部变量在定义时不赋值，则编译时默认为0。如上静态变量c。
静态局部变量在编译的时候赋初值，即只赋初值一次。参见demo()函数中的static c=3，每次调用时，它的值都在变化，第一次调用c=3；c=c+1后c的值为4，第二次调用c的值为4…