精华内容
下载资源
问答
  • 成员变量和局部变量同名 在同一个作用域内不允许定义同名的多个变量。   ...在一个方法内,可以定义和成员变量同名的局部变量或参数,此时成员变量被屏蔽。...将局部变量作用域最小化,可增加代码的可读

    成员变量和局部变量同名


    在同一个作用域内不允许定义同名的多个变量。

     

    在一个方法内,可以定义和成员变量同名的局部变量或参数,此时成员变量被屏蔽。此时如果想要访问成员变量,可以通过 this 关键字来访问,this 关键字来访问,this 为当前实例的引用,如果要访问类变量,可以通过类名来访问。

     

     

    局部变量的作用域最小化

     

    将局部变量的作用域最小化,可增加代码的可读性和可维护性,并且降低出错的可能性。

     

    局部变量最小化以下规则:

    1、在需要使用局部变量的时候,才定义它。

    2、使方法小而集中。

    全局变量与局部变量的区别
    全局变量与局部变量的区别
    一、变量的分类
    变量可以分为:全局变量、静态全局变量、静态局部变量和局部变量。
    按存储区域分,全局变量、静态全局变量和静态局部变量都存放在内
    存的静态存储区域,局部变量存放在内存的栈区。
    按作用域分,全局变量在整个工程文件内都有效;静态全局变量只在
    定义它的文件内有效;静态局部变量只在定义它的函数内有效,只是
    程序仅分配一次内存,函数返回后,该变量不会消失;局部变量在定
    义它的函数内有效,但是函数返回后失效。
    全局变量和静态变量如果没有手工初始化,则由编译器初始化为0。
    局部变量的值不可知。
    静态全局变量,只本文件可以用。
    全局变量是没有定义存储类型的外部变量,其作用域是从定义点到程
    序结束.省略了存储类型符,系统将默认为是自动型.
    静态全局变量是定义存储类型为静态型的外部变量,其作用域是从定
    义点到程序结束,所不同的是存储类型决定了存储地点,静态型变量

    是存放在内存的数据区中的,它们在程序开始运行前就分配了固定的
    字节,在程序运行过程中被分配的字节大小是不改变的.只有程序运
    行结束后,才释放所占用的内存.
    自动型变量存放在堆栈区中.堆栈区也是内存中一部分,该部分内存
    在程序运行中是重复使用的.

    二、介绍变量的作用域
    在讨论函数的形参变量时曾经提到, 形参变量只在被调用期间才分
    配内存单元,调用结束立即释放。这一点表明形参变量只有在函数
    内才是有效的, 离开该函数就不能再使用了。这种变量有效性的范
    围称变量的作用域。不仅对于形参变量, C 语言中所有的量都有自
    己的作用域。变量说明的方式不同,其作用域也不同。 C 语言中的
    变量,按作用域范围可分为两种, 即局部变量和全局变量。
    一、局部变量
    局部变量也称为内部变量。局部变量是在函数内作定义说明的。
    其作用域仅限于函数内, 离开该函数后再使用这种变量是非法的。
    例如:
    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. 允许在不同的函数中使用相同的变量名,它们代表不同的对
    象,分配不同的单元,互不干扰,也不会发生混淆。如在例5.3 中,
    形参和实参的变量名都为n,是完全允许的。4. 在复合语句中也可
    定义变量,其作用域只在复合语句范围内。例如:
    main()
    {
    int s,a;
    ……
    {
    int b;

    s=a+b;
    ……b 作用域
    }
    ……s,a 作用域
    }
    [例5.11]main()
    {
    int i=2,j=3,k;
    k=i+j;
    {
    int k=8;
    if(i==3) printf("%d\n",k);
    }
    printf("%d\n%d\n",i,k);
    }
    main()
    {
    int i=2,j=3,k;
    k=i+j;
    {
    int k=8;
    if(i=3) printf("%d\n",k);

    }
    printf("%d\n%d\n",i,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。
    二、全局变量
    全局变量也称为外部变量,它是在函数外部定义的变量。它不
    属于哪一个函数,它属于一个源程序文件。其作用域是整个源程序。
    在函数中使用全局变量,一般应作全局变量说明。只有在函数内经
    过说明的全局变量才能使用。全局变量的说明符为extern。但在一
    个函数之前定义的全局变量,在该函数内使用可不再加以说明。例
    如:
    int a,b; /*外部变量*/
    void f1() /*函数f1*/
    {

    ……
    }
    float x,y; /*外部变量*/
    int fz() /*函数fz*/
    {
    ……
    }
    main() /*主函数*/
    {
    ……
    }/*全局变量x,y 作用域全局变量a,b 作用域*/
    从上例可以看出a、b、x、y 都是在函数外部定义的外部变量,
    都是全局变量。但x,y 定义在函数f1 之后,而在f1 内又无对x,y
    的说明,所以它们在f1内无效。a,b 定义在源程序最前面,因此在
    f1,f2 及main 内不加说明也可使用。
    [例5.12]输入正方体的长宽高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("\ninput length,width and height\n");
    scanf("%d%d%d",&l,&w,&h);
    v=vs(l,w,h);
    printf("v=%d s1=%d s2=%d s3=%d\n",v,s1,s2,s3);
    }
    本程序中定义了三个外部变量s1,s2,s3, 用来存放三个面积,
    其作用域为整个程序。函数vs用来求正方体体积和三个面积, 函数
    的返回值为体积v。由主函数完成长宽高的输入及结果输出。由于C
    语言规定函数返回值只有一个, 当需要增加函数的返回数据时,用
    外部变量是一种很好的方式。本例中,如不使用外部变量, 在主函
    数中就不可能取得v,s1,s2,s3 四个值。而采用了外部变量, 在函数
    vs 中求得的s1,s2,s3 值在main 中仍然有效。因此外部变量是实现
    函数之间数据通讯的有效手段。对于全局变量还有以下几点说明:1. 对于局部变量的定义和说明,可以不加区分。而对于外部变
    量则不然,外部变量的定义和外部变量的说明并不是一回事。外部变
    量定义必须在所有的函数之外,且只能定义一次。其一般形式为:
    [extern] 类型说明符变量名,变量名… 其中方括号内的extern 可
    以省去不写。
    例如: int a,b;
    等效于:
    extern int a,b;
    而外部变量说明出现在要使用该外部变量的各个函数内, 在整
    个程序内,可能出现多次,外部变量说明的一般形式为: extern 类
    型说明符变量名,变量名,…; 外部变量在定义时就已分配了内存
    单元, 外部变量定义可作初始赋值,外部变量说明不能再赋初始值,
    只是表明在函数内要使用某外部变量。
    2. 外部变量可加强函数模块之间的数据联系,但是又使函数要
    依赖这些变量,因而使得函数的**性降低。从模块化程序设计的观点
    来看这是不利的, 因此在不必要时尽量不要使用全局变量。
    3. 在同一源文件中,允许全局变量和局部变量同名。在局部变
    量的作用域内,全局变量不起作用。
    [例5.13]
    int vs(int l,int w)
    {
    extern int h;

    int v;
    v=l*w*h;
    return v;
    }
    main()
    {
    extern int w,h;
    int l=5;
    printf("v=%d",vs(l,w));
    }
    int l=3,w=4,h=5;
    本例程序中,外部变量在最后定义, 因此在前面函数中对要用
    的外部变量必须进行说明。外部变量l,w 和vs 函数的形参l,w 同
    名。外部变量都作了初始赋值,mian函数中也对l作了初始化赋值。
    执行程序时,在printf 语句中调用vs 函数,实参l 的值应为main
    中定义的l 值,等于5,外部变量l 在main 内不起作用;实参w 的
    值为外部变量w 的值为4,进入vs 后这两个值传送给形参l,wvs 函
    数中使用的h 为外部变量,其值为5,因此v的计算结果为100,返
    回主函数后输出。变量的存储类型各种变量的作用域不同, 就其本
    质来说是因变量的存储类型相同。所谓存储类型是指变量占用内存空
    间的方式, 也称为存储方式。
    变量的存储方式可分为“静态存储”和“动态存储”两种。
    静态存储变量通常是在变量定义时就分定存储单元并一直保持
    不变, 直至整个程序结束。5.5.1 节中介绍的全局变量即属于此类
    存储方式。动态存储变量是在程序执行过程中,使用它时才分配存储
    单元, 使用完毕立即释放。典型的例子是函数的形式参数,在函数
    定义时并不给形参分配存储单元,只是在函数被调用时,才予以分配,
    调用函数完毕立即释放。如果一个函数被多次调用,则反复地分配、
    释放形参变量的存储单元。从以上分析可知, 静态存储变量是一直
    存在的, 而动态存储变量则时而存在时而消失。我们又把这种由于
    变量存储方式不同而产生的特性称变量的生存期。生存期表示了变
    量存在的时间。生存期和作用域是从时间和空间这两个不同的角度
    来描述变量的特性,这两者既有联系,又有区别。一个变量究竟属
    于哪一种存储方式, 并不能仅从其作用域来判断,还应有明确的存
    储类型说明。
    在C 语言中,对变量的存储类型说明有以下四种:
    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为外部整型变量。
    总结与区别: 变量根据定义的位置的不同的生命周期,具有不同的
    作用域,作用域可分为6 种:全局作用域,局部作用域,语句作用域,
    类作用域,命名空间作用域和文件作用域。
    从作用域看:
    全局变量具有全局作用域。全局变量只需在一个源文件中定义,就可
    以作用于所有的源文件。当然,其他不包含全局变量定义的源文件需
    要用extern 关键字再次声明这个全局变量。
    静态局部变量具有局部作用域,它只被初始化一次,自从第一次被初
    始化直到程序运行结束都一直存在,它和全局变量的区别在于全局变
    量对所有的函数都是可见的,而静态局部变量只对定义自己的函数体
    始终可见。
    局部变量也只有局部作用域,它是自动对象(auto),它在程序运行
    期间不是一直存在,而是只在函数执行期间存在,函数的一次调用执
    行结束后,变量被撤销,其所占用的内存也被收回。
    静态全局变量也具有全局作用域,它与全局变量的区别在于如果程序
    包含多个文件的话,它作用于定义它的文件里,不能作用到其它文件
    里,即被static 关键字修饰过的变量具有文件作用域。这样即使两
    个不同的源文件都定义了相同名字的静态全局变量,它们也是不同的
    变量。
    从分配内存空间看:
    全局变量,静态局部变量,静态全局变量都在静态存储区分配空间,
    而局部变量在栈里分配空间。
    全局变量本身就是静态存储方式,静态全局变量当然也是静态存储方
    式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局
    变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非
    静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制
    了其作用域,即只在定义该变量的源文件内有效,在同一源程序的其
    它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文
    件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中
    引起错误。
    1)、静态变量会被放在程序的静态数据存储区(全局可见)中,这样可
    以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变
    量和堆变量的区别。
    2)、变量用static 告知编译器,自己仅仅在变量的作用范围内可见。

    这一点是它与全局变量的区别。
    从以上分析可以看出,把局部变量改变为静态变量后是改变了它的存
    储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了
    它的作用域,限制了它的使用范围。因此static 这个说明符在不同
    的地方所起的作用是不同的。应予以注意。
    Tips:
    A.若全局变量仅在单个C 文件中访问,则可以将这个变量修改为
    静态全局变量,以降低模块间的耦合度;
    B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数
    的静态局部变量,以降低模块间的耦合度;
    C.设计和使用访问动态全局变量、静态全局变量、静态局部变量
    的函数时,需要考虑重入问题,因为他们都放在静态数据存储区,全
    局可见;
    D.如果我们需要一个可重入的函数,那么,我们一定要避免函数中使
    用static 变量(这样的函数被称为:带“内部存储器”功能的的函数)
    E.函数中必须要使用static 变量情况:比如当某函数的返回值为指
    针类型时,则必须是static的局部变量的地址作为返回值,若为auto
    类型,则返回为错指针。

    展开全文
  • C语言中的变量,按照作用域的范围可分为两种, 即局部变量和全局变量。 一、局部变量局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这种变量是非法的。...
    原链接:点击打开链接

    C语言中所有变量都有自己的作用域,申明变量的类型不同,其作用域也不同。C语言中的变量,按照作用域的范围可分为两种, 即局部变量和全局变量。 一、局部变量

    局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这种变量是非法的。

    例如:

    int f1(int a) /*函数f1*/ {     int b,c

    ……}

    int f2(int x) /*函数f2*/ {     int y,z;

    ……}

    f1内定义了三个变量,a为形参,b,c为一般变量。在 f1的范围内a,b,c有效,或者说a,b,c变量的作用域限于f1内。

    f2内定义了三个变量,x为形参,y,z为一般变量。在 f2的范围内x,y,z有效,或者说x,y,z变量的作用域限于f2内。

    关于局部变量的作用域还要说明以下几点:

             主函数中定义的变量也只能在主函数中使用,不能在其它函数中使用。同时,主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数,它与其它函数是平行关系。

             形参变量是属于被调函数的局部变量,实参变量是属于主调函数的局部变量。

             允许在不同的函数中使用相同的变量名,它们代表不同的对象,分配不同的单元,互不干扰,也不会发生混淆。虽然允许在不同的函数中使用相同的变量名,但是为了使程序明了易懂,不提倡在不同的函数中使用相同的变量名。

    二、全局变量

    int a,b; /*外部变量*/ void f1() /*函数f1*/ { …… }

    float x,y; /*外部变量*/ int fz() /*函数fz*/ { …… }

    全局变量也称为外部变量,它是在函数外部定义的变量。 它不属于哪一个函数,它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量,一般应作全局变量说明。 只有在函数内经过说明的全局变量才能使用。全局变量的说明符为extern 但在一个函数之前定义的全局变量,在该函数内使用可不再加以说明。 例如:   从上例可以看出abx都是在函数外部定义的外部变量,都是全局变量。  对于全局变量还有以下几点说明:

             对于局部变量的定义和说明,可以不加区分。而对于外部变量则不然,外部变量的定义和外部变量的说明并不是一回事。外部变量定义必须在所有的函数之外,且只能定义一次。其一般形式为: [extern] 类型说明符 变量名,变量名… 其中方括号内的extern可以省去不写。    例如: int a,b;    等效于:  extern int a,b;    而外部变量说明出现在要使用该外部变量的各个函数内,在整个程序内,可能出现多次,外部变量说明的一般形式为: extern 类型说明符 变量名,变量名, 外部变量在定义时就已分配了内存单元,外部变量定义可作初始赋值,外部变量说明不能再赋初始值, 只是表明在函数内要使用某外部变量。

             外部变量可加强函数模块之间的数据联系,但是又使函数要依赖这些变量,因而使得函数的独立性降低。从模块化程序设计的观点来看这是不利的, 因此在不必要时尽量不要使用全局变量。

             在同一源文件中,允许全局变量和局部变量同名。在局部变量的作用域内,全局变量不起作用。 int vs(int l,int w) { extern int h; int v; v=l*w*h; return v; } main() { extern int w,h; int l=5; printf("v=%d",vs(l,w)); } int l=3,w=4,h=5;    本例程序中,外部变量在最后定义, 因此在前面函数中对要用的外部变量必须进行说明。外部变量lwvs函数的形参lw同名。外部变量都作了初始赋值,mian函数中也对l作了初始化赋值。执行程序时,在printf语句中调用vs函数,实参l的值应为main中定义的l值,等于5,外部变量lmain内不起作用;实参w的值为外部变量w的值为4,进入vs后这两个值传送给形参lwvs函数中使用的为外部变量,其值为5,因此v的计算结果为100,返回主函数后输出。

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

    C语言中,对变量的存储类型说明有以下四种:

    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    这种存储类型是C语言程序中使用最广泛的一种类型。C语言规定, 函数内凡未加存储类型说明的变量均视为自动变量, 也就是说自动变量可省去说明符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); } { auto int a; 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); }    s,p是在复合语句内定义的自动变量,只能在该复合语句内有效。而程序的第9行却是退出复合语句之后用printf语句输出s,p的值,这显然会引起错误。    3. 由于自动变量的作用域和生存期都局限于定义它的个体内函数或复合语句内) 因此不同的个体中允许使用同名的变量而不会混淆。 即使在函数内定义的自动变量也可与该函数内部的复合语句中定义的自动变量同名。例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为自动变量。按照C语言的规定,在复合语句内,应由复合语句中定义的s,p起作用,故s的值应为a+ ap的值为a*a。退出复合语句后的s,p 应为main所定义的s,p,其值在初始化时给定,均为100。从输出结果可以分析出两个s和两个p虽变量名相同, 但却是两个不同的变量。    4. 对构造类型的自动变量如数组等,不可作初始化赋值。    二、外部变量的类型说明符为extern    在前面介绍全局变量时已介绍过外部变量。这里再补充说明外部变量的几个特点:    1. 外部变量和全局变量是对同一类变量的两种不同角度的提法。全局变量是从它的作用域提出的,外部变量从它的存储方式提出的,表示了它的生存期。    2. 当一个源程序由若干个源文件组成时, 在一个源文件中定义的外部变量在其它的源文件中也有效。例如有一个源程序由源文件F1.CF2.C组成: F1.C int a,b; /*外部变量定义*/ char c; /*外部变量定义*/ main() { …… }    F2.C extern int a,b; /*外部变量说明*/ extern char c; /*外部变量说明*/ func (int x,y) { …… }    F1.CF2.C两个文件中都要使用a,b,c三个变量。在F1.C文件中把a,b,c都定义为外部变量。在F2.C文件中用extern把三个变量说明为外部变量,表示这些变量已在其它文件中定义,并把这些变量的类型和变量名,编译系统不再为它们分配内存空间。 对构造类型的外部变量, 如数组等可以在说明时作初始化赋值,若不赋初值,则系统自动定义它们的初值为0 静态变量    静态变量的类型说明符是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值。而对自动变量不赋初值,则其值是不定的。 根据静态局部变量的特点, 可以看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用,但如再次调用定义它的函数时,它又可继续使用, 而且保存了前次被调用后留下的值。 因此,当多次调用一个函数且要求在调用之间保留某些变量的值时,可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的,但全局变量有时会造成意外的副作用,因此仍以采用局部静态变量为宜。    [5.15] main() { int i; void f(); /*函数说明*/ for(i=1;i<=5;i++) f(); /*函数调用*/ } void f() /*函数定义*/ { auto int j=0; ++j; printf("%d/n",j); }    程序中定义了函数f,其中的变量说明为自动变量并赋予初始值为0。当main中多次调用f时,j均赋初值为0,故每次输出值均为1。现在把j改为静态局部变量,程序如下: main() { int i; void f(); for (i=1;i<=5;i++) f(); } void f() { static int j=0; ++j; printf("%d/n",j); } void f() { static int j=0; ++j; printf("%d/n",j); }    由于j为静态变量,能在每次调用后保留其值并在下一次调用时继续使用,所以输出值成为累加的结果。读者可自行分析其执行过程。    2.静态全局变量    全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用, 因此可以避免在其它源文件中引起错误。从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。应予以注意。    四、寄存器变量    上述各类变量都存放在存储器内, 因此当对一个变量频繁读写时,必须要反复访问内存储器,从而花费大量的存取时间。 为此,C语言提供了另一种变量,即寄存器变量。这种变量存放在CPU的寄存器中,使用时,不需要访问内存,而直接从寄存器中读写, 这样可提高效率。寄存器变量的说明符是register 对于循环次数较多的循环控制变量及循环体内反复使用的变量均可定义为寄存器变量。 ∑200i=1imain() { register i,s=0; for(i=1;i<=200;i++) s=s+i; printf("s=%d/n",s); }    本程序循环200次,is都将频繁使用,因此可定义为寄存器变量。对寄存器变量还要说明以下几点:    1. 只有局部自动变量和形式参数才可以定义为寄存器变量。因为寄存器变量属于动态存储方式。凡需要采用静态存储方式的量不能定义为寄存器变量。    2. Turbo CMS C等微机上使用的C语言中, 实际上是把寄存器变量当成自动变量处理的。因此速度并不能提高。 而在程序中允许使用寄存器变量只是为了与标准C保持一致。3. 即使能真正使用寄存器变量的机器,由于CPU 中寄存器的个数是有限的,因此使用寄存器变量的个数也是有限的。 

    ——————————————————————————————————————————

    原链接:点击打开链接
    静态变量,就是在定义的时候,有static 修饰的变量,形式为
    static TYPE var_name = init_value;
    而动态变量,形式为
    TYPE var_name = init_value;
    即没有static 修饰。其中的=init_value均可省略。
    区分定义在函数外的全局变量,和函数内的局部变量,作用域,生命周期,及无显式初始化时的初始值,均有区别。
    1 动态全局变量:
    作用域为整个项目,即最终编译成可执行文件的所有文件中均可以使用动态全局变量。
    生命周期为从程序运行到程序退出,即贯穿整个运行时间。
    无显式初始化时默认初始化值为0。

    2 静态全局变量
    作用域为当前文件,从定义/声明位置到文件结尾。
    生命周期为从程序运行到程序退出,即贯穿整个运行时间。
    无显式初始化时默认初始化值为0。

    3 动态局部变量
    作用域为当前函数,从定义位置,到其所在的{}的结束位置。
    生命周期为从函数调用到函数退出。
    无显式初始化时默认初始化值为随机值。

    4 静态局部变量
    作用域为当前函数,从定义位置,到其所在的{}的结束位置。
    生命周期为从程序运行到程序退出,即贯穿整个运行时间,当下次函数调用时,静态局部变量不会被再次初始化,而是沿用上次函数退出时的值。
    无显式初始化时默认初始化值为0。

    #include<stdio.h>
    int fun3(int x)
    {
    	static int a=3;
    	a+=x;
    	return(a);
    }
    main()
    {	
    	int k=2, m=1, n;
    	n=fun3(k);
    	n=fun3(m);
    	printf("%d\n",n);            //6
    }
    #include<stdio.h>
    int fun(int x[],int n)
    {
    	static int sum=0,i;
    	for(i=0;i<n;i++) sum+=x[i];
    	return sum;
    }
    main()
    {
    	int a[]={1,2,3,4,5},b[]={6,7,8,9,},s=0;
    	s=fun(a,5)+fun(b,4);
    	printf("%d\n",s);   //60
    }

    #include<stdio.h>
    int a,b;
    void fun()
    {
    	a=100;
    	b=200;
    }
    
    main()
    {
    	int a=5,b=7;
    	fun();
    	printf("%d,%d\n",a,b);        //5,7
    }

    #include<stdio.h>
    void fun(){
    	static int a=0;
    	a+=2;
    	printf("%d",a);
    }
    
    main(){
    	int cc;
    	for(cc=1;cc<4;cc++) fun();    //246
    	printf("\n");
    }

    以下叙述中正确的是___A___。
    A、局部变量说明为static 存储类,其生存期将得到延长
    B、全局变量说明为static 存储类,其作用域将被扩大
    C、任何存储类的变量在未赋初值时,其值都是不确定的

    D、形参可以使用的存储类说明符与局部变量完全相同



    展开全文
  • static 变量 作用域 全局变量 局部变量 外部变量 常量 volatile变量 2人收藏此文章, 我要收藏发表于2年前 , 已有1077次阅读 共2个评论 作用域 全局变量 局部变量 静态变量 外部变量 常量 ...

    static 变量 作用域 全局变量 局部变量 外部变量 常量 volatile变量

    2人收藏此文章, 我要收藏发表于2年前 , 已有1077次阅读 共2个评论

    作用域 全局变量 局部变量 静态变量 外部变量 常量 volatile变量

    作用域:

    作用域规则告诉我们一个变量的有效范围,它在哪儿创建,在哪儿销毁(也就是说超出了作用域)。变量的有效作用域从它的定义点开始,到和定义变量之前最邻近的开括号配对的第一个闭括号。也就是说,作用域由变量所在的最近一对括号确定。

    全局变量:

    全局变量是在所有函数体的外部定义的,程序的所在部分(甚至其它文件中的代码)都可以使用。全局变量不受作用域的影响,问题可以使用的(也就是说,全局变量的生命期一直到程序的结束)。如果在一个文件中使用extern关键字来声明另一个文件中存在的全局变量,那么这个文件可以使用这个数据。

    局部变量:

    局部变量出现在一个作用域内,它们是局限于一个函数的。局部变量经常被称为自动变量,因为它们在进入作用域时自动生成,离开作用域时自动消失。关键字auto可以显式地说明这个问题,但是局部变量默认为

    auto,所以没有必要声明为auto。

    寄存器变量

    寄存器变量是一种局部变量。关键字register告诉编译器“尽可能快地访问这个变量”。加快访问速度取决于现实,但是,正如名字所暗示的那样,这经常是通过在寄存器中放置变量来做到的。这并不能保证将变置在寄存器中,甚至也不能保证提高访问速度。这只是对编译器的一个暗示。

    使用register变量是有限制的。不可能得到或计算register 变量的地址。register变量只能在一个块中声明(不可能有全局的或静态的register变量)。然而可以在一个函数中(即在参数表中)使用register变量作为一个形式参数。

    一般地,不应当推测编译器的优化器,因为它可能比我们做得更好。因此,最好避免使用关键字register。

    静态变量

    关键字static有一些独特的意义。通常,函数中定义局部变量在函数中作用域结束时消失。当再次调用这个函数时,会重新创建变量的存储空间,其值会被重新初始化。如果想使局部变量的值在程序的整个生命期里仍然存在,我们可以定义函数的局部变量为static(静态的),并给它一个初始化。初始化只在函数第一次调用时执行,函数调用之间变量的值保持不变,这种方式,函数可以“记住”函数调用之间的一些信息片断。

    我们可能奇怪为什么不使用全局变量。static变量的优点是在函数范围之外它是不可用的,所以它不可能被轻易改变。这会使错误局部化。

    外部变量

    extern告诉编译器存在着一个变量和函数,即使编译器在当前的文件中没有看到它。这个变量或函数可能在一个文件或者在当前文件的后面定义。例如extern int i;编译器会知道i肯定作为全局变量存在于某处。当编译器看到变量i的定义时,并没有看到别的声明,所以知道它在文件的前面已经找到了同样声明的i 。

    常量

    const告诉编译器这个名字表示常量,不管是内部的还是用户定义的数据类型都可以定义为const。如果定义了某对象为常量,然后试图改变它,编译器将会产生错误。在C++中一个const必须有初始值。

    volatile变量

    限定词const告诉编译器“这是不会改变的”(这就是允许编译器执行额外的优化);而限定词volatile则告诉编译器“不知道何时变化”,防止编译器依据变量的稳定性作任何优化。

    参考《Thinking in C++》第一卷第三章

     ——————————————————————————————————————

    Static 作用详述

    1.先来介绍它的第一条也是最重要的一条:隐藏

         当我们同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话,我举例来说明。我们要同时编译两个源文件,一个是a.c,另一个是main.c.

    下面是a.c的内容:

     char a = 'A'; // global variable
                void msg()
                {
                printf("Hello\n");
                }
                

    下面是main.c的内容:

     int main(void)
                {
                extern char a; // extern variable must be declared before use
                printf("%c ", a);
                (void)msg();
                return 0;
                }
                

    程序的运行结果是:

    A Hello

         你可能会问:为什么在a.c中定义的全局变量a和函数msg能在main.c中使用?前面说过,所有未加static前缀的全局变量和函数都具有全局可见 性,其它的源文件也能访问。此例中,a是全局变量,msg是函数,并且都没有加static前缀,因此对于另外的源文件main.c是可见的。

    如果加了static,就会对其它源文件隐藏。例如在a和msg的定义前加上 static,main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量,而不必担心命名冲突。Static可以用作函数和变 量的前缀,对于函数来讲,static的作用仅限于隐藏,而对于变量,static还有下面两个作用。

    2. static的第二个作用是保持变量内容的持久

         存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化。共有两种变量存储在静态存储区:全局变量和static变量,只不过和 全局变量比起来,static可以控制变量的可见范围,说到底static还是用来隐藏的。虽然这种用法不常见,但我还是举一个例子。

     #include <stdio.h>
                int fun(void){
                static int count = 10; // 事实上此赋值语句从来没有执行过
                return count--;
                }
                int count = 1;
                int main(void)
                {
                printf("global\t\tlocal static\n");
                for(; count <= 10; ++count)
                printf("%d\t\t%d\n", count, fun());
                return 0;
                }

    程序的运行结果是:

    global local static
    1  10
    2   9
    3   8
    4   7
    5   6
    6   5
    7   4
    8   3
    9   2
    10  1

    3. static的第三个作用是默认初始化为0.其实全局变量也具备这一属性,因为全局变量也存储在静态数据区

         在静态 数据区,内存中所有的字节默认值都是0x00,某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵,我们可以一个一个地把所有元素都置0, 然后把不是0的几个元素赋值。如果定义成静态的,就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用,但又觉得每次在字符数组末尾加‘\0’ 太麻烦。如果把字符串定义成静态的,就省去了这个麻烦,因为那里本来就是‘\0’。不妨做个小实验验证一下。

    #include <stdio.h>
                int a;
                int main(void)
                {
                int i;
                static char str[10];
                printf("integer: %d; string: (begin)%s(end)", a, str);
                return 0;
                }
                

    程序的运行结果如下integer: 0; string: (begin)(end)

    最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏,其次因为static变量存放在静态存储区,所以它具备持久性和默认值0.

    4. 用static声明的函数和变量小结

    static 声明的变量在C语言中有两方面的特征:

     

     

    1)、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
    2)、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。

     
    Tips:
    A.若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度;
    B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度;
    C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题;
        D.如果我们需要一个可重入的函数,那么,我们一定要避免函数中使用static变量(这样的函数被称为:带“内部存储器”功能的的函数)
          E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时,则必须是static的局部变量的地址作为返回值,若为auto类型,则返回为错指针。

        函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。

    扩展分析:

          术语static有着不寻常的历史.起初,在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后,static在C中有了第二种含义:用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字,所以仍使用static关键字来表示这第二种含义。最后,C++重用了这个关键字,并赋予它与前面不同的第三种含义:表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

    全局变量、静态全局变量、静态局部变量和局部变量的区别

    变量可以分为:全局变量、静态全局变量、静态局部变量和局部变量。


             

    存储区域分,全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域,局部变量存放在内存的栈区
              按作用域分,  全局变量在整个工程文件内都有效;静态全局变量只在定义它的文件内有效;静态局部变量只在定义它的函数内有效,只是程序仅分配一次内存,函数返回后,该变量不会消失;局部变量在定义它的函数内有效,但是函数返回后失效

        全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用, 因此可以避免在其它源文件中引起错误。

    从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。

    static 函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件

    static全局变量与普通的全局变量有什么区别:static全局变量只初始化一次,防止在其他文件单元中被引用;
    static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;
        static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝
        全局变量和静态变量如果没有手工初始化,则由编译器初始化为0。局部变量的值不可知。

    ——————————————————————————————————————

     C++的static有两种用法:面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类;后者主要说明static在类中的作用。

    一、面向过程设计中的static

    1、静态全局变量

    在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子,如下: 

    //Example 1

    #include <iostream.h>

    void fn();

    static int n; //定义静态全局变量

    void main()

    {

     n=20;

     cout<<n<<endl;

     fn();

    }

    void fn()

    {

     n++;

     cout<<n<<endl;

    }

    静态全局变量有以下特点:  

    ·                                

    1 该变量在全局数据区分配内存;  

    ·                                

     未经初始化的静态全局变量会被程序自动初始化为0(自动变量的值是随机的,除非它被显式初始化);  

    ·                                

     静态全局变量在声明它的整个文件都是可见的,而在文件之外是不可见的;   

    静态变量都在全局数据区分配内存,包括后面将要提到的静态局部变量。对于一个完整的程序,在内存中的分布情况如下图:
       

    代码区

    全局数据区

    堆区

    栈区

      一般程序的由new产生的动态数据存放在堆区,函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现,Example 1中的代码中将 

     static int n; //定义静态全局变量

    改为 

     int n; //定义全局变量

    <span http:="" my.oschina.net="" alphajay="" blog="" 5508"="" title="上一篇:Libnet核心数据结构" style="padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; font-family: 宋体; ">« Libnet核心数据结构



    全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用, 因此可以避免在其它源文件中引起错误。

    static全局变量与普通的全局变量有什么区别:static全局变量只初使化一次,防止在其他文件单元中被引用;
    static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;
    static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝。

    展开全文
  • 2、作用域较小的局部变量隐藏作用域较大的局部变量 例如:上图里的运算结果: 此时 int x = 1, y = 1;作用域较小会隐藏 x = 0, y = 0;的作用域。 全局变量(静态储存) 从此程序开始到此程...

    变量的作用范围

    取决于变量的定义位置

    1.局部变量(动态储存)

    1、仅能在它所定义的语句块内有效
    例如:

    第一个x,为零的作用域为定义它的语句块作用域(红色格格),里面的为橙色格格。
    2、作用域较小的局部变量隐藏作用域较大的局部变量
    例如:上图里的运算结果:
    在这里插入图片描述
    此时 int x = 1, y = 1;作用域较小会隐藏 x = 0, y = 0;的作用域。

    全局变量(静态储存)

    此程序开始到此程序结束都有效(这里指的是一个程序而不是定义它的文件)。
    1、局部变量与全局变量重名
    局部变量隐藏全局变量,变量值互不影响。
    2、形参与全局变量重名
    形参属于局部变量,符合局部变量隐藏全局变量,变量值互不影响。

    也就是说:
    只要同名的变量出现在不同的作用域内
    二者互不干扰,编译器有能力区分不同作用域中的同名变量
    假如同名变量 出现在同一个作用域中
    编译器也将束手无策

    全局变量与静态全局变量

    全局变量与静态全局变量都是静态储存,那有什么区别呢?
    静态全局变量的作用域为定义它的此文件内有效, 在同一源程序的其它源文件中不能使用它。而非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的,但在别的文件中使用需要使用extern 修饰。

    局部变量与静态变量

    局部变量与静态变量不同的是它的存储方式即改变了它的生存期,static局部变量只被初始化一次,下一次依据上一次结果值;同时只要某个对象对静态变量更新一次,所有的对象都能访问更新后的值。

    静态(static)函数与普通函数

    static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝

    小结图:

    在这里插入图片描述

    展开全文
  • 1.从作用域看: C++变量根据定义的位置的不同的生命周期,具有不同的作用域作用域可分为6种: 全局作用域,局部作用域,语句作用域,类作用域,命名空间作用域和...2>静态局部变量具有局部作用域,它只被初始化一次
  • 局部变量: 1,只能定义在他的区域或者语句中; 2,同一区域不能定义同一名变量 3,在变量所处区域的子区域重新定义同一变量,则大区域的变量被屏蔽 全局变量: 1,在函数外部定义的变量为全局变量 2,有效...
  • 局部变量,全局变量,静态变量的作用域,生命期? C++变量根据定义位置的不同,具有不同的作用域作用域可分为6种:全局作用域,局部作用域,语句作用域,类作用域,命名作用域和文件作用域。 从作用域看: 全局...
  • 变量的作用域是指变量的作用范围,即变量再程序中可以被访问的区域。 c语言中,每个变量都有一个有效的作用域。比如再函数内部定义的变量,不能再其他函数中引用 局部变量 指再函数体定义的变量和函数的形参。函数...
  • 作用域全局变量局部变量静态变量外部变量常量 volatile变量 作用域作用域规则告诉我们一个变量的有效范围,它在哪儿创建,在哪儿销毁(也就是说超出了作用域)。变量的有效作用域从它的定义点开始,到...
  • (1)static 作用域 : 当前“”文件中,其他文件无法访问 生命周期:整个程序运行过程测试1(静态变量放在cpp文件中): .h文件代码如下:#ifndef __FUNCTION_H__ #define __FUNCTION_H__ void print_var_1()...
  • C语言变量作用域

    万次阅读 2011-10-19 12:31:02
    C语言中的变量,按照作用域的范围可分为两种, 即局部变量和全局变量。  一、局部变量 局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使
  • php变量作用域

    千次阅读 2012-12-17 14:22:39
    对于初学者来说,变量作用域是它们所驻留的页面。因此,如果你定义了 $var,页面余下部分就可以访问 $var,但是,其它页面一般不能访问它(除非使用特殊的变量)。  因为包含文件像它们是原始(包含)脚本的一...
  • python中的变量作用域

    2019-04-10 10:33:09
    在Python程序中创建、改变、查找变量名时,都是在一个保存变量名的空间中进行,我们称之为命名空间,也被称之为作用域。python的作用域是静态的,在代码中变量名被赋值的位置决定了该变量能被访问的范围。即Python...
  • Python基本语法_变量作用域LEGB

    千次阅读 2015-12-10 01:31:09
    Llocal局部作用域 Eenclosing嵌套作用域 Gglobal全局作用域 Bbuilt-in内置作用域 变量名解析LEGB法则 实例说明 对变量的引用 对变量的修改 global关键字 nonlocal关键字 最后软件系统 系统 Ubuntu 14.04 软件 ...
  • c语言变量作用域

    2013-11-16 12:40:30
    C语言中的变量,按照作用域的范围可分为两种, 即局部变量和全局变量。  一、局部变量 局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这
  • 它的关键字是static存储在静态存储区,当程序执行,类的代码被加载到内存,类的静态变量就分配了内存空间,他是属于类的也就是没个实例对象都是对于以个静态变量,静态变量的内存空间知道程序退出才释放所占用的内存...
  • C++变量根据定义位置的不同,具有不同的作用域作用域可分为6种:全局作用域,局部作用域,语句作用域,类作用域,...静态局部变量具有局部作用域。它只被初始化一次,自从第一次初始化直到程序与你新内阁结束都一直
  • C语言中变量作用域

    千次阅读 2013-07-23 20:34:26
    C语言中的变量,按照作用域的范围可分为两种, 即局部变量和全局变量。 一、局部变量 局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这种变量是...
  • python 变量作用域

    千次阅读 2013-07-05 11:58:31
     在python中,变量查找遵循LGB原则,即优先在局部作用域(local scope)中对变量进行查找,失败则在全局作用域(global scope)中进行查找,最后尝试再内建作用域(build-in scope)内查找,如果还是未找到的话,则抛出...
  • 它的关键字是static存储在静态存储区,当程序执行,类的代码被加载到内存,类的静态变量就分配了内存空间,他是属于类的也就是没个实例对象都是对于以个静态变量,静态变量的内存空间知道程序退出才释放所占用的内存...
  • 局部变量的处理是比较特别,它是复杂语句里面声明,作用域也只限于复合语句里。如下面的例子:{ int a = 2;}上面的a就是局部变量的声明。现在再来仔细地分析compound里处理局部变量的代码。如下:#031 //局部变量...
  • C++ 变量根据定义的位置的不同的生命周期,具有不同的作用域作用域可分为 6 种:全局作用域,局部作用域,语句作用域,类作用域,命名空间作用域和文件...静态局部变量具有局部作用域,它只被初始化一次,自从第...
  • 作用域 存储方式 生命周期 初始化 java C/C++ 全局变量(外部变量) 整个工程文件内 内存的静态存储区域 整个源程序 0 没有全局变量的概念 在main()函数前(类外)定义,用extern int g_int ;声明,才可以...
  • 在讨论函数的形参变量时曾经提到, 形参变量只在被调用期间才分配内存单元,调用结束立即释放。 这一点表明形参变量只有在函数内才是有效的, 离开... C语言中的变量,按作用域范围可分为两种, 即局部变量和全局变量。
  • 变量作用域

    2014-09-24 08:45:37
    C++变量根据定义位置的不同,具有不同的作用域作用域可分为6种:全局作用域,局部作用域,语句作用域,类作用域,命名作用域和文件作用域。...静态局部变量具有局部作用域。它只被初始化一次,自从第一次初始化直
  • 在讨论函数的形参变量时曾经提到, 形参变量只在被调用期间才分配内存单元,调用结束立即释放。... C语言中的变量,按作用域范围可分为两种, 即局部变量和全局变量。   一、局部变量   
  • 局部变量和全局变量的区别

    千次阅读 2017-03-05 18:17:45
    作用域整个源程序。 2、局部变量 局部变量是指在程序中,只在特定过程或函数中可以访问的变量,是相对全局变量而言的。 3、特点及区别 在C等面向过程语言中,局部变量可以和全局变量重名,但是局部变量会...
  • C++变量作用域和声明周期

    千次阅读 2016-08-10 10:35:06
    顾名思义,作用域就是一个变量可以被引用的范围,如:全局作用域、文件作用域局部作用域;而生命周期就是这个变量可以被引用的时间段。不同生命周期的变量,在程序内存中的分布位置是不一样的。一个程序的内存分为...
  • Awk 中变量作用域的问题

    千次阅读 2013-05-29 17:27:01
    Awk 中变量作用域的问题 ...接下来,针对 Awk 变量作用域的特点,提出两种避免全局变量污染的常用方法,引出 Awk 中定义局部变量的方法,并提出修改过后的代码。然后,通过 Awk 的变量调试功
  • julia:变量作用域(完结)

    千次阅读 2018-08-26 21:19:25
    变量作用域 变量的范围是代码中可见变量的区域。变量作用域有助于避免变量命名冲突。这个概念很直观:两个函数都可以有名为x的参数,而不需要两个x引用相同的东西。类似地,还有很多其他情况,不同的代码块可以在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,907
精华内容 22,362
关键字:

局部变量的作用域是整个源程序