static变量

如果你再调用一次f就会看出来了简单理解,你可以吧他当全局变量.

非静态全局 变量的作用域是整个源程序

JSDHDUSWJSDISISDHFUHAJGUIQFRUGTIQ

static变量的初始化，事实胜于雄辩，啥也别说，code说明问题：[cpp] view plain copy print?int add(int a, int b) { static int result = a + b; return result; } int _tmain(int argc, _TCHAR* argv[]) { int a = add(2, 1); int b = add(3, 4); if ( a== b) cout << 1 << endl; return 0; } 输出为：1。稍作修改：[cpp] view plain copy print?int add(int a, int b) { static int result = 0; result = a + b; return result; } int _tmain(int argc, _TCHAR* argv[]) { int a = add(2, 1); int b = add(3, 4); if ( a== b) cout << 1 << endl; return 0; } 没有任何输出。这就是static变量的一个性质：初始化只有一次，但是可以多次赋值。在第一段代码中：[cpp] view plain copy print?static int result = a + b; 从汇编的调试过程中可以发现只有第一次调用add方法时才进行了初始化，第二次初始化直接跳过了。但是赋值是可以多次的。这也就说明了静态变量的初始化和赋值的区别。另外，如果上述代码返回引用，并且同时比较二者不使用中间变量呢？如下例：[cpp] view plain copy print?int& add(int a, int b) { static int result = 0; result = a + b; return result; } int _tmain(int argc, _TCHAR* argv[]) { //int a = add(2, 1); //int b = add(3, 4); if (add(2, 1) == add(3, 4)) cout << 1 << endl; return 0; } 输出结果为：1[plain] view plain copy print?00313C7E push 1 00313C80 push 2 00313C82 call add (0311451h) 00313C87 add esp,8 00313C8A mov esi,eax 00313C8C push 4 00313C8E push 3 00313C90 call add (0311451h) 00313C95 add esp,8 00313C98 mov ecx,dword ptr [esi] 00313C9A cmp ecx,dword ptr [eax] 00313C9C jne wmain+6Bh (0313CCBh) 从下面比较的汇编看来，其实二者比较的是同一地址的数据，所以必然相等。[plain] view plain copy print?<pre name="code" class="plain">00313C9A cmp ecx,dword ptr [eax]

因为static的变量是放在静态存储区，和全局变量像似，只是作用域不同。

写的真抽象....如果是页面传值问题，建议用Session。打字不易，如满意，望采纳。

static区，就是类加载就纯在的。方法区，是加载这个方法时才有的、

1. static 变量 　　静态变量的类型 说明符是static。 静态变量当然是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量。 例如外部变量虽属于静态 存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。 　　2. 静态局部变量 　　静态局部变量属于静态存储方式，它具有以下特点： 　　(1)静态局部变量在函数内定义 它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后， 尽管该变量还继续存在，但不能使用它。 　　(2)允许对构造类静态局部量赋初值 例如数组，若未赋以初值，则由系统自动赋以0值。 　　(3)对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。 根据静态局部变量的特点， 可以 看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用， 而且保存了前次被调用后留下的 值。 因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成 意外的副作用，因此仍以采用局部静态变量为宜。 　　3.静态全局变量 　　全局变量(外部变量)的说明之前再冠以static 就构 成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局 变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在 定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此 可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量 后是改变了它的作用域， 限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。 　　4. static 函数….. 　　内部函数和外部函数 　　当一个源程序由多个源文件组成时，C语言根据函数能否被其它源文件中的函数调用，将函数分为内部函数和外部函数。 　　1 内部函数（又称静态函数） 　　如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数称为内部函数。 　　定义一个内部函数，只需在函数类型前再加一个“static”关键字即可，如下所示： 　　static 函数类型 函数名(函数参数表) 　　{……} 　　关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。 　　使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。 　　2 外部函数 　　外部函数的定义：在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数： 　　[extern] 函数类型 函数名(函数参数表) 　　{……} 　　调用外部函数时，需要对其进行说明： 　　[extern] 函数类型 函数名(参数类型表)[，函数名2(参数类型表2)……]； 　　案例]外部函数应用。 　　（1）文件mainf.c 　　main() 　　{ extern void input(…),process(…),output(…); 　　input(…); process(…); output(…); 　　} 　　（2）文件subf1.c 　　…… 　　extern void input(……) /*定义外部函数*/ 　　{……} 　　（3）文件subf2.c 　　…… 　　extern void process(……) /*定义外部 函数*/ 　　{……} 　　（4）文件subf3.c 　　…… 　　extern void output(……) /*定义外部函数*/ 　　{……}

static是静态变量，也就是说在程序执行之前就分配内存，直到程序退出才释放内存。所以static变量在程序执行过程中它的值将一直保留。而普通的成员变量在一个类被销毁后它的值也就消失，每次调用，又重新分配内存地址和值

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static成员的最常见的例子是main( )。因为在程序开始执行时必须调用main()，所以它被声明为static。声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：· 它们仅能调用其他的static方法。· 它们只能访问static数据。· 它们不能以任何方式引用this或super（关键字super与继承有关，在下一章中描述）。 如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块： class UseStatic { static int a = 3; static int b; static void meth(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b);} static { System.out.println("Static block initialized."); b = a * 4; } public static void main(String args[]) { meth(42); } }一旦UseStatic类被装载，所有的static语句被运行。首先，a被设置为3，接着static块执行(打印一条消息)，最后，b被初始化为a*4或12。然后调用main()，main()调用meth()，把值42传递给x。3个println ( )语句引用两个static变量a和b，以及局部变量x 。注意：在一个static方法中引用任何实例变量都是非法的。下面是该程序的输出：Static block initialized.x = 42a = 3b = 12在定义它们的类的外面，static方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：classname.method( )这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一static变量可以以同样的格式来访问——类名加点号运算符。这就是Java如何实现全局功能和全局变量的一个控制版本。下面是一个例子。在main()中，static方法callme()和static变量b在它们的类之外被访问。class StaticDemo {static int a = 42;static int b = 99;static void callme() {System.out.println("a = " + a);}}class StaticByName {public static void main(String args[]) {StaticDemo.callme();System.out.println("b = " + StaticDemo.b);}}下面是该程序的输出：a = 42b = 99static成员是不能被其所在class创建的实例访问的。如果不加static修饰的成员是对象成员，也就是归每个对象所有的。加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的

我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！！ Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。 用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它的类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。 当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收。 与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。 如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如： 静态变量也称为类变量，属于类对象所有，位于方法区，为所有对象共享，共享一份内存，一旦值被修改，则其他对象均对修改可见，故线程非安全。 比如某个网站中，对于图片自动生成功能有两个开关，一个是总的开关，一个是配置网站中广告是否自动生成的局部开关。如果总开关没有开，那么即使局部开关打开也无法实现图片自动生成的功能。那么这个总开关可以设置为 public static final local_cache_job_flag = TRUE/FALSE ，说明它是不可以被随意一个类改变的（不能随意改变），但是是全局共享的变量。 而某一些变量，每个用户进入网站之后若此变量应该被重新初始化然后重新赋值，那么此变量就不可以设置为static，因为如果设置为static之后，一个用户进入改变了这个变量的值，那么另外一个用户进入之后，获取到这个变量的值就不是初始化的值，而是被上一个用户改变过的值。 我们也还可以利用static的特性存储在线用户：

使用静态变量public static int state = 0;

对，你说对了， 比如静态代码块，是程序进行周期最长的，在类加载的时候（没有new对象的时候就进行初始化），因为是静态（即在程序进行时都存在），所以值赋值一次···

二、static修饰的变量 1. 全局静态变量 在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。 1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在） 2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是 任意的，除非他被显示初始化） 3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。 定义全局静态变量的好处： <1>不会被其他文件所访问，修改 <2>其他文件中可以使用相同名字的变量，不会发生冲突。 2. 局部静态变量 在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。 1）内存中的位置：静态存储区 2）初始化：未经初始化的局部静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化） 3）作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。 注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。

在c中全局变量的说明之前再加以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围java类的成员变量有俩种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。　　在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。　　在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

可以，凡是变量，它的值就可以被修改：）常量的值不能被修改。

用final static是常量不可改变的只有一份,好像用类名就可直接调用

任何变量“初始化”都只有一次。const修饰的是只读变量，在程序全程中其值永远不变。static修饰的变量的值可以无数次改变，但无论在哪里改变，其改变后的值一直保留至下次改变之前。const修饰的变量在内存中存放在无const修饰的同类变量同一区域，static修饰的变量则在专门的另一区域。

static定义的变量只有第一次被赋值，这之后会自然使用之前留下来的值了，不会每次都按3初始化的。:-)

但就这个函数是没问题

不能，但用extern可以

C++11里面是线程安全的

1：前面你用的是static成员函数，该static关键字在此处的意思是：该函数属于整个类的，不是在某一个具体对象的，也就是说你可以通过类名::函数名来调用。注意：静态成员函数中不能引用非静态的成员变量。2：后面的static修饰的是局部变量，也就是说 i 在函数里面每次的值，增加之后是不变的。原因是：static 是在静态数据存储区上分配内存。而普通的局部变量是在栈上分配内存，也就是说如果 i 是在栈上分配内存的话，每次函数调用完成之后，就会收回内存，i 的值每次都为1.

在调用他的函数里还能使用这个变量么？可以能释放这个变量么？释放？变量本身不是动态申请的当然不能释放。如果你指的是一个static的指针指向一个动态申请的变量，这个应该可以释放递归函数也可以，具体会出什么问题就得看到底是什么函数了

区别就是静态变量只有第一次运行函数的时候被创建，并且在函数结束的时候不会消亡；而普通的成员在函数结束的时候就会在内存中退栈消亡。//Ex_1.cvoid fun_1 (){ static int a = 0; a ++; printf ("%d", a);}void fun_2 (int times){ int i = 0; for (;i < times; i++) { fun_1 (); }}之后再执行fun_2的话，就会依次打印：12345....直到times；如果去掉static关键字，执行fun_2，屏幕就会打印111111...次数为times次；下面举例说明一下函数外的：//H.h#ifndef _H_H_#define _H_H_static int a = 0;#endif//Ex_2.c#include "H.h"void fun_ex2 (){ a++; printf ("%d", a);//这时会打印1}//Ex_3#include "H.h"void fun_ex3 (){ printf ("%d", a);//这时打印的依然是0，即便先被Ex_2中的fun_ex2（）函数修改过，因为他们 //是两个独立的副本}

lua里没有static关键字。

实例方法可以操作类变量(static变量），也叫类的静态变量。static方法不能操作实例变量。原因很简单，实例变量（或实例方法）是要有类的实例才能访问的，即先要new一个对象，才能访问。而static方法或变量，不需要创建对象，直接通过类名访问，所以它不能访问实例变量。

static在VS2010是0

一、主体不同1、auto变量：是一个C/C++语言存储类型，仅在语句块内部使用。2、static变量：在计算机编程领域指在程序执行前系统就为之静态分配存储空间的一类变量。二、作用域范围不同1、auto变量：初始化可为任何表达式，其特点是当执行流程进入该语句块的时候初始化可为任何表达式。2、static变量：针对某一源文件的以static声明的文件级变量与函数的作用域只限于文件内（只在文件内可见），也即“内部连接”,因而可以用来限定变量的作用域。三、特点不同1、auto变量：具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。2、static变量：在函数内以static声明的变量虽然与自动局部变量的作用域相同，但存储空间是以静态分配而非默认的自动分配方式获取的，因而存储空间所在区域不同。参考资料来源：百度百科-静态变量参考资料来源：百度百科-auto

C语言标准里面，auto和static变量的初始值都没有做要求。auto一般肯定是随机的，他分到那块内存原来是什么，还是什么。static由于是静态的，一般加载的时候都初始化为0（大部分系统是这样的，并不绝对），如果是考试题，可以认为是随机的吧

auto变量会存储在堆栈里面，每次定义的时候会分配存储区，而在用完释放的时候会收回存储区。初始化的时候，如果你不赋初值，auto变量是不确定的。C默认的就是auto类型。所以一般都不加。比如你inta;那a就是auto类型的。static变量会被存储在静态存储区。你可以理解这个存储区为公共的。static变量声明的时候，如果你不初始化，编译器会自动初始化。而且，你用完了，这个变量的退出值会被保存下来。你的例子定义的有问题，可能看不出来，你staticeint ia;就行，别赋初值，你会发现连续运行两次的输出结果不一样，因为第一次运行的值被保存下来了。static一般更主要的是和全局变量配合使用，或者那些大量的存储元素被经常性使用的，比如常量数组，避免不断地存储分配

static变量，每次使用的时候会保留上一次的值，即使重新定义，也不会改变static变量的值。输出结果为 23而auto变量不会，重新定义了，就以重新定义的值为准，输出结果为：22

就是

自动变量(auto变量)和静态变量(static变量)主要有以下几点区别：1、static变量存放在静态存储区，在程序整个运行期间都不释放；而auto变量存放在动态存储区，随着生命周期的结束而立即释放。2、static变量只赋值一次，以后就不用赋值；而auto变量在函数每调用一次都要赋初值。3、如果用户不对static变量赋初值，则默认为0或""；而auto变量为不确定值。扩展资料：auto变量自动变量（Automatic Variable）指的是局部作用域变量，具体来说即是在控制流进入变量作用域时系统自动为其分配存储空间，并在离开作用域时释放空间的一类变量。在许多程序语言中，自动变量与术语“局部变量”（Local Variable）所指的变量实际上是同一种变量，所以通常情况下“自动变量”与“局部变量”是同义的。参考资料来源：百度百科-自动变量

在这两段程序中，在第一个中，当主函数每次调用AddOne（）函数时，所定义的变量ia的初始值都是1；而在第二个中，主函数第一次调用AddOne（）函数时，ia=1，当第二次调用时，ia的初始值就是上一次执行AddOne（）函数后ia的值了；static是静态变量，其作用域是全局。auto变量，作用域只是当前函数。

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。 static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

该变量在全局数据区分配内存； 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）； 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；　 静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的 代码区，全局数据区，堆区，栈区 一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将 static int n; //定义静态全局变量 改为 int n; //定义全局变量 程序照样正常运行。 的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处： 静态全局变量不能被其它文件所用； 其它文件中可以定义相同名字的变量，不会发生冲突；