局部变量

/5首先打开APP Inventor2,切换到逻辑设计界面.2/5然后点击左侧的模块,打开变量抽屉.3/5接着拖出创建全局变量模块.4/5输入变量的名字.5/5最后设置好变量的参数,这个全局变量就建立好了.

一、变量1、变量的表示FANUC系统使用“#”表示变量，例如：#1、#100等。变量根据变量号可以分成四种类型，见下表。变量号 变量类型 功能#0 空变量 该变量总是空，任何值都不能赋给该变量#1~#33 局部变量 局部变量只能用在宏程序中存储数据，例如，运算结果。当断电时，局部变量被初始化为空。调用宏程序时，自变量对局部变量赋值#100~#109#500~#999 公共变量 公共变量在不同的宏程序中的意义相同。当断电时，变量#500~#999的数据保存，即使断电也不会丢失#1000以上 系统变量 系统变量用于读写CNC运行时的各种数据，例如，刀具当前位置和补偿2、关于变量的说明（1）变量引用时，为在程序中使用变量值，指定后跟变量号的地址。当用表达式指定变量时，要把表达式放在括号中，例如，GO X[#1+#2]F#3。式中X后的坐标什即是由#1、#2这两个变量组成的表达式来表示。（2）表达式可以用于指定变量号。此时，表达式必须封闭在括号中，例如，#[#1+#2-12]。注意：1） 宏程序中，方括号用于封闭表达式，圆括号只表示注释内容，使用变量时必须注意，FANUC系统通过参数来切换圆括号和方括号。2） 表达式可以表示变量号和变量。这两者并不一样，例如，X#[#1+#2]并不等于X[#1+#2]。3） 当在程序中定义变量时，小数点可以省略。例如，当定义#1=123；变量#1的实际值是123.000。4） 被引用变量的值根据地址的最小设定单位自动舍入。例如：G00X #1。5） 改变引用的变量值的符号，要把负号放在“#”的前面。例如：G00X-#1。6） 当变量值未定义时，这样的变量成为“空”变量。当引用未定义的变量时，变量及地址字都被忽略。例如，当变量#1的值是0，并且变量#2的值是空时，G00X#1Z#2的执行结果为G00X0。7） 变量#0总是空变量。它不能写，只能读。二、变量的运算1、算术、逻辑运算和运算符（见下表）功能 格式 备注定义 #i=#j 加法 #i=#j+#k 减法 #i=#j-#k 乘法 #i=#j*#k 除法 #i=#j/#k 正弦 #i=SIN[#j] 角度以度指定。90°30"表示90.5°反正弦 #i=ASIN[#j] 余弦 #i=COS[#j] 反余弦 #i=ACOS[#j] 正切 #i=TAN[#j] 反正切 #i=ATAN[#j]/[#k] 平方根 #i=SQRT[#j] 绝对值 #i=ABS[#j] 舍入 #i=ROUND[#j] 上取整 #i=FUP[#j] 下取整 #i=FIX[#j] 自然对数 #i=LN[#j] 指数函数 #i=EXP[#j] 或 #i=#jOR#k 逻辑运算一位一位地按二进制数执行异或 #i=#jXOR#k 与 #i=#jEXP#k 从BCD转为BIN #i=BIN[#j] 用于与PMC的信号交换从BIN转为BCD #i=BCD[#j] 2、关于运算符的说明（1）角度单位函数SIN、COS、ASIN、ACOS、TAN和ATAN的角度单位是度（°）（2）上取整和下取整CNC处理数值运算时，若操作后产生的整数绝对大于原数的绝对值时为上取整；若小于原数的绝对值为下取整。对于负数的处理应小心。例如：假定#1=1.2,并且#2=-1.2。当执行#3=FUP[#1]时，2.0赋给#3。当执行#3=FIX[#1]时，1.0赋给#3。当执行#3=FUP[#2]时 ，-2.0赋给#3。当执行#3=FIX[#2]时，-1.0赋给#3。（3）运算符的优先级按优先的先后顺序依次是函数→乘和除运算（*、∕、AND、MOD）→加和减运算（+、﹣、OR、XOR）。（4）括号嵌套括号用于改变运算优先级。括号最多可以嵌套使用5级，包括函数内部使用的括号。三、功能语句1、无条件转移（GOTO）语句——转移到有顺序号n的程序段格式：GOTOn ；n指行号例如：GOTO1 转移至第一行GOTO#10 转移至变量#10所决定的行2、运算符（见下表）运算符 含义 运算符 含义EQ 等于（＝） GE 大于或等于（≥）NE 不等于（≠） LT 小于（＜）GT 大于（＞） LE 小于或等于（≤）3、条件转移（IF）语句（1）IF[表达式] GOTOn说明：如果指定的条件表达式满足时，转移到标有顺序号n的程序段；如果指定的条件表达式不32满足时，则执行下一个程序段。（2）IF[表达式]THEN说明：如果表达式满足，执行预先决定的宏程序语句，且只执行一个宏程序语句。例如，条件语句IF[#1EQ#2]THEN#3=0表示如果#1和#2的值相同，0赋给#3。4、循环功能（WHILE）语句格式：WHILE[表达式]DOm ；（m=1，2，3）……ENDm说明：在WHILE后指定一个条件表达式，当指定条件满足时，执行从DO到END之间的程序；否则，转到END后的程序段。提示:通过上述介绍,完全可以借助系统提供的二次开发功能定制出个性化的宏程序,例如,可以将例4—23中刀具轨迹路径定制在宏程序中,然后通过G65方式或直接用G代码调用.常见结构的宏程序定制是有效提高编程效率的手段之一.

不能吧,如果要用局部变量，java要求必须被定义为final

是的。static是说明这个东西是属于整个类的而局部变量的作用域只能在他所属的{}之内。不可能是属于类或对象的。所以矛盾，故static不能修饰局部变量 public class Test {public static int a=1;//成员变量，允许public static void main(String[] args) {static int b=1;//错误}}

这里有静态局部变量的详细解释http://baike.baidu.com/view/675642.htm

局部变量的使用范围就在for循环，出了那个循环，变量就失去作用。

这个取决于编译器。但是如果局部变量不在堆栈上，这种编程语言要执行递归会很麻烦。不排除你说的特定的编译器（并且其实它只是提供了类似C的语法的子集，而不是标准的C）可能如你的同事说的那样。

各个数组里的变量是属于局部数组变量，并不代表整个数组。

可以的。- -

局部变量不会受多线程影响成员变量会受到多线程影响多个线程调用的同一个对象的同一个方法：如果方法里无成员变量，不受任何影响如果方法里有成员变量，只有读操作，不受影响，存在赋值操作，有影响

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。ThreadLocal 并不能替代同步机制，两者面向的问题领域不同。1：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；2：而threadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享变量，这样当然不需要对多个线程进行同步了。import java.util.Random;public class ThreadSocpeShareData {static ThreadLocal<Integer> t = new ThreadLocal<Integer>();public static void main(String[] args) {for(int i=0;i<3;i++){new Thread(new Runnable() {

int a=2;//..............//要定义为全局的，参考变量的可见性inline void b(){a += 1;}void main(){b();}不方便使用就不要使用内联的方式好了传递数组参数只能有一维可以不确定大小，其他的必须要给出限定，如果不能确定，就给一个可以满足的大数字就可以了（虽然会浪费）

函数返回指针。本来就是一个比较容易出问题的操作。在霍顿的《VC++ 入门经典》一书中，给出了一个很有代表性的例子，如下：// Ex5_11.cpp#include iostreamusing std::cout;using std::endl;double* treble(double); // Function prototypeint main(void){double num = 5.0; // Test valuedouble* ptr = 0; // Pointer to returned valueptr = treble(num);coutendl"Three times num = "3.0*num;coutendl"Result = "*ptr; // Display 3*numcoutendl;system("pause");return 0;}// Function to treble a value - mark 1double* treble(double data){double result = 0.0;result = 3.0*data;return result;}两个输出语句，一个直接输出3*5=15.另一个在一个函数中进行了乘法运算，也是5*3， 存到result变量中也没有任何问题。返回这个变量的指针，输出时再接触引用。貌似也没有错误。两条输出语句似乎都应该输出15.但事实不是这样。编译 器会抛出[Warning] address of local variable `result" returned 这样一个警告信息。程序运行后的结果也并非是我们预想的那样。第二条输出语句会输出一个不可预见的值。这是怎么回事呢？仔细分析一下，result是作用域在treble函数中的局部变量。当函数执行结束后。变量result会被析构。其原先占用的内存区域已经被系统回收，可以存储任何数据。而返回的指向该地址的指针也失去了其原有的意义。因此我们得到这样一条准则：永远不要从函数中返回局部自动变量的地址。如果你真的需要这样操作。你可以在函数的参数表中传入一个指针变量。然后将需要写入的数据写入到该指针变量指向的地址。由于该指针指向的变量，作用域在函数体 之外。因此不会在函数结束结束时被回收。现在回到我们遇到的问题。时间函数localtime就是一个返回指针的函数。返回值类 型：tm*该如何接收这个返回值？当然是声明一个与之类型相同的变量。于是你会这样写：tm* result;接下来呢？还用问？赋值嘛。是不是这样：result=localtime(....);返回什么类型，当然要给什么类型的变量 赋值。但是这样却发生了我们不想看到的结果。也许你想到了。就是这个指针！返回的指针在函数结束后不再有效。正确的方法可以是：tm result;result = *localtime(....);也可以是：tm* result;*result = *localtime(...);正确的方法的共同特点是在函数结束前，对返回的指针解除引用。然后用这个数值，为变量或指针指向的内存区域赋值。也就是说必须要复制函 数的返回值。因为函数体中变量会被析构。指针是灵活而强大的，避免低级错误，明确基本概念。才能让指针更好的为我们服务。

会!因为要给局部变量开辟空间!但是影响是非常少的,可以无视它,因为一些必要的局部变量,要有就必须要有,没人会考虑局部变量过多的!你使用递归算法,与循环比较就知道了,递归算法要出栈入栈,所以执行效率不如循环!你要问局部变量多会不会影响执行效率,我只能说是了,因为的确会影响效率,但是可以无视它,因为影响是极少的,就算给它一百多个局部变量你也感觉不出来!还有,易语言执行效率本来就非常低,要想程序有高效的执行效率,还是用C/C++这样的语言编写程序吧!

就把lat赋给成员变量geo好了。。。

这句话不准确，如果在main函数里面定义的变量在main函数的作用范围里可以传递给其他函数，如果在除主函数的其他函数的里的局部变量会随着函数的结束而释放空间，所以不能再供别的函数传递参数。而main函数的局部变量时程序运行完后才释放空间的，程序运行完钱可以传递给其他函数

只要在function函数里面用var声明的变量都是局部变量，反之是全局变量

这个题考的就是静态变量，它有个自动变量不具备特点的就是数值在调用结束后，其固有的值并不改变，且被带到下一次调用中去。不像自动变量在下次调用又被重新初始化了。因此，本题第一次y＝2后下次调用函数时y是从2开始而不是初始化的1。

假如一个变量存在于一个函数中,函数调用结束后,普通变量会被释放内存。而静态变量的内存则不会释放。假如后面的程序段要调用该函数，该函数中该静态变量的值可以继续使用。

是GC，不是GG

顶：回答者： Rucky浪

在类的内部，也就是第一层大括号内声明的变量，在C语言中叫全局变量，在C# Java 中叫成员变量，他是对象的属性，可同时赋值也可不赋，有默认值，在new 一个新对象时会在栈内存中申请一块内存 ，在 . 调用时会在堆内存声明一块内存，里面会有你点调用时的属性也就是全局变量（成员变量）调几个有几个，栈中的对象占有的内存 有地址 会指向该对象在堆中声明的内存空间，所以new出来的对象占两块内存。 静态变量是在data segment（ 数据内存）只有一个，直接调用，类名.变量名。方法里声明的变量是局部变量，必须同时赋值，只在栈内存中咱一块空间名和值在一块。 c语言的话得您亲自释放内存，不能释放多，也不能不释放（我没学过，不太清楚），C和Java 里 在方法执行完后new 的对象 会立刻消失，所以指向也消失，原先对象在堆中内存里声明指向的东西也就没用了，垃圾回收器会定期回收这些玩意，您大可不必管!我也是初学，自己的分析，有说错的地方请多多包涵！！！！谢谢！仅供参考！！▼╝

在类的内部，也就是第一层大括号内声明的变量，在C语言中叫全局变量，在C# Java 中叫成员变量，他是对象的属性，可同时赋值也可不赋，有默认值，在new 一个新对象时会在栈内存中申请一块内存 ，在 . 调用时会在堆内存声明一块内存，里面会有你点调用时的属性也就是全局变量（成员变量）调几个有几个，栈中的对象占有的内存 有地址 会指向该对象在堆中声明的内存空间，所以new出来的对象占两块内存。 静态变量是在data segment（ 数据内存）只有一个，直接调用，类名.变量名。方法里声明的变量是局部变量，必须同时赋值，只在栈内存中咱一块空间名和值在一块。 c语言的话得您亲自释放内存，不能释放多，也不能不释放（我没学过，不太清楚），C和Java 里 在方法执行完后new 的对象 会立刻消失，所以指向也消失，原先对象在堆中内存里声明指向的东西也就没用了，垃圾回收器会定期回收这些玩意，您大可不必管!我也是初学，自己的分析，有说错的地方请多多包涵！！！！谢谢！仅供参考！！

　　ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。　　对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。　　ThreadLocal 并不能替代同步机制，两者面向的问题领域不同。　　1：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；　　2：而threadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享变量，这样当然不需要对多个线程进行同步了。　　import java.util.Random;public class ThreadSocpeShareData { static ThreadLocal<Integer> t = new ThreadLocal<Integer>(); public static void main(String[] args) { for(int i=0;i<3;i++){ new Thread(new Runnable() { @Override public void run() { int data = new Random().nextInt(); System.out.println(Thread.currentThread().getName() +" has put "+ data); t.set(data); MyThreadScopeData.getInstance().setName("name" + data); MyThreadScopeData.getInstance().setAge("age"+data); new A().get(); new B().get(); } }).start(); } } static class A{ public void get(){ int data = t.get(); MyThreadScopeData myData = MyThreadScopeData.getInstance(); System.out.println("A " + Thread.currentThread().getName() +" "+ data + myData.getAge() + myData.getName() /*ms.getName()*/); } } static class B{ public void get(){ int data = t.get(); System.out.println("B " + Thread.currentThread().getName()+ " "+ data); } }}class MyThreadScopeData{ private MyThreadScopeData(){} private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>(); public static MyThreadScopeData getInstance(){ MyThreadScopeData instance = map.get(); if(instance == null){ instance = new MyThreadScopeData(); map.set(instance); } return instance; }private String name; private String age; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; }}　　事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的，而是Thread线程对象自身保存。当用户调用ThreadLocal对象的set(Object o)时，该方法则通过Thread.currentThread()获取当前线程，将变量存入Thread中的一个Map内，而Map的Key就是当前的ThreadLocal实例。请看源码，这是最主要的两个函数，能看出ThreadLocal与Thread的调用关系：　　public void set(T value) {　　　　Thread t = Thread.currentThread(); 　　　　　ThreadLocalMap map = getMap(t); 　if (map != null) 　　　　　　　map.set(this, value); 　else　　　　　　createMap(t, value); 　} 　ThreadLocalMap getMap(Thread t) { 　return t.threadLocals; 　}　　　public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } ThreadLocalMap getMap(Thread t) { return t.threadLocals; }　　具体可以看看里面的源码，不过有一点是可以证实的，就是Threadlocal中 创建的线程副本，可以不调用remove来做清理工作，因为jvm在发现线程的调佣不再使用时，会进行自动的垃圾回收操作，我以前写程序在使用Threadlocal时却是经常的进行使用完成之后的清理工作。（防止占用内存，如果创建的副本数量不是太多的话，可以让虚拟机自动来清除）

这样就可以了啊！VI关闭，控件直接初始化为默认值，看图：忘记在中间加个加1的模块了，加上就好了！

第一个回复是正确的。把加1还有计数器这个控件（改名字为计数器）放出来，然后在程序里添加局部变量，局部变量就可以显示为计数器。并且可以实现功能。谢谢安大熊的回复。利用局部变量写一个计数器，每当VI运行一次计数器

第一个回复是正确的。把加1还有计数器这个控件（改名字为计数器）放出来，然后在程序里添加局部变量，局部变量就可以显示为计数器。并且可以实现功能。谢谢安大熊的回复。

这么和你说吧，这个就是闭包的最经典的例子，为什么counter不会被清0呢，首先楼主应该明白全局变量的概念，当全局变量被定义以后，不管执行什么运算，全局变量最后的结果都会被保存在内存中不会被初始化对吧。然后我们来看看这个闭包，在add方法中，我们先对counter赋了一个初始值0，然后return了一个function ，此时这个function相当于add方法的子方法，此时由于counter在子方法外，所以相对于子方法，counter这个变量是一个全局变量，所以在子方法中，counter会被保存在内存中，不会被垃圾回收机制清空，而子方法依赖于父方法add，因此导致父方法中的counter也不会被垃圾回收机制从内存中清除，这样就使得counter会相当于一个全局变量一直递增，这样说你明白了吗。

是可以相同的，比如全局变量int a;在子程序中也建立变量int a;这在语法上是允许的但要搞清楚，局部变量虽然使用同全局变量相同名字，但它是另外开设的变量，可以理解成名称是不同的(编译程序会在子程序中仅对应局部变量，而不会对应全局变量)

在局部变量前面加关键字static进行声明，该变量就是一个static局部变量。static局部变量的特点是它位于静态存贮区，在函数调用结束后，它的值仍然存在，并可能影响到下一次调用的过程。我认为你的理解是把函数好程序弄混淆了，本题中是说“该变量的值在程序执行结束时被释放”。程序结束了肯定是释放了。

什么变量都不可以重复定义。写在函数中的自动变量声明或定义，在进入这个函数时声明或定义，退出这个函数时自动撤消了，所以根本不存在“重复定义”的问题。第二个问题，用static修饰声明的变量不是自动变量，叫“静态变量”

静态局部变量相当于全局变量（只是只有在这个函数中能访问，但是生命周期是和全局变量差不多的），函数退出之后变量还在，而且只在第一次进入的时候做初始化，以后会跳过初始化语句，保留原来的值（也就是说，如果item是static的，那么只有在第...

静态局部变量相当于全局变量（只是只有在这个函数中能访问，但是生命周期是和全局变量差不多的），函数退出之后变量还在，而且只在第一次进入的时候做初始化，以后会跳过初始化语句，保留原来的值（也就是说，如果item是static的，那么只有在第...

在sql语句中为局部变量赋值的关键词是declare和set。用declare和set语句为局部变量赋值。SET局部变量名=表达式SELECT局部变量名=表达式，SELECT(赋值，查询(SQL))使用SELECT语句为局部变量赋值。查询语句。

在窗口的下面有一行标签页，一般有layout，open,functionlist,eventlist,declare global variables等等，这个是可以定制的。如果在标签页里看不到的话，可以在view菜单中找，其中一个variable项单击，系统会出现个窗口（拖动标签页可以拖放窗口），在窗口的上面有一个变量类型的下拉选择框，包含的类型如下：Global Variables:声明全局变量Shared Variables:声明共享变量Instance Variables:声明实例变量Global External Functions:声明全局外部函数Local External Functions:声明本地外部函数局部变量就是在窗口内部对象的script中定义的变量。至于这几种变量的定义方式都是一样。string ls_str,ls_arr[]integer li_ilong ll_lendec{2} ldec_i

全局变量就是所有地方都可以用；局部变量，在一个函数或者局部循环内部使用的临时变量

我的天啊，你知道这么多名词应该学过编程吧要么百度一下，不就又比较全面精确的解释算了，我复制几个吧变量分为局部与全局，局部变量又可称之为内部变量。由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。一个局部变量在被其它对象引用时，会是一个空值。但全局变量却不会出现这种情况成员变量是指定维度的成员变量，用于标识某个维度成员语言无关的通用定义：与程序有着相同生命周期（英语：Object lifetime）的变量；C族语言特有的定义：以static存储类声明的变量。

类变量、实例变量、局部变量类变量是类中独立于方法之外的变量，用static 修饰。实例变量也是类中独立于方法之外的变量，不过没有static修饰。局部变量是类的方法中的变量。

类变量就是在类中声明的变量，成员变量就是类变量，实力变量就是方法中的变量，也就是局部变量，其实就是这样地。

嵌套函数在执行时从父作用域查找变量，而不是在定义时查找。编译函数体，验证自由变量（未通过赋值在函数本身中定义），然后将闭包单元绑定到函数，代码使用索引引用每个单元格。pet_function因此具有一个自由变量（cage），然后将其通过一个闭合单元引用，索引为0的闭合本身指向局部变get_petters功能。当您实际调用该函数时，该闭包将用于查看函数调用时cage周围范围的值。这就是问题所在。当您调用函数时，该函数已经完成计算结果。将在在执行过程中的一些点局部变量分配各的，和字符串，但在功能的结束，包含了最后一个值。

全局变量

变量的范围确定了能够知晓该变量存在的那部分代码。在一个过程内部声明变量时，只有过程内部的代码才能访问或改变那个变量的值；它有一个范围，对该过程来说是局部的。但是，有时需要使用具有更大范围的变量，例如这样一个变量，其值对于同一模块内的所有过程都有效，甚至对于整个应用程序的所有过程都有效。Visual Basic 允许在声明变量时指定它的范围.在不同的范围内也可有同名的变量。例如，可有名为 Temp 的公用变量，然后在过程中声明名为 Temp 的局部变量。在过程内通过引用名字 Temp 来访问局部变量；而在过程外则通过引用名字 Temp 来访问公用变量。通过用模块名限定模块级变量就可在过程内访问这样的变量。过程级变量只有在声明它们的过程中才能被识别。也称它们为局部变量。用 Dim 或者 Static 关键字来声明它们。例如：Dim intTemp As Integer— 或者 —Static intPermanent As Integer在整个应用程序运行时，用 Static 声明的局部变量中的值一直存在，而用 Dim 声明的变量只在过程执行期间才存在。对任何临时计算来说，局部变量是最佳选择。例如，可以建立十来个不同的过程，每个过程都包含称作 intTemp 的变量。只要每个 intTemp 都声明为局部变量，那么每个过程只识别它自己的 intTemp 版本。任何一个过程都能够改变它自己的局部的 intTemp 变量的值，而不会影响别的过程中的 intTemp 变量。为了使模块级的变量在其它模块中也有效，用 Public 关键字声明变量。公用变量中的值可用于应用程序的所有过程。和所有模块级变量一样，也在模块顶部的声明段来声明公用变量。例如：Public intTemp As Integer注意 不能在过程中声明公用变量，只能在模块的声明段中声明公用变量。

局部变量只能本VI使用。全局变量可以被别的VI，甚至别的应用调用。调用路径是通过变量所属组的保存路径来完成的。如果单个VI解决了你的问题，就没必要用全局变量。

变量可分为两类： 环境变量又被称为全局变量，可以在创建的shell以及任意子进程shell中使用。局部变量只能在创建的shell脚本中使用。 环境变量用于定义Shell的运行环境，保证Shell命令的正确执行，Shell通过环境变量来确定登录的用户名、登录目录等。所有的环境变量都是系统的全局变量，可用于所有的子进程中。 环境变量可以在命令行中设置，但用户退出后这些变量值也会随之丢失，所以最好在下面的文件或者目录中配置，每次用户登录都将会被初始化： 环境变量可用在任意的Shell进程中，环境变量名一般大写，并且是已经使用export内置命令进行了导出。比如HOME、PATH、UID、USER等，在用户登陆之前已经本/bin/login程序设置好了。 下面是常见的系统环境变量： 更多详情请通过env命令查看： 如果设置想自己设置环境变量，有临时生效和永久生效两种： 在.bash_profile或者/etc/profile文件中使用export导出变量，然后使用"."或者source命令使其生效。 系统的内置的环境变量或者自定义的环境变量可以通过echo或者printf进行打印： 对于有哪些变量使用env（上述已经说过）或者set命令： 使用unset取消变量，不要随意使用，尤其是系统环境变量： 局部变量的生命周期是当前的Shell脚本，如果启动另一个Shell进程或者退出当前Shell进程，变量就会丢失。 局部变量又三种定义方式： 变量名一般以字母、数字、下划线组成，其中以字母开头。 为了更好的说明上面定义的三种方式，即不加引号、加单引号、加双引号的区别，以下面的例子说明： 上述a、b、c输出为： 在上面的基础上如果变成下面的例子： a、b、c的输出有时什么呢？ 从上面的例子中可以看出第一种定义a变量的方式（不带引号），内容一般为简单连续的数字、字符串等；第二种定义b变量的方式（单引号）所见即所得，内容原样输出；第三种定义c变量的方式（双引号），输出变量时引号中变量会经过解析后输出。 所以，脚本中单纯的数字可以不使用引号，但是其它普通字符串尽量使用双引号。 系列教程： Python虚拟环境搭建-学习视频教程-腾讯课堂ke.qq.com

java易混淆概念之类变量、实例变量、局部变量类变量、实例变量、局部变量类变量是类中独立于方法之外的变量，用static 修饰。实例变量也是类中独立于方法之外的变量，不过没有static修饰。局部变量是类的方法中的变量。看下面的伪代码说明：public class Variable{ static int allClicks=0; //类变量 String str="hello world"; //实例变量 public void method(){ int i =0; //局部变量 }}实例变量也称为:“域”，“成员变量”，在实体类或数据类中被称为“属性”或“字段”。当实例变量可以改变时，被称为对象的状态。2. final用于常量的声明，规范要求常量的变量名是大写的。3. statci 在java 里面用于对类方法和属性进行修饰，其作用是什么呢？有两种情况是non-static无法做到的，这时你就要使用statice。第一种：你希望不论产生了多少个对象，或不存在任何对象的情形下，那些特定数据的存储空间都只有一份；第二种：你希望某个函数不要和class object绑在一起。即使没有产生任何object，外界还是可以调用其static函数，或是取用其static data。

窗体级变量和全局变量均在顶部进行声明。而局部变量在Sub或者Function内部进行定义。全局变量和窗体级变量的区别是，窗体级变量在窗体顶部进行声明，而全局变量在标准模块的顶部进行声明。而最关键的是，窗体级变量定义的时候使用的是Public还是Private，如果使用Public，那么这个变量不仅仅可以在闯体内使用，并且可加前缀被其他模块进行调用，也就是常称谓的对外可见。而Private定义的窗体级变量，仅仅只能用于本窗体，无法被外界进行调用（也就是对外不可见）。而局部变量只能用Dim进行定义。这是比较基本的几个区别。给你个实例：Public x as stringPrivate y as stringPrivate Sub Form_Load() Dim z as integerENd subx,y均称为窗体级变量，而Z是局部变量，而x,y两者的主要区别就在于，x可以通过Form1.x的方法被其他窗体调用，而y则不可以。

@一个@是局部变量,两个是系统变量.

局部变量包括自动变量和静态局部变量,静态局部变量是编译器在数据段或者bss段分配的,如果没有初值则一般放在bss段,由程序加载器将其内存清零;而自动变量是在栈上,函数调用结束时,栈会被回收,自动变量也就消亡了,再次分配给其他自动变量时不会自动清零,所以如果没有初值就是垃圾数据。举个例子:static int a=10;那么你的可执行文件里面就会有四个字节里面存放了数字10; { int a=10;}这样定义的话你的可执行文件中并没有存放数字10的四个字节,而是类似如下代码:sub $4,%esp;mov $0xa,(%esp);意思是再栈上分配四个字节(不清零),然后把数字10放进去。不知道我说清楚了没,不懂的话再问我。

这你也问，牛

全局变量和局部变量的作用域不同，在函数中出现变量名同全局变量同名时以函数中的变量作为操作数，当函数返回时，函数中的变量即结束了生存期，变量值为全局变量的值。编译器是以栈结构保存信息以实现的。inti=5;main(){printf（"%d ",i);add()printf("%d ",i);}voidadd(){inti=10;printf("%d ",i);}结果：5105 一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。-程序结束后有系统释放4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放5、程序代码区—存放函数体的二进制代码。 二、例子程序这是一个前辈写的，非常详细 //main.cpp inta=0;全局初始化区 char*p1;全局未初始化区 main() { intb;//栈 chars[]="abc";//栈 char*p2;//栈 char*p3="123456";123456";//在常量区，p3在栈上。 staticintc=0；//全局（静态）初始化区 p1=(char*)malloc(10); p2=(char*)malloc(20); //分配得来得10和20字节的区域就在堆区。 strcpy(p1,"123456");//123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 }

Public a as string"全局变量sub aa()dim c as long"局部变量end sub

简单说吧，书上说的太复杂了：全局变量就是在方法外定义的变量，这种变量可以在类中的任何地方使用；而局部变量就是方法内定义的变量，仅仅可以在方法内使用；

推荐阅读http://www.cyuyan.com.cn/viewnews-21/

C语言存储类型有四种，分别是auto, extern, register, static。1、局部变量，在没有任何修饰的情况下，存储类型为auto。 即定义局部变量int a;和auto int a;是相同的。auto为缺省类型。 2、静态局部变量。静态局部变量是指有static修饰的局部变量，比如static int a;其存储类型为static。3、寄存器变量。是指用register修饰的变量，比如：register int a;其存储类型为register。

publicclasstest{privatestringname;//成员变量，也是全局变量publicvoidchangename(){stringn="tomoya";//n就是局部变量name=n;}}总的来说，定义在类里的，也就是name那个位置，就是成员变量，在java里全局变量和成员变量是一个意思。定义在方法里或域里就叫做局部变量，所谓域就是{}里面，比如publicvoidshow(){intb=2;//局部变量if(true){inta=1;//局部变量}//这个位置访问a，无效}//这个位置，或其他方法里访问b，无效他的作用范围：局部变量离开了他的域{}就无效成员变量的范围依赖他的访问修饰符，什么是访问修饰符呢？publicprotectedprivate默认，你定义时不给他访问修饰符就是默认至于他们的范围，请自行查资料，不动脑筋是不行滴这种东西确实如1l所说的，再烂的书也会有介绍

就是变量的生存周期不同全局变量在程序退出时才释放内存局部变量在窗体关闭或者函数关闭时就释放内存

窗体级变量和全局变量均在顶部进行声明。而局部变量在Sub或者Function内部进行定义。全局变量和窗体级变量的区别是，窗体级变量在窗体顶部进行声明，而全局变量在标准模块的顶部进行声明。而最关键的是，窗体级变量定义的时候使用的是Public还是Private，如果使用Public，那么这个变量不仅仅可以在闯体内使用，并且可加前缀被其他模块进行调用，也就是常称谓的对外可见。而Private定义的窗体级变量，仅仅只能用于本窗体，无法被外界进行调用（也就是对外不可见）。而局部变量只能用Dim进行定义。这是比较基本的几个区别。给你个实例：Public x as stringPrivate y as stringPrivate Sub Form_Load() Dim z as integerENd subx,y均称为窗体级变量，而Z是局部变量，而x,y两者的主要区别就在于，x可以通过Form1.x的方法被其他窗体调用，而y则不可以。

　　成员变量是类的一个组成部分，和类的方法处于同一级别；　　而局部变量是为了让方法/功能正常运行设立的一些临时存储单元，是专门服务于方法的。　　从概念上说，两者是完全没有关系的，　　但从应用上说，成员变量可能临时做为局部变量存在，而局部变量也可能依赖或者干脆引用成员变量完成工作。　　打个不太合适的比方，你的主机是一个类，你的CPU、硬盘、内存等等必然和你主机同时存在，同时消失的就是成员变量。　　而你机器里装的软件就是这个类所能提供出的方法，局部变量就是组成这些软件的文件。

global 是定义全局变量的 局部变量是单独某个函数下的变量 在其他函数中不能使用该数值

变量：可以表达变化数据的标示量。自变量：函数中引起函数值发生变化(也可能不变)的变量，java中没有这个定义。局部变量：编程语言中的局部变量是指作用在指定的局部程序段(可以是方法体，程序段等)的变量。本地变量：没有听说过，可能就是局部变量吧！成员变量：类或者对象的属性变量。static修饰的为类属性。

在Linux系统中使用C/C++进行多线程编程时，我们遇到最多的就是对同一变量的多线程读写问题，大多情况下遇到这类问题都是通过锁机制来处理，但这对程序的性能带来了很大的影响，当然对于那些系统原生支持原子操作的数据类型来说，我们可以使用原子操作来处理，这能对程序的性能会得到一定的提高。那么对于那些系统不支持原子操作的自定义数据类型，在不使用锁的情况下如何做到线程安全呢？本文将从线程局部存储方面，简单讲解处理这一类线程安全问题的方法。一、数据类型 在C/C++程序中常存在全局变量、函数内定义的静态变量以及局部变量，对于局部变量来说，其不存在线程安全问题，因此不在本文讨论的范围之内。全局变量和函数内定义的静态变量，是同一进程中各个线程都可以访问的共享变量，因此它们存在多线程读写问题。在一个线程中修改了变量中的内容，其他线程都能感知并且能读取已更改过的内容，这对数据交换来说是非常快捷的，但是由于多线程的存在，对于同一个变量可能存在两个或两个以上的线程同时修改变量所在的内存内容，同时又存在多个线程在变量在修改的时去读取该内存值，如果没有使用相应的同步机制来保护该内存的话，那么所读取到的数据将是不可预知的，甚至可能导致程序崩溃。 如果需要在一个线程内部的各个函数调用都能访问、但其它线程不能访问的变量，这就需要新的机制来实现，我们称之为Static memory local to a thread (线程局部静态变量)，同时也可称之为线程特有数据（TSD: Thread-Specific Data）或者线程局部存储（TLS: Thread-Local Storage）。这一类型的数据，在程序中每个线程都会分别维护一份变量的副本(copy)，并且长期存在于该线程中，对此类变量的操作不影响其他线程。如下图：二、一次性初始化 在讲解线程特有数据之前，先让我们来了解一下一次性初始化。多线程程序有时有这样的需求：不管创建多少个线程，有些数据的初始化只能发生一次。列如：在C++程序中某个类在整个进程的生命周期内只能存在一个实例对象，在多线程的情况下，为了能让该对象能够安全的初始化，一次性初始化机制就显得尤为重要了。——在设计模式中这种实现常常被称之为单例模式（Singleton）。Linux中提供了如下函数来实现一次性初始化：#include <pthread.h>// Returns 0 on success, or a positive error number on errorint pthread_once (pthread_once_t *once_control, void (*init) (void));利用参数once_control的状态，函数pthread_once()可以确保无论有多少个线程调用多少次该函数，也只会执行一次由init所指向的由调用者定义的函数。init所指向的函数没有任何参数，形式如下：void init (void){ // some variables initializtion in here}另外，参数once_control必须是pthread_once_t类型变量的指针，指向初始化为PTHRAD_ONCE_INIT的静态变量。在C++0x以后提供了类似功能的函数std::call_once ()，用法与该函数类似。使用实例请参考https://github.com/ApusApp/Swift/blob/master/swift/base/singleton.hpp实现。三、线程局部数据API 在Linux中提供了如下函数来对线程局部数据进行操作#include <pthread.h>// Returns 0 on success, or a positive error number on errorint pthread_key_create (pthread_key_t *key, void (*destructor)(void *));// Returns 0 on success, or a positive error number on errorint pthread_key_delete (pthread_key_t key);// Returns 0 on success, or a positive error number on errorint pthread_setspecific (pthread_key_t key, const void *value);// Returns pointer, or NULL if no thread-specific data is associated with keyvoid *pthread_getspecific (pthread_key_t key);函数pthread_key_create()为线程局部数据创建一个新键，并通过key指向新创建的键缓冲区。因为所有线程都可以使用返回的新键，所以参数key可以是一个全局变量（在C++多线程编程中一般不使用全局变量，而是使用单独的类对线程局部数据进行封装，每个变量使用一个独立的pthread_key_t）。destructor所指向的是一个自定义的函数，其格式如下：void Dest (void *value){ // Release storage pointed to by "value"}只要线程终止时与key关联的值不为NULL，则destructor所指的函数将会自动被调用。如果一个线程中有多个线程局部存储变量，那么对各个变量所对应的destructor函数的调用顺序是不确定的，因此，每个变量的destructor函数的设计应该相互独立。函数pthread_key_delete()并不检查当前是否有线程正在使用该线程局部数据变量，也不会调用清理函数destructor，而只是将其释放以供下一次调用pthread_key_create()使用。在Linux线程中，它还会将与之相关的线程数据项设置为NULL。由于系统对每个进程中pthread_key_t类型的个数是有限制的，所以进程中并不能创建无限个的pthread_key_t变量。Linux中可以通过PTHREAD_KEY_MAX（定义于limits.h文件中）或者系统调用sysconf(_SC_THREAD_KEYS_MAX)来确定当前系统最多支持多少个键。Linux中默认是1024个键，这对于大多数程序来说已经足够了。如果一个线程中有多个线程局部存储变量，通常可以将这些变量封装到一个数据结构中，然后使封装后的数据结构与一个线程局部变量相关联，这样就能减少对键值的使用。函数pthread_setspecific()用于将value的副本存储于一数据结构中，并将其与调用线程以及key相关联。参数value通常指向由调用者分配的一块内存，当线程终止时，会将该指针作为参数传递给与key相关联的destructor函数。当线程被创建时，会将所有的线程局部存储变量初始化为NULL，因此第一次使用此类变量前必须先调用pthread_getspecific()函数来确认是否已经于对应的key相关联，如果没有，那么pthread_getspecific()会分配一块内存并通过pthread_setspecific()函数保存指向该内存块的指针。参数value的值也可以不是一个指向调用者分配的内存区域，而是任何可以强制转换为void*的变量值，在这种情况下，先前的pthread_key_create()函数应将参数destructor设置为NULL函数pthread_getspecific()正好与pthread_setspecific()相反，其是将pthread_setspecific()设置的value取出。在使用取出的值前最好是将void*转换成原始数据类型的指针。四、深入理解线程局部存储机制 1. 深入理解线程局部存储的实现有助于对其API的使用。在典型的实现中包含以下数组：一个全局（进程级别）的数组，用于存放线程局部存储的键值信息pthread_key_create()返回的pthread_key_t类型值只是对全局数组的索引，该全局数组标记为pthread_keys，其格式大概如下：数组的每个元素都是一个包含两个字段的结构，第一个字段标记该数组元素是否在用，第二个字段用于存放针对此键、线程局部存储变的解构函数的一个副本，即destructor函数。每个线程还包含一个数组，存有为每个线程分配的线程特有数据块的指针（通过调用pthread_setspecific()函数来存储的指针，即参数中的value） 2. 在常见的存储pthread_setspecific()函数参数value的实现中，大多数都类似于下图的实现。图中假设pthread_keys[1]分配给func1()函数，pthread API为每个函数维护指向线程局部存储数据块的一个指针数组，其中每个数组元素都与图线程局部数据键的实现(上图)中的全局pthread_keys中元素一一对应。五、总结 使用全局变量或者静态变量是导致多线程编程中非线程安全的常见原因。在多线程程序中，保障非线程安全的常用手段之一是使用互斥锁来做保护，这种方法带来了并发性能下降，同时也只能有一个线程对数据进行读写。如果程序中能避免使用全局变量或静态变量，那么这些程序就是线程安全的，性能也可以得到很大的提升。如果有些数据只能有一个线程可以访问，那么这一类数据就可以使用线程局部存储机制来处理，虽然使用这种机制会给程序执行效率上带来一定的影响，但对于使用锁机制来说，这些性能影响将可以忽略。Linux C++的线程局部存储简单实现可参考https://github.com/ApusApp/Swift/blob/master/swift/base/threadlocal.h，更详细且高效的实现可参考Facebook的folly库中的ThreadLocal实现。更高性能的线程局部存储机制就是使用__thread，这将在下一节中讨论。

静态局部变量和局部变量个人感觉提高性能不会太大。理由如下：voidf(){staticinta=2;}//拿windows平台来说,此时的a将被分配在pe区段的data段，初始化在vc的crt函数中进行。

不太同意楼上观点，的确，当函数结束时会释放局部变量，但是，当你将它的地址返回时，系统就不会释放该变量。可参考链表的创建过程，我们都是在子函数中创建空链表，然后将其地址返回，如果返回了该地址，程序还释放局部变量，那么，空链表岂不是无法创建？而且楼主的那个例2我编译了，可以正常返回的啊…

这个不一定。编译的时候当然都会优先使用寄存器，但如果当前组的寄存器用尽（例如参数太多）就会在指定存储域（默认为内部RAM的直接寻址空间）内分配。

register 只是建议编译器把这个局部变量放到寄存器中而不要放到栈中，但最终是否这样做是由编译器决定的，声明为register的变量不一定会放到寄存器中，而没有声明为register的变量也有可能被放到寄存器中。

我现在能想起来的一个，就是 void f(char s[20]) { char t[20]; } 中，s与t就不同，t是char [20]类型，而s是char *类型，也就是数组形参，注定要被转换。你的意思，当然可以，你可以去做试验。一般都是auto的，参数也在调用时，被推入堆栈。但如果你非要将其声明为static的话，VC会给个警告，而不是错误。它说，static的形参，不是种好的用法。为什么？我觉得因为本来为多处调用的函数，就应该是每次参数都是不同的，而static让它成为下次内容不变的，而函数调用发生的那一瞬间，其实，又是改变了该值，那你把它声明成能记住上次的值（因些需要放在全局的某个地方）又有何意义呢？请注意，static量，还需要区别对待是否是第一次引用到该对象，如果是，还要初始化，否则还要沿用上次的内容，而调用处，它的必将改变，又与沿用的语义是矛盾的，这会带来不必要的开销。

1、其中的s严格意义上讲是不是应该叫形参，同样也是局部变量上面这句是对的。下面这句是错的，不能简写，本来yanshi函数带一个参数，如果简写为yanshi()就会认为不带参数的函数，而又没有定义不带参数的yanshi函数，所以会报错2、假如s=0，是不是可以省略不写，简写成yanshi（）；

第一从变量角度看，实参性质是根据形参来变化的，如果当前的实参是被局部变量的形参调用，这时的实参是局部变量；如果当前的实参是被全局变量调用，这时的实参就是全局变量。第二从内存角度看，实参同样是内存的一块区域，按照内存四区（栈、堆、文字常量区、代码区）的说法，实参一般情况下（除了用函数作为实参）应该在文字常量，文字常量区的数据，局部或全局都可以调用，因为你程序运行时，编译读取是在栈和堆中运行的，形参需要实际数据（实参）参与运算时，就会到文字常量区读取或调用。以上是个人总结，仅供参考

这句话哪儿错了?

C语言全局变量和局部变量引子---? ?? ???变量可以在程序中三个地方说明: 函数内部、函数的参数定义中或所有的函数外部。根据所定义位置的不同, 变量可分为局部变量、形式参数和全程变量。从空间角度来看，变量可以分为全局变量和局部变量，而从时间角度来分的 可以有静态存储变量和动态存储变量之分。一。全局变量和局部变量1。局部变量他是 指在函数内部定义的变量 作用域为定义局部变量的函数 也就是说他只能在定义他的函数中使用最值得注意的是 只有在程序执行到定义他的模块时才能生成，一旦执行退出该模块则起变量消失eg.func (){? ?int x;? ?局部变量x的作用域 很明确? ?......}2。全局变量在程序执行的过程中一直有效eg.int x=1;func (){? ?x=x+1;}func1 (){??x=x-1;}main (){}由此不难看出整型x的作用范围对于全局变量 如果在定义的时候不做初始化 则系统将自动为起赋值 数值型为0字符型为空""全局变量的弊端 增加内存开销 降低函数的通用性定义全局变量时 理想的位置是在文件的开头 当这些函数以及同一个程序中的其他源程序文件中的某些函数需要使用该全局变量时 在函数内部对该变量使用extern 加以说明 说明他是外部的 (这里还要做详细的讲解)eg.main (){extern int a,b;printf ("mIn is %d ",min(a,b));}int a=1,b=2;int min (x,y)int x,y;{int z;z=x<y?x:y;return(z);}我还要说明的是 对外部变量的说明和对全局变量的定义不是一回事对外部变量的说明 只是声明该变量是在外部定义过的一个全局变量 在这里引用 而对全局变量的定义则是要对起分配存储单元的一个全局变量只能定义一次 可是却可以多次引用*** 在同一源文件中，全局变量和局部变量同名时，在局部变量的作用域内，全局变量不起作用的。二。静态存储变量和动态存储变量对于程序运行期间根据需要进行临时动态分配存储空间的变量 为动态存储变量对于那些程序运行期间永久占用固定内存的变量 称为静态存储变量还要说明的是 程序的指令代码是存放在程序代码区的 静态存储变量是存放在静态数据区的 包括全局变量等 而程序中的动态存储变量存放在动态数据区 如函数的形参以及函数调用时的返回地址等三。C语言中的变量存储分类指定? ? ? ? auto ? ? auto称为自动变量 如果函数不做其他说明的话 均为自动变量? ? static ? ? static称为静态变量。根据变量的类型可以分为静态局部变量和静态全程变量。 ? ? 1. 静态局部变量 ? ? ? ???它与局部变量的区别在于: 在函数退出时, 这个变量始终存在, 但不能被其它函数使用, 当再次进入该函数时, 将保存上次的结果。其它与局部变量一样。 ? ? ? ? 2. 静态全程变量 ? ? ? ???Turbo C2.0允许将大型程序分成若干独立模块文件分别编译, 然后将所有模块的目标文件连接在一起, 从而提高编译速度, 同时也便于软件的管理和维护。静态全程变量就是指只在定义它的源文件中可见而在其它源文件中不可见的变量。它与全程变量的区别是: 全程变量可以再说明为外部变量(extern), 被其它源文件使用, 而静态全程变量却不能再被说明为外部的, 即只能被所在的源文件使用。 ? ?? ?? ? extern ? ? extern称为外部变量。为了使变量除了在定义它的源文件中可以使用外, 还要被其它文件使用。因此,? ?必须将全程变量通知每一个程序模块文件,? ?此时可用extern来说明。 eg. ? ?? ???文件1为file1.c? ?? ?? ?? ?? ?? ?文件2为file2.c ? ? int i, j;/*定义全程变量*/? ?? ???extern int i, j;/*说明将i, j从 ? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ???文件1中复制过来*/ ? ? char c;? ?? ?? ?? ?? ?? ?? ?? ???extern char c; /*将c复制过来*/ ? ? void func1(int k);? ?? ?? ?? ?? ?func2()? ?? ???/*用户定义函数*/ ? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? { ? ? main()? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?static float k;/*定义静态变量*/ ? ? {? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ???i=j*5/100; ? ?? ?? ? func1(20);/*调用函数*/? ?? ???k=i/1.5; ? ?? ?? ? func2();? ?? ?? ?? ?? ?? ?? ?? ?? ?. ? ?? ?? ? .? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? . ? ?? ?? ? .? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? . ? ?? ?? ? .? ?? ?? ?? ?? ?? ?? ?? ?? ? } ? ???} ? ???func1(int k) /*用户定义函数*/ ? ???{ ? ?? ?? ? j=k*100; ? ???} ? ? 对于以上两个文件file1.c和file2.c, 用Turbo C2.0的集成开发环境进行编译 连接时, 首先应建立一个.prj的文件。例如file.prj, 该文件内容如下: ? ???file1.c ? ???file2.c ? ? 然后将file.prj的文件名写入主菜单Project中的Project Name项中。 再用F9 编译连接, 就可产生一个文件名为fioe.exe的可执行文件。 ? ?????? ? register ? ? register称为寄存器变量。它只能用于整型和字符型变量。定义符register说明的变量被Turbo C2.0存储在CPU的寄存器中,??而不是象普通的变量那样存储在内存中, 这样可以提高运算速度。但是Turbo C2.0只允许同时定义两个寄存器变量,一旦超过两个, 编译程序会自动地将超过限制数目的寄存器变量当作非寄存器变量来处理。因此, 寄存器变量常用在同一变量名频繁出现的地方。 ? ? 另外, 寄存器变量只适用于局部变量和函数的形式参数, 它属于auto型变量, 因此, 不能用作全程变量。定义一个整型寄存器变量可写成: ? ?? ?register int a; ? ? 对于以上所介绍的变量类型和变量存储类型将会在以后的学习中, 通过例行程序中的定义、使用来逐渐加深理解。

1 A2 C()3 D4 B5 A6 C7 D8 B9 B

一般在函数的定义：类型标识符 函数名（形参） 此处就为形参；在函数的调用：函数名（实参）此处就为实参在你的程序中定义了fun(struct ty b){b.data=20;b.c="y";} 那么struct ty b为形参主程序main中，调用了fun(a)，则参数a就是实参

这些概念不需要太在意吧。形参就是指一个形式上的引用。在函数内部需要引用外部的东西，可又不知道外部需要函数处理什么。于是在函数参数表里定义一个无实际意义的形式上的变量名，用于函数体操作。

函数的形参确实是局部变量，但是形参如果是地址，那么通过去地址操作，就可以访问到内存中的空间，从而改变它的值，返回时那个形参已经没有了。这里讲的是在函数局部内申明的局部变量，函数结束时，内存就已经释放了，返回它的地址是没有任何意义的。

你注意到cur_pin是不同的类型了吗？正是因为需要转换类型所以才引入它 形参可以参与运算，都居于栈空间

B啊。人家都写外部static变量啊~~

如果需要在保留形参的值不变的前提下（可能另有他用），但是需要形参的值参与运算并可能被改变时，就需要定义局部变量代替形参进行运算如果形参的值使用后被改变并不会造成一些不必要的错误时，可以直接使用形参参与运算

形参不能声明为static，但是局部变量可以。

什么意思 都默认了肯定要是一个定值 局部变量肯定不是定值

一样的，如果是&类型的话，参数会修改本来的值但作用域那么大