精华内容
下载资源
问答
  • 怎么做:当局部变量与全局变量同名时局部变量的作用域内,可以通过关键字this来引用成员变量。 特别注意:关键字this代表的是一个对象,只能用在非静态中,不能用在静态中,因为在静态中this可能是类名也可能是...

    怎么做:当局部变量与全局变量同名时在局部变量的作用域内,可以通过关键字this来引用成员变量。

    特别注意:关键字this代表的是一个对象,只能用在非静态中,不能用在静态中,因为在静态中this可能是类名也可能是对象,因此在编译时会报错,如果需要,可以通过对象去访问成员变量

    代码说明:

    public class Test {
    	int x=1;
    	static void show() {
    		int x=2;
    		System.out.println("局部变量:"+x);
    		//System.out.println(this.x);//程序在编译时报错,this只能是对象,而在这里this可能是对象也可能是类名,具有不确定性
    		System.out.println("全局变量:"+new Test().x);//可以通过创造对象的方式去访问全局变量
    	}
    	
    	void view() {
    		int x=2;
    		System.out.println("局部变量:"+x);
    		System.out.println("全局变量:"+this.x);//编译不会出错,此时方法为非静态
    	}
    }


     

     

     

    展开全文
  • 局部变量与全局变量同名时,在定义局部变量的子程序内局部变量其作用;其他地方全局变量起作用。 #!/usr/bin/env python # -*- coding:utf-8 -*- # Author:ZhengzhengLiu school = "Qing hua" #全局变量
  • 局部变量与全局变量

    2021-01-08 11:31:01
    局部变量与全局变量的关系是一个非常重要且细致的问题,在这方面,稍不注意就非常容易出问题。现稍作总结。 变量的作用域 变量的作用域是指变量的使用范围。根据变量的作用域,可以将变量分为局部变量与全局变量。 ...

    局部变量与全局变量的关系是一个非常重要且细致的问题,在这方面,稍不注意就非常容易出问题。现稍作总结。

    变量的作用域

    变量的作用域是指变量的使用范围。根据变量的作用域,可以将变量分为局部变量与全局变量。

    局部变量

    在一个函数内复合语句内定义的变量称为局部变量。此外,函数的形参也属于局部变量。
    局部变量只允许在其定义的函数或复合语句中使用,离开所在的函数或复合语句后该局部变量将不能使用。

    • main()函数中定义的变量不能在其余的函数中使用。
    • 复合语句中定义的变量只能在该复合语句中使用
    • for()循环中定义的变量只能在该循环语句中使用

    重要说明
    局部变量是在执行该函数或复合语句时自动建立,当该函数或复合语句执行完毕后将自动释放。所以在不同的函数或复合语句中定义同名的局部变量,也不会相互干扰。

    全局变量

    全局变量声明与所有函数之外,可以被所有函数使用。

    #include <iostream>
    using namespace std;
    
    int a=3,b=5;//定义了全局变量a,b
    
    int fun(int a,int b)//函数形参也是a,b
    {
        return a>b?a:b;
    }
    
    int main()
    {
        int a=8;//在main()中定义了局部变量a
        cout<<fun(a,b);//输出a,b中的最大值
        return 0;
    }
    //运行结果
    8
    

    在上述代码中定义了全局变量a、b,又在main()中定义了局部变量a,这是被允许的。并且,在main()中调用了fun()函数,且实参为main()中定义的a与全局变量b,注意,fun()是在main()中调用的,其实参为main()中的a,并非是全局变量a。所以实际上传递的参数的值为fun(8,5),而不是fun(3,5)。
    系统规定,当局部变量与全局变量同名时,在该函数或者复合语句内,局部变量优先于全局变量,也即“局部变量优先”原则。
    在这种情况下,即在函数或者复合语句内有和全局变量同名的变量时,当想使用全局变量,需要在变量前加作用域运算符“::”。

    #include <iostream>
    using namespace std;
    
    int a=3;//定义了全局变量a
    
    int main()
    {
        int a=8;//在main()中定义了局部变量a
        cout<<::a;//输出全局变量a
        return 0;
    }
    //运行结果
    3
    
    展开全文
  • UINT8 acc_tab_sta = acc->acc_tab_sta; static void hmi_adas_root_callback_on_status(ndm_node_t *self, ndm_evt_t *in_status) { UINT8 acc_tab_sta = 0; switch (NodeMsgGetEvent(in_status)) ...
  • 一、局部变量与全局变量 python引用变量的顺序:当前作用域局部变量->外层作用域变量->... 当全局变量与局部变量同名时,在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用 ...

    一、局部变量与全局变量

    python引用变量的顺序: 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量

    • 在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。
    • 全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序。
    • 当全局变量与局部变量同名时,在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用

    (1)局部变量外部访问

    def change_name():
        name = '局部变量'
        print('函数内部修改name值为:', name)
    
    
    change_name()
    print('函数外部打印name的值为:', name)
    
    """
    运行结果:
    函数内部修改name值为: 局部变量
        print('函数外部打印name的值为:', name)
    NameError: name 'name' is not defined
    
    """

    说明:报错可以看出,在外部访问函数内部的局部变量是不可行的,因为局部变量name的作用域只在change_name()中

    (2)函数内部访问全局变量且修改全局变量

    def change_name(name):
        print('函数内部修改name值之前为:', name)
        name = '局部变量'
        print('函数内部修改name值为:', name)
    
    
    change_name(name)
    print('函数外部打印name的值为:', name)
    
    """
    运行结果:
    函数内部修改name值之前为: 全局变量
    函数内部修改name值为: 局部变量
    函数外部打印name的值为: 全局变量
    """

    说明:可以看到在函数内部对全局变量的修改后,在函数执行完毕,修改的结果是无效的,全局变量并不会受到影响

    ????????老夫不能接受这个肤浅的解释,那我们打印出变量的内存地址试试

    def change_name(name):
        print('函数内部修改name值之前为的内存地址为:', id(name))
        name = '局部变量'
        print('函数内部修改name值之后的内存地址为:',id(name))
    
    
    change_name(name)
    print('函数外部打印name的内存地址值为:', id(name))
    
    """
    运行结果:
    函数内部修改name值之前为的内存地址为: 2147662653208
    函数内部修改name值之后的内存地址为: 2147663637912
    函数外部打印name的内存地址值为: 2147662653208
    """

    说明:任性的我这下明白了,在函数内部修改之后,会在内存中重新开辟一块内存地址,与之前外面的全局变量的地址不搭嘎啊,所以不会影响全局变量的值

    (3)全局与局部变量名一样

    说明:因为在change_name()函数使用了局部变量name,它只是个跟全局变量同名的局部变量,使用前还是要赋值,不赋值就使用就是不合法,再或者说:如果内部函数有引用外部函数的同名变量或者全局变量,并且对这个变量有修改.那么python会认为它是一个局部变量,又因为函数中没有name的定义和赋值,所以报错,但是如果你不修改,那么不会报错

    二:全局/局部变量中的复杂数据类型

    name = [1, 2, 3, 4]
    
    
    def change_name():
        print('函数内部打印name[0]的内存地址:', id(name[0]))
        name[0] = name[0] + 1
        print('函数内部打印name[0]的内存地址:', id(name[0]))
        print('函数内部打印name[0]的值:', name[0])
    
    
    change_name()
    print('函数外部打印name[0]的内存地址:', id(name[0]))
    print('函数外部打印name[0]的值:', name[0])
    
    """
    运行结果:
    函数内部打印name[0]的内存地址: 140719482123088
    函数内部打印name[0]的内存地址: 140719482123120
    函数内部打印name[0]的值: 2
    函数外部打印name[0]的内存地址: 140719482123120
    函数外部打印name[0]的值: 2
    """

    说明:可以看出这里在函数内部修改全局变量可以,并且修改之后,全局变量的值也改变了,根据运行结果可以看出,其实操作的都是同一块内存地址的值,特别说明:复杂的数据类型;如列表,字典,集合,类,都可以函数内部修改

    三、关键字global与nonlocal的使用

    特别说明:千万不要在函数内部强制性修改全局变量本身的值,你不知道有多少个地方引用这个全局变量,万一出了问题,调试到你想死

    (1)A:在函数里面修改全局变量本身

    name = '全局变量'
    def change_name(n):
        global name
        name = n
        print('函数内部打印name的值:', name)
        print('函数内部打印name的内存地址值:', id(name))
    
    
    change_name('global')
    print('函数外部打印name的值:', name)
    print('函数外部打印name的内存地址:', id(name))
    
    
    """
    运行结果:
    函数内部打印name的值: global
    函数内部打印name的内存地址值: 2170632629640
    函数外部打印name的值: global
    函数外部打印name的内存地址: 2170632629640
    """

    说明:可以看书这里修改是同一块内存地址的变量值,使用global关键字就是告诉python编译器这个变量不是局部变量而是全局变量,其实有点像是"引用"的意思

    B: 多层函数嵌套变量使用

    说明:使用了未定义的局部变量,然而num1也不是全局变量,只是count2函数的外层变量,强行使用global定义num1的话同样会报错

    C:多层函数嵌套使用global(回答了上面B中为什么强行添加global,也会报错)

    说明:在函数count2内 global 定义的变量 num1,只能在 函数 count2内引用, 如果要在 add_one内修改,必须在 add_one 函数里面声明 再global  num1 ,表明是修改外面的 全局变量 num1.相当于你声明了,才能引用修改(2)

    (3)nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

    def count2(n):
        num1=n
        print('外层变量num1的内存地址:',id(num1))
    
        def add_one():
            nonlocal num1
            print('内层变量num1的内存地址:', id(num1))
            num1 += 1
            return num1
    
        return add_one()
    
    
    num3 = count2(4)
    """
    运行结果:
    外层变量num1的内存地址: 140719532454832
    内层变量num1的内存地址: 140719532454832
    """

    说明: nonlocal  适用于在局部函数 中 的局部函数, 把最内层的局部 变量设置成外层局部可用,但是:但是还不是全局的,故不能在外部引用该变量

    展开全文
  • 1、局部变量与全局变量定义: 在子程序(函数)中定义的变量称为:局部...当局部变量与全局变量同名时,在定义局部变量的子程序内局部变量其作用;其他地方全局变量起作用。 #!/usr/bin/env python # -*- coding:utf-

    1、局部变量与全局变量定义:

    子程序(函数)中定义的变量称为:局部变量;在程序顶级(一开始)定义的变量称为:全局变量

    2、局部变量与全局变量作用域:

    局部变量作用域:定义该变量的子程序;全局变量作用域:整个程序

    当局部变量与全局变量同名时,在定义局部变量的子程序内局部变量其作用;其他地方全局变量起作用。

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    # Author:ZhengzhengLiu
    
    school = "Qing hua"       #全局变量
    def change_name(name):
        school = "Bei da"    #局部变量
        print(school)
        print("before change:",name)
        name = "LIU"    #局部变量,只在函数内部生效(局部变量的作用域就是定义该变量的子程序)
        print("after change:",name)
    
    print(school)
    name = "liu"        #全局变量,在整个程序中都有效
    change_name(name)
    print(name)
    
    #运行结果:
    #Qing hua
    #Bei da
    #before change: liu
    #after change: LIU
    #liu
    注:在函数内部要将局部变量修改为全局变量,需要用 global声明(不要这样用:程序多处调用时会导致逻辑混乱,不利于调试)。
    school = "Qing hua"       #全局变量
    def change_name(name):
        print("before change:",name)
        name = "LIU"    #局部变量,只在函数内部生效(局部变量的作用域就是定义该变量的子程序)
        print("after change:",name)
        global school        # 函数内将局部变量改为全局变量用global声明
        school = "Bei da"  
    
    name = "liu"        #全局变量,在整个程序中都有效
    change_name(name)
    print(name)
    print("school:",school)
    
    #运行结果:
    #before change: liu
    #after change: LIU
    #liu
    #school: Bei da
    3、除了整数和字符串, 列表、字典、集合、类中可以在子程序中(子函数)通过修改局部变量达到修改全局变量的目的
    names = ["liu","zhang","wang"]
    def chang_name():
        names[0] = "sun"
        print(names)
    
    chang_name()
    print(names)
    
    #运行结果:
    #['sun', 'zhang', 'wang']
    #['sun', 'zhang', 'wang']

    注:在Python中, Ctrl+?快捷键可以实现多行注释


    展开全文
  • 1.变量: 在内存中用来存储数据开辟的那块空间局部变量:定义在函数内部的变量,就是局部变量全局变量:定义在函数外部的变量2.异同点相同点: 多少变量,都是在内存中开辟一块空间来存储数据不同点:1). 声明的位置不同 , ...
  • 局部变量全局变量

    2016-03-16 21:59:18
    3.当局部变量与全局变量同名时,在C语言中,局部变量会屏蔽全局变量。在函数内引用这个变量,会用到同名的局部变量,而不会用到全局变量。 4.在定义的局部变量的子程序内,局部变量起作用;在其他的地方全局变量起...
  • 全局变量与局部变量同名,则在局部变量的作用范围内,全局变量被屏蔽。全局变量增加了程序的耦合度,如果一个全局变量可以被多个要限制使用全局变量!局部变量Local Variable不同的函数及作用域中可以使用相同名字的...
  • Python局部变量与全局变量

    千次阅读 2013-05-18 21:27:25
    Python中的局部全局与全局变量主要体现在函数内的变量函数外的变量。 局部与全局就是变量的作用域(作用范围)。 当你在函数内部定义变量的时候,它们函数外具有相同名称的变量没有任何关系,即变量对于函数来...
  • /**********************************************...*函数内部定义的局部变量与全局变量重名,函数在使用该变量的时候会以局部变量覆盖全局变量,也就是只有局部变量会起效果。 ********************************...
  • 其他都可以在函数中修改#在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量#全局变量作用域是整个程序,而局部变量作用域是定义该变量的子程序#当全局变量与局部变量同名时:在定义局部变量...
  • 局部变量与全局变量 局部变量是在函数内
  • C++局部变量 C++局部变量是指:在一个函数内部定义的变量,它只在本函数范围内有效,也就是说只有在本函数内才能使用它,在此函数以外是不能使用这些变量的。 同样,在复合语句中定义的变量只在本复合语句范围内有效...
  • 全局变量与局部变量同名时: 在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。 简而言之,谁的作用域越小,在共有作用域内,谁就越大 全局变量 我们需要在整个程序中使用某个变量,定义的...
  • 初学c语言,总会被一些关于变量的区别所困扰,比如这次所要阐述的局部变量与全局变量的问题。  首先我们应该搞清楚,局部变量全局变量的划分。  在学习变量,我们知道,形参是只在函数内有效的一种参数。...
  • 局部变量与全局变量区别

    千次阅读 2016-12-09 23:02:02
    局部变量:在使用之前必须赋初始值。  例如:int var = 0;  System.out.println(var);...按存储区域分,全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域,局部变量存放在内存的
  • 换言之,在一个函数内部定义的变量是内部变量,它只在本函数范围内有效,也就是说只有在本函数内才能使用它们,在此函数以外不能使用这些变量的,它们称为局部变量全局变量 定义:在函数外定义的变量是外部变量...
  • JS笔记:局部变量与全局变量1.JavaScript中,变量无需事先声明可以直接使用,并且都是动态类型,类型可以随时更改,但它也具有局部变量全局变量之分:脚本中直接定义的变量是全局变量,函数中定义的变量是局部变量
  • 笔记:如果将main内改为“int i=::i;”,答案就会是B,因为将全局变量i的值赋给了main内的局部变量
  • #由于name在此函数之前已经被定义为全局变量,此处函数读取变量name是读取的全局变量name “xxx”,函数内部就不能再定义其同名局部变量,否则无法区分变量为局部变量还是全局变量 # name = yyy #此语句放开以后会...
  • 全局变量 全局变量默认初始化为0,字符型变量为空字符’’ 定义在函数外,可被本文件及其他文件的函数使用...同一文件中全局变量局部变量可以同名,在局部变量作用域内,全局变量不起作用 静态全局变量 静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,748
精华内容 38,299
关键字:

局部变量与全局变量同名时