精华内容
下载资源
问答
  • SQL局部变量

    千次阅读 2017-02-24 16:16:31
    1.局部变量的定义: DECLARE 局部变量名 数据类型 【后面可以用逗号连接n个】 局部变量名必须是以@开头,要符合标识符的命名规则。 2.局部变量的赋值: 用SET或SELECT语句为局部变量赋值。 SET 局部变量名=表达式 ...

    1.局部变量的定义:

    DECLARE 局部变量名 数据类型 【后面可以用逗号连接n个】

    局部变量名必须是以@开头,要符合标识符的命名规则。


    2.局部变量的赋值:
    用SET或SELECT语句为局部变量赋值。

    SET 局部变量名=表达式

    SELECT 局部变量名=表达式 【后面可以用逗号连接n个


    3.变量值的输出,用PRINT或SELECT语句输出变量的值。

    PRINT 变量名

    SELECT 变量名 【后面可以用逗号连接n个

    PRINT只能一次输出一个变量,在“消息”窗口中显示,用SELECT可以同时输出多个变量,在“结果”子窗口中以表格形式显示。


    图片

    展开全文
  •   基本概念: 作用域:起作用的区域,也就是可以工作的范围。...C语言中局部变量就分配在栈中。   局部变量  普通的局部变量定义的时候直接定义或者在前面加上auto void func1(void){&nbs...

     

    基本概念: 作用域:起作用的区域,也就是可以工作的范围。

    代码块:所谓代码块,就是用{}括起来的一段代码。

    数据段:数据段存的是数,像全局变量就是存在数据段的

    代码段:存的是程序代码,一般是只读的。

    栈(stack):先进后出。C语言中局部变量就分配在栈中。

     

    局部变量

      普通的局部变量定义的时候直接定义或者在前面加上auto

    void func1(void)
    {
     int i = 1;
     
     i++;
     
     printf("i = %d.\n", i);
    }
    局部变量i的解析:
    在连续三次调用func1中,每次调用时,在进入函数func1后都会创造一个新的变量i,
    并且给它赋初值1,然后i++时加到2,
    然后printf输出时输出2.然后func1本次调用结束,
    结束时同时杀死本次创造的这个i。这就是局部变量i的整个生命周期。
    下次再调用该函数func1时,又会重新创造一个i,经历整个程序运算,
    最终在函数运行完退出时再次被杀死。

     

    静态局部变量(static) 静态局部变量定义时前面加static关键字。

    总结:

    1、静态局部变量和普通局部变量不同。静态局部变量也是定义在函数内部的,静态局部变量定义时前面要加static关键字来标识,静态局部变量所在的函数在多调用多次时,只有第一次才经历变量定义和初始化,以后多次在调用时不再定义和初始化,而是维持之前上一次调用时执行后这个变量的值。本次接着来使用。

    2、静态局部变量在第一次函数被调用时创造并初始化,但在函数退出时它不死亡,而是保持其值等待函数下一次被调用。下次调用时不再重新创造和初始化该变量,而是直接用上一次留下的值为基础来进行操作。

    3、静态局部变量的这种特性,和全局变量非常类似。它们的相同点是都创造和初始化一次,以后调用时值保持上次的不变。不同点在于作用域不同

     

    全局变量 定义在函数外面的变量,就叫全局变量。

    普通全局变量  普通全局变量就是平时使用的,定义前不加任何修饰词。普通全局变量可以在各个文件中使 用,可以在项目内别的.c文件中被看到,所以要确保不能重名。

    静态全局变量  静态全局变量就是用来解决重名问题的。静态全局变量定义时在定义前加static关键字, 告诉编译器这个变量只在当前本文件内使用,在别的文件中绝对不会使用。这样就不用担心重名问题。所以静态的全局变量就用在我定义这个全局变量并不是为了给别的文件使用,本来就是给我这个文件自己使用的。

    跨文件引用全局变量(extern) 就是说,你在一个程序的多个.c源文件中,可以在一个.c文件中定义全局变量g_a,并且可以在别的另一个.c文件中引用该变量g_a(引用前要声明)

    函数和全局变量在C语言中可以跨文件引用,也就是说他们的连接范围是全局的,具有文件连接属性,总之意思就是全局变量和函数是可以跨文件看到的(直接影响就是,我在a.c和b.c中各自定义了一个函数func,名字相同但是内容不同,编译报错。)。

     

    局部变量和全局变量的对比:
    1、定义同时没有初始化,则局部变量的值是随机的,而全局变量的值是默认为0.
    2、使用范围上:全局变量具有文件作用域,而局部变量只有代码块作用域。
    3、生命周期上:全局变量是在程序开始运行之前的初始化阶段就诞生,到整个程序结束退出的时候才死亡;而局部变量在进入局部变量所在的代码块时诞生,在该代码块退出的时候死亡。
    4、变量分配位置:全局变量分配在数据段上,而局部变量分配在栈上。

    //static

    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 void func1(void);
     5 void func_static(void);
     6 void func_static2(void);
     7 void func_global(void);
     8 void func_register(void);
     9 
    10 int g_a = 1;
    11 
    12 
    13 int main(void)
    14 {
    15     //a = 4;            // 编译报错,未定义
    16     g_a = 5;            // 可以,因为g_a是全局变量,所以到处都可以用
    17 
    18     func1();        // i = 2
    19     func1();        // i = 2
    20     func1();        // i = 2
    21     
    22     func_static();    // a = 2
    23     func_static();    // a = 3
    24     func_static();    // a = 4
    25     
    26     func_static2();    // a = 4;
    27     func_static2();    // a = 7;
    28     func_static2();    // a = 10;
    29     
    30     func_global();    // g_a = 4;
    31     func_global();    // g_a = 7;
    32     func_global();    // g_a = 10;
    33     
    34     func_register();
    35     func_register();
    36     func_register();
    37     
    38     
    39     
    40     
    41 // 因为i是定义在函数func中的局部变量,所以i的作用域为代码块作用域,所以i只在func1
    42 // 函数内部有效,在func1外面是不能访问i的。所以这里i会无定义。
    43     //i = 5;        // error: ‘i’ undeclared (first use in this function)
    44     
    45     return 0;
    46 }
    47 
    48 
    49 void func1(void)
    50 {
    51     int i = 1;                // 普通的局部变量,auto可以省略的
    52     //auto int i = 0;            // 自动局部变量,其实就是普通局部变量
    53     
    54     i++;
    55     
    56     printf("i = %d.\n", i);
    57 }
    58 
    59 void func_static(void)
    60 {
    61     static int a = 1;        // 静态的局部变量
    62     
    63     a++;
    64     
    65     printf("a = %d.\n", a);
    66 }
    67 
    68 void func_static2(void)
    69 {
    70     static int a = 1;        // 静态的局部变量
    71     
    72     a += 3;
    73     
    74     printf("a = %d.\n", a);
    75 }
    76 
    77 void func_global(void)
    78 {
    79     g_a += 3;
    80     
    81     printf("g_a = %d.\n", g_a);
    82 }
    83 
    84 void func_register(void)
    85 {
    86     register int a = 1;        // 静态的局部变量
    87     
    88     a += 3;
    89     
    90     printf("a = %d.\n", a);
    91 }
    复制代码

    //globle

    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 int g_i = 13;
     5 
     6 
     7 // 实验结论:
     8 // 首先,main函数是一个程序运行最开始执行的东西,所有的其他函数都只能在main函数中被
     9 // 直接或者间接的调用才能被执行。main函数的执行其实就是整个程序的生命周期,main函数
    10 // 一return返回,整个程序就结束了。
    11 // 其次,全局变量的定义和初始化是在main函数运行之前发生的。
    12 int main(void)
    13 {    
    14     printf("g_i = %d.\n", g_i);
    15     
    16     return 0;
    17 }
    复制代码
    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 void func_in_a(void);
     5 extern int g_a;                // 声明了一个int变量g_a
     6 //extern int g_b;
     7 
     8 void func_in_b(void)
     9 {
    10     printf("I am func in b.c.\n");
    11 }
    12 
    13 
    14 int main(void)
    15 {
    16     printf("I am main in a.c.\n");
    17     printf("I am main in a.c, g_a = %d.\n", g_a);
    18     printf("I am main in a.c, g_a = %d.\n", g_b);
    19     
    20     
    21     //func_in_b();        // 直接调用
    22     
    23     func_in_a();        // 间接调用
    24     
    25     return 0;
    26 }
    复制代码
    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 
     5 void func_in_b(void);
     6 
     7 int g_a = 12;
     8 int g_b = 111;
     9 
    10 
    11 
    12 
    13 
    14 
    15 void func_in_a(void)
    16 {
    17     
    18     g_a = 24;
    19     
    20     printf("I am in func_in_a of a.c, g_a = %d.\n", g_a);
    21     func_in_b();
    22 }
    23 
    24 /*
    25 // 定义错误
    26 // C语言中,定义函数都必须在外面,不能在一个函数里面定义别的函数
    27 // 所以没有局部函数,只有全局函数。
    28 
    29 void func1(void)
    30 {
    31     int a;
    32     
    33     
    34     void func2()
    35     {
    36         int b;
    37     }
    38 }
    39 
    40 */
    复制代码

    //最后两个分别为a.c b.c 文件目录为

     

    展开全文
  • 成员变量和局部变量同名 在同一个作用域内不允许定义同名的多个变量。   在一个方法内,可以定义和成员变量同名的局部变量或参数,此时成员变量被屏蔽。此时如果想要访问成员变量,可以通过 this 关键字来...

    成员变量和局部变量同名


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

     

    在一个方法内,可以定义和成员变量同名的局部变量或参数,此时成员变量被屏蔽。此时如果想要访问成员变量,可以通过 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
    类型,则返回为错指针。

    展开全文
  • 形参、局部变量和静态局部变量的差别  从本质上说,三者均属于局部作用域中的变量,其中局部变量又可以分为普通(非静态)局部变量和静态局部变量。它们的差别: 作用域:形参的作用域为整个函数体;而普通(非...

    形参、局部变量和静态局部变量的差别

            从本质上说,三者均属于局部作用域中的变量,其中局部变量又可以分为普通(非静态)局部变量和静态局部变量。它们的差别:

    1. 作用域:形参的作用域为整个函数体;而普通(非静态)局部变量和静态局部变量的作用域为:从定义处到包含该变量定义的块的结束处。
    2. 初始化:形参由调用函数时所传递的实参初始化而普通(非静态)局部变量和静态局部变量通常用初始化式进行初始化,且均在程序执行流程第一次经过该对象的定义语句时惊醒初始化。静态局部变量的初始化在整个程序执行过程中只进行一次。
    3. 生命周期形参和普通(非静态)局部变量均属于自动变量,在每次调用函数时创建,并在函数结束时撤销;静态局部变量的生命期跨越了函数的多次调用,它在创建后直到程序结束时才撤销。
    例如,如果需要连续输出1……x之间所有整数的阶乘
    //7-27.cpp
    //读入上限值upLimt,输出1……upLimt之间所有整数的阶乘
    #include <iostream>
    using namespace std;
    
    //用于辅助求阶乘的函数
    int fac(int x)		//x为形参
    {
    	static result = 1;	//result 为静态局部变量
    	result *= x;
    	return result;
    }
    
    int main()
    {
    	int upLimt;		//upLimt为普通局部变量
    	cout << "Enter value of upper limit:" << endl;
    	cin >> upLimt;
    
    	//依次输出1……upLimt之间所有整数的阶乘
    	for(int i = 1; i <= upLimt; ++i)
    		cout << i << "! = " << fac(i) << endl;
    
    	return 0;
    }
    
    7.5. Local Objects
    7.5. 局部对象
    In C++, names have scope, and objects have lifetimes. To understand how functions operate, it is important to understand both of these concepts. The scope of a name is the part of the program's text in which that name is known. The lifetime of an object is the time during the program's execution that the object exists.

    在 C++ 语言中,每个名字都有作用域,而每个对象都有生命期。要弄清楚函数是怎么运行的,理解这两个概念十分重要。名字的作用域指的是知道该名字的程序文本区。对象的生命期则是在程序执行过程中对象存在的时间。

    The names of parameters and variables defined within a function are in the scope of the function: The names are visible only within the function body. As usual, a variable's name can be used from the point at which it is declared or defined until the end of the enclosing scope.

    在函数中定义的形参和变量的名字只位于函数的作用域中:这些名字只在函数体中可见。通常,变量名从声明或定义的地方开始到包围它的作用域结束处都是可用的。

    7.5.1. Automatic Objects
    7.5.1. 自动对象
    By default, the lifetime of a local variable is limited to the duration of a single execution of the function. Objects that exist only while a function is executing are known as automatic objects. Automatic objects are created and destroyed on each call to a function.

    默认情况下,局部变量的生命期局限于所在函数的每次执行期间。只有当定义它的函数被调用时才存在的对象称为自动对象。自动对象在每次调用函数时创建和撤销。

    The automatic object corresponding to a local variable is created when the function control path passes through the variable's definition. If the definition contains an initializer, then the object is given an initial value each time the object is created. Uninitialized local variables of built-in type have undefined values. When the function terminates, the automatic objects are destroyed.

    局部变量所对应的自动对象在函数控制经过变量定义语句时创建。如果在定义时提供了初始化式,那么每次创建对象时,对象都会被赋予指定的初值。对于未初始化的内置类型局部变量,其初值不确定。当函数调用结束时,自动对象就会撤销。

    Parameters are automatic objects. The storage in which the parameters reside is created when the function is called and is freed when the function terminates.

    形参也是自动对象。形参所占用的存储空间在调用函数时创建,而在函数结束时撤销。

    Automatic objects, including parameters, are destroyed at the end of the block in which they were defined. Parameters are defined in the function's block and so are destroyed when the function terminates. When a function exits, its local storage is deallocated. After the function exits, the values of its automatic objects and parameters are no longer accessible.

    自动对象,包括形参,都在定义它们的块语句结束时撤销。形参在函数块中定义,因此当函数的执行结束时撤销。当函数结束时,会释放它的局部存储空间。在函数结束后,自动对象和形参的值都不能再访问了。

    7.5.2. Static Local Objects
    7.5.2. 静态局部对象
    It is can be useful to have a variable that is in the scope of a function but whose lifetime persists across calls to the function. Such objects are defined as static.

    一个变量如果位于函数的作用域内,但生命期跨越了这个函数的多次调用,这种变量往往很有用。则应该将这样的对象定义为 static(静态的)。

    A static local object is guaranteed to be initialized no later than the first time that program execution passes through the object's definition. Once it is created, it is not destroyed until the program terminates; local statics are not destroyed when the function ends. Local statics continue to exist and hold their value across calls to the function. As a trivial example, consider a function that counts how often it is called:

    static 局部对象确保不迟于在程序执行流程第一次经过该对象的定义语句时进行初始化。这种对象一旦被创建,在程序结束前都不会撤销。当定义静态局部对象的函数结束时,静态局部对象不会撤销。在该函数被多次调用的过程中,静态局部对象会持续存在并保持它的值。考虑下面的小例子,这个函数计算了自己被调用的次数:

    size_t count_calls()
    {
    static size_t ctr = 0; // value will persist across calls
    return ++ctr;
    }
    int main()
    {
    for (size_t i = 0; i != 10; ++i)
    cout << count_calls() << endl;
    return 0;
    }



    This program will print the numbers from 1 through 10 inclusive.

    这个程序会依次输出 1 到 10(包含 10)的整数。

    Before count_calls is called for the first time, ctr is created and given an initial value of 0. Each call increments ctr and returns its current value. Whenever count_calls is executed, the variable ctr already exists and has whatever value was in the variable the last time the function exited. Thus, on the second invocation, the value is 1, on the third it is 2, and soon.

    在第一次调用函数 count_calls 之前,ctr 就已创建并赋予初值 0。每次函数调用都使加 1,并且返回其当前值。在执行函数 count_calls 时,变量 ctr 就已经存在并且保留上次调用该函数时的值。因此,第二次调用时,ctr 的值为 1,第三次为 2,依此类推。
     
     
    展开全文
  • 1、局部变量能否和全局变量重名?  答:能,局部会屏蔽全局。要用全局变量,需要使用 ":: "  局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器...
  • 全局变量与局部变量同名,则在局部变量的作用范围内,全局变量被屏蔽。全局变量增加了程序的耦合度,如果一个全局变量可以被多个要限制使用全局变量!局部变量Local Variable不同的函数及作用域中可以使用相同名字的...
  • 局部变量 什么是局部变量 通俗定义:函数内部定义的变量就叫局部变量。 话不多说,代码如下: def test1(): a = 300 # 定义一个局部变量a,并初始化300 print(--test1--修改前:a=%s % a) a = 200 # 给变量a重新...
  • 红字部分,不输出,我知道是因为j是局部变量。但是后面的i,k都是全局变量为什么也不输出?我把红字部分分别放到后面两行中间和两行的后面,都能正常打印。继续研究。。。 经大神告知,js 只要一块出错,后面就不...
  • 一、普通全局变量和普通局部变量的关系 通常情况下,如果有两个同名变量,一个是普通全局变量,另一个是普通局部变量,那么局部变量在其作用域内具有较高的优先权,它将屏蔽全局变量。 #include #include int ...
  • SQL SERVER 局部变量

    千次阅读 2016-05-18 22:46:10
    局部变量: 以“@”开头的标识符表示变量(局部变量),该变量必须先用DECLARE命令声明后才能使用:DECLARE @js_age int; DECLARE @name varchar(32), @address varchar(64);使用DECLARE命令并创建局部变量后,初始...
  • python的 局部变量和全局变量

    万次阅读 多人点赞 2017-07-31 19:12:06
    全局变量:所有函数之外定义的变量局部变量:函数内部定义的变量 或者代码块里的变量1.函数内部的变量名如果第一次出现,且出现在=前面,即被视为定义了一个局部变量,不管全局域中有没有该变量名,函数中使用的将是...
  • 1、前言 相信同学们一定懵逼过,那是,不懵逼就不正常了,现在由我为了大家在轻松的氛围... b、局部变量:在函数内、在class的方法(构造、类方法、静态方法、实例方法)内(变量未加self修饰),这就是局部变量 ...
  • 如果java的成员变量和局部变量重名 JAVA会用局部变量覆盖掉成员 只看楼主 收藏 回复 iehshx 淼沝 5 怎么样才能让两个变量都输出呢...
  • 通常情况下,如果有两个同名变量,一个是全局变量,另一个...在main函数的输出语句中,使用的变量num是main函数内定义的局部变量,因此输出的结果为局部变量num的值。 作用域运算符可以用来解决局部变量与全局变量的重
  • python中全局变量和局部变量详解

    万次阅读 多人点赞 2018-11-13 12:18:46
    python中全局变量和局部变量的最大区别在于局部变量只能通过函数去访问,而全局变量可以直接访问。 !!! 我们先来看一个最简单的例子,事实上这并不是一个真正的全局变量,只是在类中的一个变量。 !!! 我们...
  • C语言静态局部变量

    千次阅读 2016-11-19 20:20:14
    用static声明局部变量,有时我们希望局部变量的值在函数调用结束后不消失而保留原值,即其占用的存储单元不释放,在下一次该函数调用时,该变量已有值。这时就应该指定该局部变量为“静态局部变量”,用关键字static...
  • 面向对象主要用到的两种类型的变量: 成员变量和局部变量。 一、成员变量 在类中定义,用来描述对象将会有什么 二、局部变量 在类的方法中定义,在方法中用于临时保存数据 三、成员变量和局部变量的区别 1、...
  • 本文主要讲述全局变量、局部变量和导入模块变量的方法。 参考:《Python核心编程 (第二版)》 一. 局部变量 声明适用的程序的范围被称为了声明的作用域。在一个过程中,如果名字在过程的声明之内,它的出现即为过程的...
  • 理解全局变量和局部变量 1.定义的函数内部的变量名如果是第一次出现, 且在=符号前,那么就可以认为是被定义为局部变量。在这种情况下,不论全局变量中是否用到该变量名,函数中使用的都是局部变量。例如: num =...
  • java虚拟机 jvm 局部变量表实战

    千次阅读 热门讨论 2016-04-02 12:48:36
    java局部变量表是栈帧重要组中部分之一。他主要保存函数的参数以及局部的变量信息。局部变量表中的变量作用域是当前调用的函数。函数调用结束后,随着函数栈帧的销毁。局部变量表也会随之销毁,释放空间。 由于局部...
  • python3的全局变量和局部变量

    千次阅读 2018-11-19 20:47:03
    局部变量 定义在函数体内部的变量称为局部变量 函数的形参也是局部变量 局部变量的作用范围只在声明该局部变量的函数体内 局部变量在函数调用时被创建,在函数调用完成后自动销毁 全局变量 定义在函数体外,...
  • 1、局部变量能否和全局变量重名?  答:能,局部会屏蔽全局。要用全局变量,需要使用"::" ;局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器而言...
  • 成员变量和局部变量区别

    千次阅读 多人点赞 2020-06-18 17:13:43
    成员变量和局部变量区别 在类中的位置不同 成员变量:在类中方法外面 局部变量:在方法或者代码块中,或者方法的声明上(即在参数列表中) 在内存中的位置不同 成员变量:在堆中(方法区中静态区),成员变量属于...
  • python的局部变量和全局变量区别

    千次阅读 2018-01-16 15:37:59
    1.函数内部的变量名如果第一次出现,且出现在=前面,即被视为定义了一个局部变量,不管全局域中有没有该变量名,函数中使用的将是局部变量。 (即声明了一个新的局部变量。如果这个变量名字和全部变量名字相同,...
  • 多线程-局部变量和成员变量

    千次阅读 2017-09-06 11:14:00
    Java多线程对成员变量和局部变量的影响最近复习了一下Java多线程的一些基础的础知识,这里演示一个java多线程对成员变量和局部变量的Demo对局部变量的操作:/** * Java局部变量和成员变量代码演示 */ public class ...
  • Python局部变量和全局变量区别

    千次阅读 2018-05-29 15:31:52
    局部变量: 在函数内、在class的方法内(未加self修饰),这就是局部变量 2. 如何使用: 在def中,我们可以定义一个局部变量,该变量仅仅在函数体中有生存期,出了这个函数体,变量就不能使用了。 def fun(): ...
  • 实例: string s1 = “hello world”; private void button1_Click(object sender, ... 局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器而言...
  • 在不同作用域内声明的变量可以同名,但如果局部变量和全局变量同名,在局部变量作用域内如何访问全局变量?C语言没有提供同名情况下访问全局变量的方法。在C++中,可以通过使用作用域限定符(::)(scope resolution ...
  • 关于局部变量

    千次阅读 2018-06-15 01:56:53
    我们都知道,局部变量在使用前必须赋初值。那么什么是使用?什么是赋初值?赋初值就是直接给变量赋值,比如:int a=3;那么什么是使用局部变量呢?比如:Debug.Log("a"+a);输出a的值,也就是获取a的值,...
  • 形参、普通(非静态)局部变量和静态局部变量差别---求取指定整数间阶乘 1.形参、局部变量和静态局部变量的差别。 从本质上说,三者均属于局部作用域中的变量,其中,局部变量又可以分为普通(非静态)局部变量和静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 307,238
精华内容 122,895
关键字:

局部变量怎么输出