局部变量

1.classa中的intx是成员变量，类中的doublex是成员函数voidf(doublex)的局部变量，当此成员函数运行结束退出的时候，doublex内存就自动回收了。2.另外一个问题，这两个函数中的doublex分配的内存空间大小相同，都是在栈里分配。

生命周期不同：1、动态变量生命周期仅为函数执行时间周期，该函数调用结束，变量销毁；2、静态变量生命周期延长到整个程序执行结束（不是该函数调用结束，是main函数结束），本次函数调用结束，变量不销毁，再次调用该函数该变量保留上一次的值。

最好写两个不同的变量若是把全局变量覆盖了，是用不了全局变量的。

c和c++不一样的

这个！！这个，根据马克思唯物主义观点！！！凡是绝对的就是错的！！所以这句话是错的！！

如果一个函数内的变量没有特别声明，那么这个变量只在函数内部使用，即为局部变量，如果两个或多个函数公用一个变量（或者说在子程序中也要用到主程序中的变量，注意不是参数），那么可以用global来将它声明为全局变量。全局变量的使用可以减少参数传递，合理利用全局变量可以提高程序执行效率。如果需要用到其他函数的变量，就要利用在主程序与子程序中分别声明全局变量的方式实现变量的传递，否则函数体内使用的都为局部变量。

可以相同！还有疑问请附源码！

就像这样就可以了。不必使用可分配数组。但是，在某些编译器下，这样可能会造成堆栈溢出。（stack overflow）尤其是对 a 较大的情况下。如果出现这种情况，你可以选择：调大堆栈，具体操作取决于你使用的编译器产品。换用 allocatable 数组。

两个问题的原理一样。第一个程序，你用下面的程序做下比较int& ABC() { int n = 5; cout << *n << endl; // 这里打印出n的内存地址，假设是 0001 return n; }void main(){ int x; x=ABC(); // 执行函数，打印0001 cout<<*x<<endl; // 这里打印出n的内存地址， 你会发现打印出来的结果是0002。 int& y = ABC(); // 执行函数，打印0001 cout << *y << endl; // 打印y的地址，你会发现打印的结果一热是0001}第二个程序，使用同样的方法测试下要修改的地方有： display函数中语句改成下面的语句 cout <<"(" <<*real <<"+" <<*imag <<"i)" <<endl;Complex& Complex::operator+(Complex &c2)函数中在return之前加一句 c.display();执行，你会发现，comp3.display() 得到的结果与c.display()得到的结果不同。而p.display()得到的结果越与c.display() 得到的结果是相同的。原理：使用语句 Complex& p 会调用构造函数，因为这样写在编译器看来p只是一个别名（也就是对象的引用），没有分配另外分配内存。而Complex comp3 则不同，在编译器看来，comp3是一个需要特别为其分配另外的内存空间的变量（也就是对象）。利用返回引用类型的函数为p和comp3说白了，对p的赋值就是为局部变量的内存空间其别名p，而对comp3就是将局部变量的值赋给comp3。而由于局部变量在函数执行完毕后会被回收内存空间。因此，p指向的内存被销毁，值就变了。注意：用下面的语句会发生编译错误 error C2530: “p”: 必须初始化引用 int& p；

方法一：《插入》菜单-->《局部变量》方法二：把光标移动子程序下按下组合快捷键 Ctrl+L方法三：复制别的变量或参数，把光标移动子程序下《粘贴》

它们都是同一个x，即定义的全局变量int x。这个x是全局通用的。还有给你点建议，main()最好定义为int型，这是ANSI C++规定的。

全局变量和静态变量差不多，都是程序刚开始就构造，程序结束析构，局部变量一般在某个函数中申明，执行函数时构造，函数退出析构，new的变量，什么时候new什么时候构造，用完后一般自己析构，想在哪儿在哪儿，如果不主动析构，那么程序结束会自己析构，但这样会有内存泄漏

在程序结束前，他一直存在！在函数的多次调用中，静态的局部对象会持续存在并保存他的值！例如：int fun(){ static int coutnt = 0; return ++count;}int main(){ fun(); fun(); cout << fun() << endl;结果会输出3}

看书最好，仔细看定义和例子

更快是什么意思？ （成员变量就是全局变量）

去搜一下js的变量提升。

这个应该是打开注册表；OpenRegistryPath打开之后返回RegistryKey实例进行操作，你不实例化RegistryKey肯定会报错的

很简单啊，存储过程没有返回值，你应该使用自定义函数

不要这么比较好！

文件中变量定义时放在函数体外边,可以简单理解为 全局变量fun1()里面打印的时候 a,b为形参的a,b,当局部变量与全局变量同名的时候,同一作用域中,全局变量被隐藏,使用的是局部变量fun2()函数中修改了全局变量 a,b的值,所以在主函数中打印5,6,3,4

仔细检查一下有么有其他中断使能了确没有使用的情况你看一下汇编就知道了中断向量表在main之前若中断向量表没用被填充 则硬件跳转到未定义的中断向量时就相当于初始化具体我这没环境没法细说

const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。被const修饰的变量称为常类型变量。const的主要作用：（1）可以定义const常量，具有不可变性。 例如：const int Max=100; Max++会产生错误; （2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改； （3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！ （4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错。例如： void f(const int i) { i=10;//error! } （5） 可以节省空间，避免不必要的内存分配。 例如： #define PI 3.14159 //常量宏 const double Pi=3.14159; //此时并未将Pi放入RAM中 ...... double i=Pi; //此时为Pi分配内存，以后不再分配！ double I=PI; //编译期间进行宏替换，分配内存 double j=Pi; //没有内存分配 double J=PI; //再进行宏替换，又一次分配内存！ const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。 （6） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

存取局部变量size加3表示存取变量的字节大小。1和3处同时操作时表示为存取断点，3中size表示存取变量的字节大小，bytes与objects的区别在于单一变量与结构体的不同。局部变量表是一组变量值存储空间，用于存放方法参数和方法内部定义的局部变量。

代码如下:function square(num){ var total = num*num;//局部变量 return total;}var total = 50;//全局变量var number = square(20);alert(total);//结果为50function square(num){ total = num*num;//全局变量 return total;}var total = 50;//全局变量var number = square(20);alert(total);//结果为400这细微的差别就会影响到程序的结果代码如下:body{ color:white; background-color:black;}这些颜色不仅作用于那些直接包含在标签里的内容，还将作用于嵌套在body元素内的所有元素id属性就像一个挂钩，它一头连着文档里的某个元素，另一头连着CSS样式表里的某个样式document.getElementById("purchases")这个调用将返回一个对象，这个对象对应着document对象里的一个独一无二的元素，那个元素的的id属性值为purchases其实，文档中的每个元素都是一个对象。利用DOM提供的方法能够得到任何一个对象。getElementsByTagName返回一个数组，即使整个文档里只有一个元素，也返回一个数组。示例： 代码如下:var items = document.getElementsByTagName("li");for(var i = 0;i<items.length;i++){ alert(typeof items[i]);}显示信息都是objectgetElementByClassName也返回一个具有相同类名的元素数组获取和设置属性getAttributeobject.getAttribute(attribute)注：getAttribute方法不属于document对象，它只能通过元素节点对象调用。setAttributeobject.setAttribute(attribute,value)例子：var shopping = document.getElementById("purchases");shopping.setAttribute("title","a list of goods");

汇编语言定义变量的格式为 【变量名】【变量类型】【数值列表】其中 变量类型有 DB DW DD等，分别表示变量占有的内存空间(依次为1，2，4个字节)如:A DB 1,2,3,4 就定义了名称为A的4个占1个字节的变量，分别是1，2，3，4(严格来说是0001，0010，0011，0100) 保存在系统分配的内存空间中如果是A DW 1,2,3,4则保存的值为(00000001,00000010,00000011,00000100）由于汇编语言是面向机器的语言，没有对函数的定义，函数的实现是通过中断调用的,（一个代码段跳到另外一个代码段) 所以对全局变量和局部变量的体现是通过栈来实现的，即：全局变量保存在数据段中，即伪代码中声明的DATA SEGMENT，任何时刻都能调用。而局部变量则保存在栈段中，是伪代码中声明的STACK SEGMENT，平时不调用，调用中断时把局部变量从栈里取出来...有疑问请追问，望采纳

global X Y Z这就是定义全局变量的关键字~ 定以后变量会变蓝~~我都是在主函数中用global，然后子函数里边调用，免得函数传递了。你具体可以help一下~~

FC，FB内部定义的变量，使用时前面带#的就是局部变量了。

局部变量的作用域最小化只在程序段内或函数内部起作用。根据查询相关信息表明变量的作用域不同，可分为四种：全局变量是作用域为整个应用程序。实例变量是在特定的对象中，随着对象的打开、关闭而创建和删除。局部变量是局部变量的作用范围最小，只在程序段内或函数内部起作用。共享变量是在同种类的对象中共享，和对象的定义相关联，不是某个特定的实例，总是存在。它们的执行优先顺序：局部变量，共享变量，全局变量，实例变量。

以@符号开头。局部变量是用户可自定义的变量，它的作用范围仅在程序内部。在程序中通常用来储存从表中查询到的数据，或当作程序执行过程中暂存变量使用。局部变量必须以“@”开头，而且必须先用DECLARE命令说明后才可使用。其说明形式如下：DECLARE @变量名 变量类型 [@变量名 变量类型?]其中变量类型可以是sql server(WINDOWS平台上强大的数据库平台) 2000支持的所有数据类型，也可以是用户自定义的数据类型。 在Transact-SQL中不能像在一般的程序语言中一样使用“变量=变量值”来给变量赋值。必须使用SELECT或SET命令来设定变量的值，其语法如下：SELECT @局部变量=变量值。SET @局部变量=变量值

singlelist<int> *a;你申明的是一个对象指针，而不是对象，所以需要先new。int main(){singlelist<int> *a = new singlelist<int>();(*a).insert(1,2);a->find(1,3);//存在时提示 不能将参数 2 从“int”转换为“int &”a->output(cout); return 0;}这样就可以了。

使用命令global例如定义全局变量a>>global a注意：1 全局变量列表中各个变量名不能用逗号分隔。 如： global a b c2 全局变量使用前必须再matlab工作空间中申明，如果再具体得函数中用则要 在函数前面申明，否则在该函数中即使用到了该变量，也会被当成局部变量使用。

了解过JVM的都知道，堆和方法区（JDK1.8后叫元空间）是线程共享的 虚拟机栈、程序计数器（PC寄存器）和本地方法栈是线程私有的 虚拟机栈里面存的是一个一个的栈帧，这里的栈帧你也可以理解为此时正在运行的方法，如果此方法调用其他方法的话，在虚拟机栈中就形成了一个个栈帧堆叠的形态，相信读到这里你已经对虚拟机栈的样子有了感觉 接着，我们讨论栈帧（方法 栈帧有五个部分组成 在这里讲栈帧的组成只是为了给不熟悉的同学涨涨知识或者给大家复习一波。 接着，我们回到题目 你会发现方法区中定义的局部变量不就是存在于局部变量表中嘛，而局部变量表有存在于栈帧，栈帧存在于虚拟机栈，那它不就是线程私有的，也就是安全的嘛！ 其实，这里面有些坑，看完下面这四个例子我相信你会恍然大悟！ 2和3发生了逃逸，作用域不止在方法内部了 1和4未发生逃逸，是安全的 我们要明确一个概念： 创建对象不一定在堆空间上创建，还可以在栈上创建 总结：method1和4是安全的，2和3是不安全，所以这道题方法中定义的局部变量不一定线程安全，要看具体使用。

变量的引用 变量和数据都是保存在内存中的 变量和数据是分开存储的 数据保存在内存中某个位置，通过地址来标记 变量保存的是数据的地址，通过地址可以找到数据在内存空间的位置 把变量保存数据地址的过程称为引用 变量的重新赋值修改的是变量中引用数据的内存地址 变量之间的赋值实际是引用的传递 函数参数的传递，本质也是引用的传递 函数的返回值本身也是引用的传递 可变和不可变类型 不可变类型，内存中的数据不允许被修改：数字类型（int,bool,float,complex,long(2,x)、字符串、元组（tuple） 可变类型，内存中的数据可以被修改：列表list、字典dict 无论是可变还是不可变数据类型，通过赋值语句，都会改变变量的引用 Hash函数只能接收不可变数据类型，字典的键也只能是不可变数据类型，字典的value值可以是任意数据类型 局部变量 1.在函数内部定义的变量就是局部变量（作用范围只能是当前函数内部） 2.在函数外部无法直接访问局部变量 3.不同的函数中可以定义同名的局部变量 4.局部变量的生命周期：从定义变量时开始，到函数运行结束 全局变量 1.在所有函数外边定义的变量就是全局变量 2.让所有函数都能访问到，可以作为函数通信的桥梁 3.一般情况下，为了和普通变量的区别，需要加上g_或gl_前缀 4.全局变量一般放在所有函数的最上面 5.在函数内部修改全局变量，必须要加上global关键字，如果不加global只是定义了一个同名的局部变量 函数的多个返回值

stack frame size of：堆栈帧大小栈帧是运行时数据区中虚拟机栈的栈元素，用于支持虚拟机进行方法调用和执行的数据结构，栈帧中储存着局部变量表、操作栈、动态链接、返回地址以及一些额外的附加信息。每个方法从调用到执行完成的过程就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。在编译的时候，栈帧中需要多大的局部变量表以及多深的操作数栈都已经完全确定了，并且存在Class类文件方法表的Code属性中（具体参看JVM系列之Class类文件的结构）。一个线程中方法的调用链可能会很长，很多方法都同时处于执行状态，但对于执行引擎（具体参看JVM系列之字节码解释执行引擎）来说，在活动线程中，只有位于栈顶的栈帧才是有效的，称为当前栈帧（Current Stack Frame），执行引擎运行的所有字节码指令都只针对当前栈帧进行操作。

局部变量的创建肯定是在方法压栈以后，方法压栈创建栈帧包括局部变量表操作数栈，局部变量表存放局部变量

修改：in，out，in_out，temp，这些一般用于子程序，不能用于Q和I映像区。in为主程序调用子程序是需要对子程序的某些参数赋值或者设定时使用，这样的好处在设定的参数不同时，该子程序可以被多次调用。out为子程序调用完毕之后的计算结果的输出，该结果为调用该子程序的程序所需要的结果。in_out兼备以上in和out的功能。temp为子程序内部的变量，不参与输入输出，只参与子程序内部运算。

局部变量表位于方法栈帧中，方法结束时栈帧被回收，其中的所有内容包括局部变量表不再有效。

要在 Python 中查看和打印局部变量和全局变量的列表，可以使用 和 内置函数。这些函数返回一个字典，分别包含当前作用域中所有局部变量和全局变量的名称和值。然后，您可以使用字典的方法循环访问键值对并将其打印到输出中。locals()globals()items()下面是如何使用 and 函数在 Python 中打印局部变量和全局变量的示例：locals()globals()此代码定义函数中的全局变量和局部变量。然后，它使用 and 函数分别打印局部变量和全局变量的列表。运行此代码时，它将输出以下内容：global_varlocal_varlocals()globals()如您所见，该函数返回一个包含局部变量的字典，而该函数返回一个包含全局变量 、 和 的字典。您可以使用此方法在 Python 中查看和打印任何范围内的局部变量和全局变量列表。locals()local_varglobals()__name__global_varprint_vars回答不易望请采纳

你需要弄懂 java 运行的时候 栈 跟堆的区别，栈指的是方法栈 ，每运行一个方法，就会把一个代表方法的对象（想不起来这个对象叫什么了，好像是叫栈帧），push进 方法栈里，当方法结束的时候，pop出方法栈。 这个是运行时候的逻辑。每一个栈帧包含两部分，一部分是局部变量表，一部分是操作数栈，局部变量表，指的是，这个方法里需要操作的一些变量，这个的大小，是编译器编译java类的时候，确定的。操作数栈，代码的运行其实就是这个操作数栈的变化。堆 指的是 对象堆，所有通过new生成的对象 都是在这个堆里。假设 你在一个方法 new 一个对象。首先在 方法里，局部变量表里 会有一个位置A，标记 这个对象的地址（某种意义上就是指针，引用）， 当运行代码的时候， new 操作，会去堆内存申请这个对象大小的内存，同时把申请到的地址，返回给操作数栈，然后把操作数栈的这个引用的值，赋给局部变量表的A，这样，你就在这个方法里 new了一个对象。这个对象的引用在局部变量表里。当方法结束的时候，你只是把 局部变量表里 A位置的值（这个代表的是那个对象的引用），返回给上一个方法，然后方法结束，对应的方法栈出栈，结束方法。在另一个方法里，你依然可以用A位置的值 去找到 你 new出来的那个对象。整体的流程就是这样。上面假设的是引用类型，如果是值类型，上面的流程又不一样。如果你想去搞懂这里面的问题，可以去看一些，深入讲解JVM内部运行原理的书。

西门子临时变量的意思就是：进入子程序后，系统为临时变量分配存储地址，子程序调用结束后，系统不会清空这些分配的地址而是直接给下一个子程序使用。通俗的讲，就像客房一样，系统不会打扫干净给下一个租客，所以下一个租客直接使用的话会有问题。因此，需要程序员遵守这样一样原则：临时变量：先赋值后使用。

在每个程序块的上方有一个表格就是局部变量表，局部变量需要自己创建

这个还真没有认真思考过，想要了解工作内存，可以看看thinking in java或者jvm底层的技术解释，我看不太懂，所以只能推荐这几本书看看

在回答你的问题之前，有必要对变量声明表有一个基本了解。在STEP7中有两种用来定义符号地址的表格形式：符号表（共享符号）和变量声明表（局域符号），其本质都是为了建立绝对地址与符号地址之间的内在联系，但表格针对的对象不同。共享符号是整个程序所使用的共同符号（用于全局符号定义的表为符号表）；而局域符号是某一特定逻辑快（OB、FB、FC等）所使用的临时性标记，只能在特定的逻辑块中进行临时性定义。用于临时性的、局域符号定义的表被称为变量声明表，又称局部变量声明表。局部变量声明表分为参数（输入参数IN、输出参数OUT、输入/输出参数IN_OUT）和局部变量。局部变量又包括静态变量（STAT）和临时变量（TEMP）两种。参数可在调用块（逻辑块，块中的形参）和被调用块（功能FB有自己自动生成的背景数据块DI，而功能FC只能使用共享数据块，提供调用块的形参的实际参数值，与调用块形式参数一一对应，数据类型必需一致）。静态变量和临时变量是仅供逻辑块本身使用数据，不能用作不同程序块之间的数据接口。通过以上分析，我们知道所谓局部变量（包括静态变量和暂态变量）都是指对特定的逻辑块而言的，局部变量只是在它所在的块中有效，离开具体的逻辑块谈上述变量是没有意义的，你不能在其他块中调用利用变量（包括静态变量和暂态变量），这是与共享符号不一致的，共享符号可以被任意块调用。在每个逻辑块的前上面部分就是变量声明表的区域，在变量声明表中，用户声明本块中专用的变量，即局部变量包括块的形参和参数的系统属性。你可以在不同的块中使用相同的局部变量符号不会产生冲突。静态变量（STAT）在PLC运行期间始终被存储。S7 将静态变量定义在背景数据块（针对FB而言，FC和OB无静态变量），当被调用块运行时，能读出或修改静态变量；被调用块结束后，静态变量保留在数据块中；临时变量(TEMP)是一种在块执行时，用来暂时存储数据的变量，这些数据存储在CPU工作存储区的局部数据堆栈（L堆栈）中。临时变量可以在组织快OB、功能FC和功能块FB中使用，当块执行时它们被用来临时存储数据，一旦块执行介绍，堆栈重新分配，临时变量中的数据将丢失。在程序块中，如果在块的变量声明表中有局部变量符号，编程是STEP7软化自动在局部变量名前加一个“#”号，如果要访问与局部变量重名的全局变量（在符号表中定义），则全局变量必须使用双引号（如“Symbol”）

在最下面一行，仔细看。鄙视楼上

局部变量表是一组变量值存储空间，用于存放方法参数和方法内部定义的局部变量。在Java程序被编译成Class文件时，就在方法的Code属性的max_locals数据项中确定了该方法所需要分配的 最大局部变量表的容量。 局部变量表的容量以变量槽（Slot）为最小单位，32位虚拟机中一个Slot可以存放一个32位以内的数据类型（boolean、byte、char、short、int、float、reference和returnAddress八种）。

如图所示，菜单栏——视图——组件——变量表这个就是局部的变量表，当上面程序部分为主程序时，下面显示的变量表就是就是主程序部分的变量表，当上面程序部分为子程序时，下面显示的就是这个子程序部分的变量表。望采纳。。。。。。

for(int k=0; k<10; k++) { fun1(); //调用fun1() i每次自增1，所以一直加到10 fun2(); //每次进入fun2，j被赋为0，所以最后为1 }

全局变量又叫做外部变量，它是可以被多个函数使用的变量。局部变量又叫做内部变量，它只是某个函数内部的变量，只能被这个函数使用（访问）。静态变量分为全局静态变量和局部静态变量。静态变量和普通变量的区别是普通变量随着函数的结束而被释放，静态变量并不释放，一直保存着上一次的结果。

作用域不同；编译时期不同

全局变量就是对于整个程序，都可以调用的变量，但程序里面不一定就只是一个程序，也可能调用其他子程序，只在子程序里面声明并起到作用的就是局部变量，静态变量就是指变量的地址不变，也就是说变量，本质上就是一个寄存器或者存储区，每个存储的位置都是有固定的地址，以便访问，但有时候，并不一定要一个变量就占据一个地址，如果我变量所储存的数据并不需要长期存在，那么在我不需要的时候，就释放那个地址，以便其他程序利用这个地址，我不确定这个就叫自动型变量，我是没有用自动型变量来表示啦。其实也没有必要纠结于他们的表述，你只要知道变量本身就是一个存储空间罢了，并且知道怎样控制变量的作用位置，以及控制变量的存储空间就OK了。

局部变量：栈区局部静态变量：静态区全局变量：静态区的常量区全局静态变量：静态区内存分四个区：静态区，栈区，堆区，代码区

这种问题我建议你上网搜下,在这问效率太低

静态变量是按生命周期大小分的全局 ，局部是按 作用域分的全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，即编译的时候已经决定好了，而局部变量在栈里分配空间全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误局部变量在调用函数时分配，函数结束时释放资源，全局和静态变量在整个函数结束后，释放内存资源。

全部变量就是在整个工程工都可以调用。比如我在一个标准模块中定义了一个全局变量，那么我无论是在窗体1还是窗体2还是其他地方都可以调用它。而局部变量就不行，比如我在某个窗体定义了一个变量，那么这个变量我就只能在这个窗体中使用。 静态变量，就是当我执行完一个过程后，它的值保存下来了。下次再执行这个过程的时候，使用的值就是新值（即上次过程执行完后产生的值）而动态变量就不会保存那个值。当执行完一个过程后，静态的数值变量会初始化为0，静态的字符串变量会初始化为空字符串说得很明白了不知道你了解不？

编译不分配，应该叫启动时分配吧。而且全局也有绝对相对吧，典型的例子就是单例模式，每个单件都是运行时New的。

编译不分配，应该叫启动时分配吧。而且全局也有绝对相对吧，典型的例子就是单例模式，每个单件都是运行时New的。

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文 件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作 用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。 由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可 以避免在其它源文件中引起错误。 从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的 生存期（静态局部变量在程序运行结束释放空间，而普通静态局部变量在函数退出时释放空间）。 把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。 static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明 为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以 外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件 （用static声明的即内部函数，内部函数指只能被本文件的其他函数所调用的函数， 内部函数在C++实际上可以通过类名修饰符访问其他均为外部函数）

简单来说，静态变量就是一个变量名称前有static标注的比如说staticinta;全局变量等于静态变量，他们的差别你可以简单理解成在作用域上的差别，静态变量是在一个函数中的作用域(主函数就是主函数作用域，局部函数就是局部函数的作用域)，而全局函数是写在主函数外的(非局部函数中)空白处的变量，其生命期在主函数之前即产生，随着主函数运行完数据再有系统回收而动态变量与静态变量的差别是例如voida(){staticinti=0;//静态i++;}voidb(){inti=0;//动态i++;}动态变量就是，每一次调用完系统回收内存，下一次调用再分配内存，而静态变量的生命期会在主函数运行结束后内存才会被系统收回

局部变量与其它三个有本质区别。 局部变量，定义在函数内，作用域为定义位置，到所在大括号结束。 每次执行到定义语句的时候，系统为该变量分配内存，当作用域结束后，内存被释放。而另外三个，都是在系统运行时就分配内存，在运行过程中都不会释放，直到程序结束。也就是说，局部变量和其它三个，最明显的区别：1 生命周期不同2 分配时间不同3 分配位置不同。而另外三个，在这几项上是相同的，之间的区别在于作用域。全局变量，作用域为整个项目，不管在哪个文件中，只要声明后都可以使用。静态全局变量，作用域为定义改变量的所在文件。而静态局部变量，作用域与普通局部变量一样，都是定义位置到所在大括号结束。

全局变量静态变量存放在静态全局存储区函数代码区自动变量栈区

就算它不是静态变量，return的值也是它，这就要看局部变量的作用域了。

局部变量与其它三个有本质区别。 局部变量，定义在函数内，作用域为定义位置，到所在大括号结束。 每次执行到定义语句的时候，系统为该变量分配内存，当作用域结束后，内存被释放。而另外三个，都是在系统运行时就分配内存，在运行过程中都不会释放，直到程序结束。也就是说，局部变量和其它三个，最明显的区别：1 生命周期不同2 分配时间不同3 分配位置不同。而另外三个，在这几项上是相同的，之间的区别在于作用域。全局变量，作用域为整个项目，不管在哪个文件中，只要声明后都可以使用。静态全局变量，作用域为定义改变量的所在文件。而静态局部变量，作用域与普通局部变量一样，都是定义位置到所在大括号结束。

1.从作用域看：C++变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。1>全局变量具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包含全局变量定义的源文件需要用extern关键字再次声明这个全局变量。2>静态局部变量具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。3>局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。4>静态全局变量也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。2.从分配内存空间看：1>全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，而局部变量在栈里分配空间2>全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。1)全局变量、静态全局变量以及静态局部变量都会被放在程序的静态数据存储区(全局可见)中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它们与堆变量、堆变量的区别。2)静态变量（包括静态局部变量和静态全局变量）用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。因此static这个说明符在不同的地方所起的作用是不同的。应予以注意。Tips:A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题，因为他们都放在静态数据存储区，全局可见；D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数)E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

fcccccccccccccccccccccccc

一、静态局部变量：1、static类型的内部变量同auto自动变量（即未加 static 声明的局部变量）一样，是某个特定函数的局部变量，即只能在定义该变量的函数内使用该变量，两者作用域相同；两者的不同在于：auto自动变量会随着函数被调用和退出而存在和消失，而static类局部变量不会，它不管其所在的函数是否被调用，都将一直存在；不过，尽管该变量还继续存在，但不能使用它。倘若再次调用定义它的函数时，它又可继续使用，而且保存了前次被调用后留下的值。换言之，static类型的内部变量是一种只能在某个特定函数中使用，但一直占据存储空间的变量。2、函数体内如果在定义静态变量的同时进行了初始化，则以后程序不再进行初始化操作（出现在函数内部的基本类型的的静态变量初始化语句只有在第一次调用才执行）。而对自动变量赋初值是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。3、静态局部变量的初始化表达式必须是一个常量或者常量表达式。即使局部静态变量定义时没有赋初值，系统会自动赋初值0（对数值型变量）或空字符（对字符变量）；静态变量的初始值为0。而对自动变量auto来说，如果不赋初值则它的值将是个不确定的值。4、当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成意外的副作用（主要是变量的作用域造问题成的），因此仍以采用局部静态变量为宜。注：局部静态变量占用内存时间较长，并且可读性差，因此，除非必要，尽量避免使用局部静态变量。二、静态全局变量全局变量(外部变量)的声明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。static静态局部变量和静态全局变量区别这两者的区别在于：1、非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。2、静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。从以上分析可以看出————把局部变量改变为静态变量后是改变了它的存储方式，即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。static静态变量会被放在程序的全局存储区中（即在程序的全局数据区，而不是在堆栈中分配，所以不会导致堆栈溢出），这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。

简单来说，静态变量就是一个变量名称前有static标注的比如说 static int a;全局变量等于静态变量，他们的差别你可以简单理解成在作用域上的差别，静态变量是在一个函数中的作用域（主函数就是主函数作用域，局部函数就是局部函数的作用域），而全局函数是写在主函数外的（非局部函数中）空白处的变量，其生命期在主函数之前即产生，随着主函数运行完数据再有系统回收而动态变量与静态变量的差别是例如void a(){static int i=0; //静态i++;}void b(){ int i=0; //动态i++;}动态变量就是，每一次调用完系统回收内存，下一次调用再分配内存，而静态变量的生命期会在主函数运行结束后内存才会被系统收回

错 如果同一个源文件中，只有一个主函数,外部变量与局部变量同名，则在局部变量的作用范围内，外部变量被“屏蔽”，即它不起作用。所以是错的 8.1.1 局部变量 局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内， 离开该函数后再使用这种变量是非法的。 例如： int f1(int a) /*函数f1*/ { int b,c; …… } a,b,c有效 int f2(int x) /*函数f2*/ { int y,z; …… } x,y,z有效 main() { int m,n; …… } m,n有效 在函数f1内定义了三个变量，a为形参，b,c为一般变量。在 f1的范围内a,b,c有效，或者说a,b,c变量的作用域限于f1内。同理，x,y,z的作用域限于f2内。m,n的作用域限于main函数内。关于局部变量的作用域还要说明以下几点： 1) 主函数中定义的变量也只能在主函数中使用，不能在其它函数中使用。同时，主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数，它与其它函数是平行关系。这一点是与其它语言不同的，应予以注意。 2) 形参变量是属于被调函数的局部变量，实参变量是属于主调函数的局部变量。 3) 允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰，也不会发生混淆。如在前例中，形参和实参的变量名都为n，是完全允许的。 4) 在复合语句中也可定义变量，其作用域只在复合语句范围内。 例如： main() { int s,a; …… { int b; s=a+b; …… /*b作用域*/ } …… /*s,a作用域*/ } main() { int i=2,j=3,k; k=i+j; { int k=8; printf("%d ",k); } printf("%d ",k); } 本程序在main中定义了i,j,k三个变量，其中k未赋初值。而在复合语句内又定义了一个变量k，并赋初值为8。应该注意这两个k不是同一个变量。在复合语句外由main定义的k起作用，而在复合语句内则由在复合语句内定义的k起作用。因此程序第4行的k为main所定义，其值应为5。第7行输出k值，该行在复合语句内，由复合语句内定义的k起作用，其初值为8，故输出值为8，第9行输出i，k值。i是在整个程序中有效的，第7行对i赋值为3，故以输出也为3。而第9行已在复合语句之外，输出的k应为main所定义的k，此k值由第4 行已获得为5，故输出也为5。 8.1.2 全局变量 全局变量也称为外部变量，它是在函数外部定义的变量。它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量，一般应作全局变量说明。 只有在函数内经过说明的全局变量才能使用。全局变量的说明符为extern。但在一个函数之前定义的全局变量，在该函数内使用可不再加以说明。 例如： int a,b; /*外部变量*/ void f1() /*函数f1*/ { …… } float x,y; /*外部变量*/ int fz() /*函数fz*/ { …… } main() /*主函数*/ { …… } 从上例可以看出a、b、x、y 都是在函数外部定义的外部变量，都是全局变量。但x,y 定义在函数f1之后，而在f1内又无对x,y的说明，所以它们在f1内无效。a,b定义在源程序最前面，因此在f1,f2及main内不加说明也可使用。 输入正方体的长宽高l,w,h。求体积及三个面x*y,x*z,y*z的面积。 int s1,s2,s3; int vs( int a,int b,int c) { int v; v=a*b*c; s1=a*b; s2=b*c; s3=a*c; return v; } main() { int v,l,w,h; printf(" input length,width and height "); scanf("%d%d%d",&l,&w,&h); v=vs(l,w,h); printf(" v=%d,s1=%d,s2=%d,s3=%d ",v,s1,s2,s3); } 外部变量与局部变量同名。 int a=3,b=5; /*a,b为外部变量*/ max(int a,int b) /*a,b为外部变量*/ {int c; c=a>b?a:b; return(c); } main() {int a=8; printf("%d ",max(a,b)); } 如果同一个源文件中，外部变量与局部变量同名，则在局部变量的作用范围内，外部变量被“屏蔽”，即它不起作用。

局部变量：局部变量必须以标记@作为前缀，如@age局部变量的使用也是先声明，再赋值 全局变量：全局变量必须以标记@@作为前缀，如@@version全局变量由系统定义和维护，我们只能读取，不能修改全局变量的值

程序的局部变量 全局变量 动态申请数据分别存储在什么地方?量的类别：根据作用域可分为全局变量和局部变量。根据生存周期可分为静态存储方式和动态存储方式，具体地又分为自动的（auto）、静态的（static）、寄存器的（register）、外部的（extern）。静态存储方式是指在程序运行期间分配固定的存储空间的方式，动态存储方式是在程序运行期间根据需要进行动态的分配存储空间的方式。每一个变量均有作用域和存储类别两个属性，这些属性共同用于描述一个变量，这些不同类型的变量与存储位置的关系如下：外部变量（全局变量）、静态外部变量、静态局部变量存储在静态存储区。自动局部变量（局部变量默认为自动局部变量）、函数形参存储在动态存储区，不论是静态存储区还是动态存储区均属于内存中的用户区。但是，寄存器变量是存储在CPU寄存器中的而不是内存中。首先说明一下与作用域相关的几个属性：局部变量：在一个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的，这种类型的变量就称为“局部变量”。全局变量：在函数外定义的变量，可以为本源文件中其它函数所公用，有效范围为从定义变量的位置开始到本源文件结束，这种类型的变量就称为“全局变量”。接下来说明一下与存储类型相关的几个属性：atuo：在声明局部变量时，若不指定 static，默认均是 auto，这类变量都是动态分配存储空间的，数据存储在动态存储区中。static：在声明局部变量时，使用关键字 static 将局部变量指定为“静态局部变量”，这样在函数调用结束后不消失而保留原值，即占用的存储单元不释放，在下一次函数调用时，该变量已有值就是上次函数调用结束时的值。register：在声明动态局部变量或者函数形参时，可将变量声明为register，这样编译系统就会为变量分配一个寄存器而不是内存空间，通过这种方式可提升对某些局部变量频繁调用的程序的性能。（寄存器运算速度远高于内存）extern：用于扩展全局变量的作用域，比如如果函数想引用一个外部变量，但该外部变量在该函数后定义，那么这个函数需要使用 extern 来声明变量，这样才能使用在该函数后面定义的全局变量。此外，extern 还可以在多文件的程序中声明外部变量。由于变量从不同维度划分，形成了多种错综复杂的关系，在学习编程的时候需要重点关注。

第一个for循环中的y<20就是使用了为初始化的局部变量，因为在这之前没有给y赋值

给你个例子吧：public class Test001 { 8. static int a = 27;//全局变量 9. static void test() { 10. boolean flag = false;// flag是局部变量，他的有效范围市整个方法体 11. if (!flag) { 12. int a = 20;// 局部变量a，是必须进行初始化的且只在if块中有效 13. System.out.println("a1=" + a); 14. } 15. // a = 10;// 注意，这一行是会报编译错误：未声明变量a 16. } 17. /** 18. * @param args 19. */ 20. public static void main(String[] args) { 21. System.out.println("a2=" + a); 22. int a = 23;//局部变量a 23. test(); 24. System.out.println("a3=" + a); 25. } 结果为： a2=27 a1=20 a3=23 注意： 1，对于局部变量要先赋值后使用 2，局部变量局部有效，在定义这个变量的代码块也就是在“{}”中有效 3，在重合的有效范围内，不允许两个局部变量发生命名冲突。

静态局部变量是为了再下一次进入其所属函数时,变量的值仍保持上一次的值.而main函数在程序的一次运行中只会运行一次,所以设置静态局部变量就没有意义了.

看一下作用域那块知识，应该获取更多

变量可以在程序中三个地方说明: 函数内部、函数的参数定义中或所有的函数外部。根据所定义位置的不同, 变量可分为局部变量、形式参数和全程变量。从空间角度来看，变量可以分为全局变量和局部变量，而从时间角度来分的 可以有静态存储变量和动态存储变量之分。一。全局变量和局部变量1。局部变量他是 指在函数内部定义的变量 作用域为定义局部变量的函数 也就是说他只能在定义他的函数中使用最值得注意的是 只有在程序执行到定义他的模块时才能生成，一旦执行退出该模块则起变量消失

楼上回答的很好,我也学习了

在子程序中声明的变量叫局部变量，退出子程序时释放内存而在主程序中声明的叫全局变量，在程序运行过程中一致有效。为了节约内存,能用局部变量就不要用全局变量

全局变量和局部变量的区别有：有效范围不一样，内存空间不同，使用区间不同。局部变量只在本函数范围有效，在此函数以外是不能使用这些变量，全局变量的有效范围是从定义变量的位置开始到本源文件结束。局部变量是程序运行到该函数时给该变量分配内存空间，函数结束则释放该内存空间。全局变量是程序运行时事先分配内存空间，当程序结束时释放内存。全局变量作用于整个程序文件，局部变量作用于所属语句块或函数中。使用全局变量程序运行时速度更快一些（因为内存不需要再分配），同样也快不了多少。对于局部变量的名字空间污染，这个在不使用太多变量时是可以避免的。注意事项当全局变量与局部变量重名的时候，起作用的是局部变量，全局变量被屏蔽掉。还可以用extern在函数外对全局变量声明，使全局变量的作用域从声明处到文件的结束，全局变量的优先度低于局部变量。总之，全局变量可以使用，但是全局变量使用时应注意的是尽可能使其名字易于理解。而且不能太短，避免名字空间的污染，避免使用巨大对象的全局变量。在C语言等面向过程语言中，局部变量可以和全局变量重名，但是局部变量会屏蔽全局变量。在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。

public static void main(String args[]){...

局部变量就是只在FB或FC中使用的变量，全局变量就是所有地方都可以使用的变量。局部变量：从字面理解就是只能在局部使用的变量，也就是说只能在特定的函数或子程序中可以访问的变量，它的作用域就只在此函数的内部。对于西门子PLC来说，在FC或FB预先定义一些局部变量，比如在接口数据区，在主程序调用时，可以为输入、输出等接口变量提供参数。全局变量：顾名思义，就是对于整个程序都可以使用的变量，任何地方可以使用的变量，当然前提是你必须要定义变量，它定义在函数或子程序的外部，又可以称之为外部变量。比如对于西门子来说I、Q、M等变量。

结点是用malloc函数动态分配的内存，是分配的堆中的内存当然不会释放掉，而其他的局部变量是在栈中的，当函数结束时就自动释放了，个人观点仅供参考