精华内容
下载资源
问答
  • C语言中变量的声明和定义

    万次阅读 多人点赞 2018-03-21 18:30:45
    程序中变量有且仅有一个定义变量声明:用于向程序表明变量的类型和名字。定义也是声明,extern声明不是定义定义也是声明:当定义变量时我们声明了它的类型和名字。extern声明不是定义:通过使用extern关键字声明...

    变量声明和变量定义


    • 变量定义:用于为变量分配存储空间,还可为变量指定初始值。程序中,变量有且仅有一个定义。

    • 变量声明:用于向程序表明变量的类型和名字。

    • 定义也是声明,extern声明不是定义

    • 定义也是声明:当定义变量时我们声明了它的类型和名字。
    • extern声明不是定义:通过使用extern关键字声明变量名而不定义它。
      [注意]
      变量在使用前就要被定义或者声明。
      在一个程序中,变量只能定义一次,却可以声明多次。
      定义分配存储空间,而声明不会。
       C++程序通常由许多文件组成,为了让多个文件访问相同的变量,C++区分了声明和定义。
    
        变量的定义(definition)用于为变量分配存储空间,还可以为变量指定初始值。在程序中,变量有且仅有一个定义。
    
        声明(declaration)用于向程序表明变量的类型和名字。定义也是声明:当定义变量的时候我们声明了它的类型和名字。可以通过使用extern声明变量名而不定义它。不定义变量的声明包括对象名、对象类型和对象类型前的关键字extern。
    
        extern声明不是定义,也不分配存储空间。事实上它只是说明变量定义在程序的其他地方。程序中变量可以声明多次,但只能定义一次。
    
        只有当声明也是定义时,声明才可以有初始化式,因为只有定义才分配存储空间。初始化式必须要有存储空间来进行初始化。如果声明有初始化式,那么它可被当作是定义,即使声明标记为extern。
    
        任何在多文件中使用的变量都需要有与定义分离的声明。在这种情况下,一个文件含有变量的定义,使用该变量的其他文件则包含该变量的声明(而不是定义)。
    

    如何清晰的区分变量声明和定义


    extern通知编译器变量在其他地方被定义


    1.extern告诉编译器变量在其他地方定义了。

    例如:

    extern int i;       //声明,不是定义
    int i;              //声明,也是定义,未初始化

    带有初始化式的声明必定式定义


    2.如果声明有初始化式,就被当作定义,即使前面加了extern。
    只有当extern声明位于函数外部时,才可以被初始化。

    例如:

    extern double pi=3.141592654;  //定义

    函数的声明和定义


    3.函数的声明和定义区别比较简单,带有{ }的就是定义,否则就是声明。

    例如:

    extern double max(double d1,double d2);  //声明

    除非有extern关键字,否则都是变量的定义。


    4.除非有extern关键字,否则都是变量的定义。

    例如:

    extern int i; //声明
    int i; //定义          

    程序模块化设计风格


    概要


    1. 不要把变量定义放入.h文件,这样容易导致重复定义错误。
    
    永远不要在.h文件中定义变量。定义变量和声明变量的区别在于定义会产生内存分配的操作,是汇编阶段的概念;而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量
    
    2. 尽量使用static关键字把变量定义限制于该源文件作用域,除非变量被设计成全局的。
    
    3. 可以在头文件中声明一个变量,在用的时候包含这个头文件就声明了这个变量。

    模块化要点


     (1) 模块即是一个.c文件和一个.h文件的结合,头文件(.h)中是对于该模块接口的声明;
    
    (2) 某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明;
    
    (3) 模块内的函数和全局变量需在.c文件开头冠以static关键字声明;
    
    (4) 永远不要在.h文件中定义变量!定义变量和声明变量的区别在于定义会产生内存分配的操作,是汇编阶段的概念;而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。
    

    一般情况下头文件中只放变量的声明,因为头文件要被其他文件包含(即#include),如果把定义放到头文件的话,就不能避免多次定义变量,C++不允许多次定义变量,一个程序中对指定变量的定义只有一次,声明可以无数次。

    不过有三个例外,一下三中实体的定义也可放到头文件中。

    1.值在编译时就已知的const 变量的定义可以放到头文件中
    如:const int num(10);
    2.类的定义可以放到头文件中
    3.inline 函数
    

    这三个实体可以定义在多个源文件中,只要在每个源文件中的定义相同。

    示例程序


    #include <stdio.h>
    #include <stdlib.h>
    
    //  是定义,定义了A为整型的外部变量
    //  C中定义的变量默认就是extern的,
    //  因此一般来说int a = 10 <==> extern int a = 10;
    /*extern */int a = 10;
    //如果声明有初始化式,就被当作定义,即使前面加了extern。
    //只有当extern声明位于函数外部时,才可以被初始化。
    
    int main(void)
    {
        extern int  a;           //  声明一个外部extern的int型变量a
        //  这是个声明而不是定义,声明A是一个已经定义了的外部变量
        //  注意:声明外部变量时可以把变量类型去掉如:extern a;
        printf("a = %d\n", a);
    
    
    
        return EXIT_SUCCESS;
    }
    

    这里写图片描述

    在这个程序中,我们再函数外部定义了一个变量
    注extern int a = 10;只有当extern声明位于函数外部时,才可以被初始化。
    我们后面还会提到这个问题

    #include <stdio.h>
    #include <stdlib.h>
    
    
    
    int main(void)
    {
        int a;                  //  定义一个变量, 不初始化
        int b = 10;             //  定义一个变量, 同时进行初始化
        extern int  c;          //  声明一个外部extern的int型变量a
    
        printf("a = %d\n", a);
        printf("b = %d\n", b);
        printf("c = %d\n", c);
    
        extern int d = 10;
    
    
        return EXIT_SUCCESS;
    }
    

    在这个程序中,

    int a;是个定义,但是未初始化,打印他的值式不确定的,因此编译时会报未初始化的异常。

    int b = 10; 是个定义,并且被正确初始化,打印b的值没有问题。

    这里写图片描述

    但是是个声明,如果要对c进行读写操作,而我们并没有对c进行定义,因此语法检查没有问题,但是在链接时,连接器会找不到c的地址。

    这里写图片描述

    对于d再明显不过了,前面我们提到过如果声明有初始化式,就被当作定义,即使前面加了extern。但是只有当extern声明位于函数外部时,才可以被初始化。

    现在这个定义很明显被gcc编译器认为是错误的。

    这里写图片描述

    点击打开链接 点击打开链接 点击打开链接

    展开全文
  • C语言中变量声明和变量定义的区别

    千次阅读 2019-04-24 10:11:49
    程序中变量有且仅有一个定义变量声明:用于向程序表明变量的类型和名字。 定义也是声明,extern声明不是定义 定义也是声明:当定义变量时我们声明了它的类型和名字。 extern声明不是定义:通过使用exte.....

    本文转载至CSDN博客JeanCheng

    变量声明和变量定义


    • 变量定义:用于为变量分配存储空间,还可为变量指定初始值。程序中,变量有且仅有一个定义。

    • 变量声明:用于向程序表明变量的类型和名字。

    • 定义也是声明,extern声明不是定义

    • 定义也是声明:当定义变量时我们声明了它的类型和名字。
    • extern声明不是定义:通过使用extern关键字声明变量名而不定义它。
      [注意]
      变量在使用前就要被定义或者声明。
      在一个程序中,变量只能定义一次,却可以声明多次。
      定义分配存储空间,而声明不会。
       C++程序通常由许多文件组成,为了让多个文件访问相同的变量,C++区分了声明和定义。
    
        变量的定义(definition)用于为变量分配存储空间,还可以为变量指定初始值。在程序中,变量有且仅有一个定义。
    
        声明(declaration)用于向程序表明变量的类型和名字。定义也是声明:当定义变量的时候我们声明了它的类型和名字。可以通过使用extern声明变量名而不定义它。不定义变量的声明包括对象名、对象类型和对象类型前的关键字extern。
    
        extern声明不是定义,也不分配存储空间。事实上它只是说明变量定义在程序的其他地方。程序中变量可以声明多次,但只能定义一次。
    
        只有当声明也是定义时,声明才可以有初始化式,因为只有定义才分配存储空间。初始化式必须要有存储空间来进行初始化。如果声明有初始化式,那么它可被当作是定义,即使声明标记为extern。
    
        任何在多文件中使用的变量都需要有与定义分离的声明。在这种情况下,一个文件含有变量的定义,使用该变量的其他文件则包含该变量的声明(而不是定义)。
    

    如何清晰的区分变量声明和定义


    extern通知编译器变量在其他地方被定义


    1.extern告诉编译器变量在其他地方定义了。

    例如:

    extern int i;       //声明,不是定义
    int i;              //声明,也是定义,未初始化
      
    • 1
    • 2

    带有初始化式的声明必定式定义


    2.如果声明有初始化式,就被当作定义,即使前面加了extern。
    只有当extern声明位于函数外部时,才可以被初始化。

    例如:

    extern double pi=3.141592654;  //定义
     
    • 1

    函数的声明和定义


    3.函数的声明和定义区别比较简单,带有{ }的就是定义,否则就是声明。

    例如:

    extern double max(double d1,double d2);  //声明
     
    • 1

    除非有extern关键字,否则都是变量的定义。


    4.除非有extern关键字,否则都是变量的定义。

    例如:

    extern int i; //声明
    int i; //定义          
     
    • 1
    • 2

    程序模块化设计风格


    概要


    1. 不要把变量定义放入.h文件,这样容易导致重复定义错误。
    
    永远不要在.h文件中定义变量。定义变量和声明变量的区别在于定义会产生内存分配的操作,是汇编阶段的概念;而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量
    
    2. 尽量使用static关键字把变量定义限制于该源文件作用域,除非变量被设计成全局的。
    
    3. 可以在头文件中声明一个变量,在用的时候包含这个头文件就声明了这个变量。
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    模块化要点


     (1) 模块即是一个.c文件和一个.h文件的结合,头文件(.h)中是对于该模块接口的声明;
    
    (2) 某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明;
    
    (3) 模块内的函数和全局变量需在.c文件开头冠以static关键字声明;
    
    (4) 永远不要在.h文件中定义变量!定义变量和声明变量的区别在于定义会产生内存分配的操作,是汇编阶段的概念;而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    一般情况下头文件中只放变量的声明,因为头文件要被其他文件包含(即#include),如果把定义放到头文件的话,就不能避免多次定义变量,C++不允许多次定义变量,一个程序中对指定变量的定义只有一次,声明可以无数次。

    不过有三个例外,一下三中实体的定义也可放到头文件中。

    1.值在编译时就已知的const 变量的定义可以放到头文件中
    如:const int num(10);
    2.类的定义可以放到头文件中
    3.inline 函数
    
     
    • 1
    • 2
    • 3
    • 4

    这三个实体可以定义在多个源文件中,只要在每个源文件中的定义相同。

    示例程序


    #include <stdio.h>
    #include <stdlib.h>
    
    //  是定义,定义了A为整型的外部变量
    //  C中定义的变量默认就是extern的,
    //  因此一般来说int a = 10 <==> extern int a = 10;
    /*extern */int a = 10;
    //如果声明有初始化式,就被当作定义,即使前面加了extern。
    //只有当extern声明位于函数外部时,才可以被初始化。
    
    int main(void)
    {
        extern int  a;           //  声明一个外部extern的int型变量a
        //  这是个声明而不是定义,声明A是一个已经定义了的外部变量
        //  注意:声明外部变量时可以把变量类型去掉如:extern a;
        printf("a = %d\n", a);
        return EXIT_SUCCESS;
    }
    

    这里写图片描述

    在这个程序中,我们再函数外部定义了一个变量
    注extern int a = 10;只有当extern声明位于函数外部时,才可以被初始化。
    我们后面还会提到这个问题

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void)
    {
        int a;                  //  定义一个变量, 不初始化
        int b = 10;             //  定义一个变量, 同时进行初始化
        extern int  c;          //  声明一个外部extern的int型变量a
    
        printf("a = %d\n", a);
        printf("b = %d\n", b);
        printf("c = %d\n", c);
    
        extern int d = 10;
    
    
        return EXIT_SUCCESS;
    }
    

    在这个程序中,

    int a;是个定义,但是未初始化,打印他的值式不确定的,因此编译时会报未初始化的异常。

    int b = 10; 是个定义,并且被正确初始化,打印b的值没有问题。

    这里写图片描述

    但是是个声明,如果要对c进行读写操作,而我们并没有对c进行定义,因此语法检查没有问题,但是在链接时,连接器会找不到c的地址。

    这里写图片描述

    对于d再明显不过了,前面我们提到过如果声明有初始化式,就被当作定义,即使前面加了extern。但是只有当extern声明位于函数外部时,才可以被初始化。

    现在这个定义很明显被gcc编译器认为是错误的。

    这里写图片描述

    展开全文
  • 我在函数的初始化初始化了,但是开始可以运行,但是一段时间后会报错,使用的变量没有定义,错误截图 最后发现:程序在调用函数的时候,会使用该变量,我用该变量存了一个数,下...正确的方法是将该变量定义为全局

    我在函数的初始化初始化了,但是开始可以运行,但是一段时间后会报错,使用的变量没有定义,错误截图


    最后发现:程序在调用函数的时候,会使用该变量,我用该变量存了一个数,下一次调用的时候会使用,所以会报错,原因是,函数内部的变量在函数调用完毕后将变量释放,存储的数就不存在了,下一次调用的时候,存储的数不存在了。所以会报这个错,导致实际上我们定义了,报错说没有定义。正确的方法是将该变量定义为全局变量,这个问题就迎刃而解。

    展开全文
  • 函数的声明和变量定义

    千次阅读 2019-04-14 19:44:13
    函数的声明和变量定义声明与定义比较前向引用函数属性内部/内嵌函数函数应用:打印图形和数学计算变量作用域全局变量与局部变量局部变量全局变量globa语句可变类型的全局变量 声明与定义比较 ​ 在某些编程语言...

    声明与定义比较

    ​ 在某些编程语言里,函数声明和函数定义区分开的,一个函数声明包括提供对函数名,参数的名字(传统上还有参数的类型),但不必给出函数的任何代码,具体的代码通常属于函数定义的范畴。
    ​ 在声明和定义有区别的语言中,往往是因为函数的定义可能和其声明放在不同的文件中。python将这两者视为一体,函数的子句由声明的标题行以及随后的定义体组成的。

    前向引用

    和其他高级语言类似python也不允许在函数未声明之前,对其进行引用或者调用。
    我们下面给出几个例子来看一下:

    def func():
    	print("in func()")
    	bar()
    print(func())
    #会报错
    

    修改:现在定义函数bar()在函数func()前给出bar()声明:

    #定义函数的前后顺序都可以!
    def func():
    	print("in func()")
    	bar()
    def bar():
    	print("in bar()")
    func()
    

    现在我们可以安全的调用func(),而不会出现任何问题:

    func()
    in func()
    in bar
    

    事实上,我们甚至可以在函数bar()前定义函数func():

    def func():
    	print("in func()")
    	bar()
    def bar():
    	print("in bar()")
    

    Amazing依然可以很好的运行,不会有前向引用的问题:

    func()
    in func()
    in bar
    
    这段代码是正确的因为即使(在 foo()中)对 bar()进行的调用出现在 bar()的定义之前,但 foo()本身不是在 bar()声明之前被调用的。换句话说,我们声明 foo(),然后再声明bar(),接着调用 foo(),但是到那时,bar()已经存在了,所以调用成功。
    

    注意 ,foo()在没有错误的情况下成功输出了’in foo()’。名字错误是当访问没有初始化的标识符时才产生的异常 。

    函数属性

    你可以获得每个 pyhon 模块,类,和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,,但是在将这两个模块导入你的程序后,仍然可以使用这两个变量。所以,即使在两个模块中使用了相同的变量名字,这也是安全的,因为句点属性标识对于两个模块意味了不同的命名空间,比如说,在这段代码中没有名字冲突:

    import foo, bar
    print(foo.x + bar.x) 
    

    函数属性是 python 另外一个使用了句点属性标识并拥有名字空间的领域。

    def foo():
    	'foo()-- properly created doc string'
    
    def bar():
    	pass
    
    bar.__doc__='Oops,forgot the doc str above'
    bar.version =0.1
    

    #按住shift在空白处打开 执行时在中间加-i
    PS C:\Users\asus\Desktop\pythondemo测试\小巷> python -i band.py
    >>> foo.__doc__
    'foo()-- properly created doc string'
    >>>
    

    ​ 上面的 foo()中,我们以常规地方式创建了我们的文档字串,比如, 在函数声明后第一个没有赋值的字串。当声明
    bar()时, 我们什么都没做, 仅用了句点属性标识来增加文档字串以及其他属性。我们可以接着任意地访问属性。下面是一个使用了交互解释器的例子。(你可能已经发现,用内建函
    数 help()显示会比用__doc__属性更漂亮,但是你可以选择你喜欢的方式)

    >>> help(foo)
    Help on function foo in module __main__:
    
    foo()
        foo() -- properly created doc string
    
    >>> bar.version 
    0.1
    >>> foo.__doc__
    'foo() -- properly created doc string'
    >>> bar.__doc__
    'Oops, forgot the doc str above'
    >>>
    

    注意我们是如何在函数声明外定义一个文档字串。然而我们仍然可以就像平常一样,在运行时刻访问它。然而你不能在函数的声明中访问属性。换句话说,在函数声明中没有’self‘这样的东西让你可以进行诸如_dict_[‘version’] = 0.1 的赋值。这是因为函数体还没有被创建,但之后你有了函数对象,就可以按我们在上面描述的那样方法来访问它的字典。另外一个自由的名字空间!

    内部/内嵌函数

    在函数体内创建另外一个函数(对象)是完全合法的,这种函数叫做内部/内嵌函数。
    最明显的创造内部函数的方法是在外部函数的定义体内定义函数(用def关键字),如在:

    def foo():
    	def bar():
    		print("bar() called.")
    	print("foo() called")
    	bar()
    foo()
    bar()
    

    我们将以上代码置入一个模块中,如inner.py,然后运行,我们会得到如下输出:

    bar() called.
    foo() called
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'bar' is not defined
    >>>
    
    http://www.pythontutor.com/visualize.html#mode=edit
    将简单的代码拷贝进去,可以查看执行的步骤过程
    
    内部函数一个有趣的方面在于整个函数体都在外部函数的作用域(即是你可以访问一个对象的区域;稍后会有更多关于作用域的介绍)之内。如果没有任何对 bar()的外部引用,那么除了在函数体内,任何地方都不能对其进行调用,这就是在上述代码执行到最后你看到异常的原因
    

    另外一个函数体内创建函数对象的方式是使用lambda 语句。 稍后讲述。如果内部函数的定义包含了在外部函数里定义的对象的引用(这个对象甚至可以是在外部函数之外),内部函数会变成被称为闭包(closure)的特别之物。

    函数应用:打印图形和数学计算

    函数的嵌套调用;

    程序设计的思路,复杂问题分解为简单问题。

    • 思考1:编程实现:

      • 写一个函数打印一条横线

      • 打印自定义行数的横线

        举例子说明:

    #打印一行方法一
    # def foo():
    # 	for i in range(5):
    # 		dar()
    # def dar():
    # 	print("-",end=" ")
    # foo()
    
    #打印一行方法二:
    # def line():
    # 	print("-"*15)
    # line()
    
    #打印多条横线的方法一:
    # def line():
    # 	print("-"*15)
    # line()
    # def lines(n):
    # 	for i in range(n):
    # 		line()
    # lines(5)
    
    #打印多条横线方法二:
    def printOneline():
    	print("-"*30)
    
    def printNumline(num):
    	a=0
    #因为prinOneline函数已经完成了打印横线的功能
    #只需要多次调用此函数即可
    	while a<num:
    		printOneline()
    		a+=1
    printNumline(3)
    
    • 思考2:编程实现
      • 写一个函数求三个数的和
      • 写一个函数求三个数的平均值

    参考代码

    # 求3个数的和
    def sum3Number(a,b,c):
        return a+b+c # return 的后面可以是数值,也可是一个表达式
    
    # 完成对3个数求平均值
    def average3Number(a,b,c):
    
     # 因为sum3Number函数已经完成了3个数的就和,所以只需调用即可
     # 即把接收到的3个数,当做实参传递即可
     sumResult = sum3Number(a,b,c)
     aveResult = sumResult/3.0
     return aveResult
    
     # 调用函数,完成对3个数求平均值
     result = average3Number(11,2,55)
     print("average is %d"%result)
    

    变量作用域

    标识符的作用域是定义为其声明在程序的可应用范围,或者即是我们所说的变量可见性,换句话说,就好像在问你自己,你可以在程序里的哪些部分去访问一个制定的标识符,变量可以是局部域或者是全局域。

    全局变量与局部变量

    定义在函数内的变量有局部作用域,在一个模块中最高级别的变量有全局作用域。
    “声明适用的程序的范围被称为了声明的作用域,在一个过程中,如果名字在过程的声明之内,它的出现即为过程的局部变量,否则的话,出现即为非局部的”.
    全局变量的一个特征是除非被删除掉,否则它们的存活到脚本运行结束,且对于所有的函数,他们的值都是可以被访问的,然而局部变量,就像它们存放的栈,暂时的存在,仅仅只依赖于定义它们的函数现阶段是否处于活动,当一个函数调用出现时,其局部变量就进入声明它们的作用域,在那一刻,一个新的局部变量名为那个对象创建了,一旦函数完成,框架被释放,变量将会离开作用域。

    举例子说明:

    global_str='foo'
    def foo():
    	local_str='bar'
    	return global_str+local_str
    print(foo())#结果为:foobar
    print(global_str)#结果为:foo
    print(local_str)#会报错,因为局部变量只能在函数方法内部使用才有用
    
    题目:
    编写函数,实现求两个序列的交集。(为方便,序列类型可以直接统一采用列表)
    方法一:
    def foo():
    	a=[1,2,3,4,5]
    	b=[2,3,4]
    	list1=list((set(a)&set(b)))
    	print(list1)
    foo()
    结果:[2, 3, 4]
    方法二:
    def foo():
    	a=[1,2,3,4,5]
    	b=[2,3,4]
    	list1=[val for val in a if val in b]
    	print(list1)
    foo()
    结果:[2, 3, 4]
    

    局部变量

    例子:

    def foo():
    	a=666
    	print('foo(),修改前a:\t',a)
    	a=999
    	print('foo(),修改后a:\t',a)
    
    def bar():
    	a=8899
    	print('bar(),a\t',a)
    

    运行结果:

    >>> foo()
    foo(),修改前a:   666
    foo(),修改后a:   999
    >>> bar()
    bar(),a  8899
    >>>
    

    可以看出:

    • 局部变量,就是在函数内部定义的变量
    • 不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响
    • 局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

    全局变量

    同样,先看一下例子:

    a=6699
    def foo():
    	print('foo(),a:\t',a)
    
    def bar():
    	print('bar(),a:\t',a)
     
    print(foo())
    print(bar())
    

    运行结果:

    foo(),a:	 6699
    None
    bar(),a:	 6699
    None
    

    讨论1:如果全局变量和局部变量名字相同?

    a=8899
    def foo():
    	a=666
    	print('foo(),修改前a:\t',a)
    	a=888
    	print('foo(),修改后a:\t',a)
    
    def bar():
    	print('bar(),a:\t',a)
    
    foo()
    bar()
    

    运行结果为:

    foo(),修改前a:	 666
    foo(),修改后a:	 888
    bar(),a:	 8899
    

    讨论2:全局变量,是能够在所有的函数中进行使用的变量,那么局部变量可否进行修改编程全局变量?

    globa语句

    如果将全局变量的名字声明在一个函数体内的时候,全局变量的名字能被局部变量给覆盖掉。

    a=6699
    def foo():
    	global a 
    
    	print('foo(),修改前,a:\t',a)
    	a=666
    	print('foo(),修改后,a:\t',a)
    
    def bar():
    	print('bar(),a:\t',a)
    foo()
    bar()
    

    运行结果:

    foo(),修改前,a:	 6699
    foo(),修改后,a:	 666
    bar(),a:	 666
    

    通过以上例子,我们可以观察出:

    • 在函数外边定义的变量叫做全局变量
    • 全局变量能够在所有的函数中进行访问
    • 如果在函数中修改全局变量,那么就需要使用global进行声明,否则出错
    • 如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的

    可变类型的全局变量

    先举2个例子:

    例子1:

    a=1
    def foo():
    	a+=1
    	print(a)
    foo()#内存地址改变了
    

    运行后:

    Traceback (most recent call last):
      File "C:\Users\asus\Desktop\pythondemo测试\小巷\band.py", line 108, in <module>
        foo()
      File "C:\Users\asus\Desktop\pythondemo测试\小巷\band.py", line 106, in foo
        a+=1
    UnboundLocalError: local variable 'a' referenced before assignment
    

    例子2:

    li=['a','b']
    def foo():
    	li.append('c')
    	print(li)
    print(foo())
    print(li)
    

    运行结果:

    ['a', 'b', 'c']
    None
    ['a', 'b', 'c']
    
    展开全文
  • makefile中变量定义

    千次阅读 2008-07-17 16:30:00
    第五章:Makefile变量来源: ChinaUnix博客 日期: 2006.07.21 12:56 (共有0条评论) 我要评论 第五章:Makefile变量1 使用变量在Makefile变量就是一个名字(像是C语言的宏),代表一个文本字符串...
  • .c中变量必须定义在执行语句前面

    千次阅读 2015-09-08 13:16:22
    如果你将这段代码保存在.c文件下,在vc++6.0去编译,编译器会报错,但同样的代码保存在.cpp文件下再编译,正确。这是为什么呢? 这是C标准的问题: C98规定,在任何执行语句(上面的a=2;是表示将变量a重新赋值为2...
  •  1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构的栈。  2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由os回收 。...
  • 全局变量定义在项目文件,app.js里面,找到下面的定义,或者自己写一个。 在里面定义要全局访问的变量名字。 2 使用全局变量 2.1 定义引用 在需要应用的文件头,定义应用: 2.2 使用全局变量 2.3 改变...
  • java类方法和变量定义顺序

    千次阅读 2017-03-01 21:55:58
    一、在类的内部,变量定义的先后顺序决定了初始化的顺序。即使变量定义散布于方法定义之间,它们仍旧会在任何方法(包括构造器)被调用之前得到初始化。即:先变量后方法。 比如如下的java程序:class Tag { Tag...
  • c语言中定义变量的几个关键字

    万次阅读 2018-08-23 10:44:21
    (1)auto关键字在C语言只有一个作用,那就是修饰局部变量。 (2)auto修饰局部变量,表示这个局部变量是自动局部变量,自动局部变量分配在栈上。(既然在栈上,说明它如果不初始化那么值就是随机的······) (3)...
  • shell变量的分类及定义

    千次阅读 2017-01-01 22:10:20
    shell变量的类型: shell变量分环境变量(全局变量)和普通变量(局部变量) 环境变量亦称为全局变量,可以在建立它们的shell及其派生出来的任意子进程shell使用;...环境变量的作用:一般用于定义shell的运行
  • 勿在头文件中定义static变量

    万次阅读 多人点赞 2016-02-29 22:05:20
    一、问题看到有一位同学在头文件这么写:static const wchar_t* g_str1 = … ...定义全局变量时使用static,意味着该变量的作用域只限于定义它的源文件,其它源文件不能访问。既然这种定义方式出现在头文件
  • C/C++语言在头文件中定义全局变量

    千次阅读 2016-06-19 10:19:10
    全局变量可不可以定义在可被多个.C文件包含的头文件?为什么?...头文件不可以直接定义变量和函数,但是可以定义static变量 ,类。  extern 用法,全局变量与头文件(重复定义) 用#incl
  • C语言:在头文件使用static定义变量意味着什么? 看到有一位同学在头文件这么写: static const wchar_t* g_str1 = … static const wchar_t* g_str2 = … 这种定义变量的方式我从来没有见过,而且它还能...
  • c++全局变量正确声明

    千次阅读 2016-04-12 10:35:51
    C++全局变量声明错误情况 造成LNK2005错误主要有以下几种情况:   1.重复定义全局变量。...正确的应该是在一个CPP文件中定义如下:int g_Test;那么在使用的CPP文件就应该使用:extern
  • 其实在前面的例子中已经多次用到了变量。在程序运行期间其值可以改变的量称为变量。一个变量应该有一个名字,并在内存占据一定的存储单元,在该存储单元存放变量的值。请注意区分变量名和变量值这两个不同的概念...
  • keil无法跳转到定义的情况有多种情况: 1、工程编译不成功,这种情况肯定跳转不到定义的,这时只能根据编译提示信息检查程序直到程序正常通过编译吧。 2、工程未编译或工程清空编译信息后未再进行编译,肯定会...
  • Oracle变量定义的方法

    千次阅读 2018-05-07 14:25:54
    通过define定义host变量的时候必须指定变量名和变量的值,如果变量已经存在于host变量中,则自动覆盖,这个值不可以指定类型,一律按char存储。 DEFINE 变量只在当前session环境有效。(1).语法:define ...
  • javamain函数变量定义及其使用

    千次阅读 2012-05-10 11:04:15
    错误案例一: public class exe1 { static int i=10; int k=3; public static void main(String[] args) {  k=5; System.out.println("i="+i); System.out.println("k="+k);...静态方法操作动态变量既是main
  • 全局变量正确声明

    千次阅读 2009-06-03 17:46:00
    造成LNK2005错误主要有以下几种情况: 1.重复定义全局变量。可能存在两种情况: A、...正确的应该是在一个CPP文件中定义如下:int g_Test;那么在使用的CPP文件就应该使用:extern int g_Test即可,如果还是使用int
  • 变量的概念与定义格式

    千次阅读 2020-03-12 22:59:48
    变量:常量是固定不变的数据,那么在程序中可以变化的量称为变量。 数学,可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。 程序中,可以使用字母保存数字的方式进行运算,提高计算能力,可以解决更多的问题。...
  • 一般为大写,且都是全局变量,用于定义Shell运行环境,保证Shell命令正确执行。 环境变量可以在命令行设置,但是退出用户后值会丢失,因此最好在用户home目录下 .bash_profile 文件或者全局配置 /etc/...
  • 微信小程序对全局变量的引用和赋值

    万次阅读 多人点赞 2019-07-05 22:26:47
    在小程序中可以通过全局变量来实现从A页面到B,C,D…页面之间参数的传递,但容易出现参数传递不成功或者参数不能正确更新(A的参数第一次能成功传到B页面,但当A页面更改了全局变量的值,新的值不能正确传到B页面)...
  • 在linux平台编写复杂的多线程程序,没有互斥锁是肯定不行的,而仅有互斥锁没有条件变量也是万万不行的。关于互斥锁需要注意的问题不多,而且现有资料也很多。但是条件变量正确使用却不是一件简单的事,有很多...
  • C语言声明和定义详解

    万次阅读 多人点赞 2016-02-06 16:56:05
    程序中变量有且仅有一个定义变量声明:用于向程序表明变量的类型和名字。 定义也是声明,extern声明不是定义 定义也是声明:当定义变量时我们声明了它的类型和名字。 extern声明不是定义:通过使用...
  • 我们知道,在 C++(但不是在 C 语言),const 限定符对默认存储类型稍有影响。... 因此,可以将 const 常量定义在头文件供工程的多个其它文件包含引用,并且编译时不会产生变量重复定义的错误。当然,也可
  • C语言定义变量的位置

    千次阅读 2019-03-03 20:21:55
    在标准C规定变量定义必须放在所有的执行语句之前!一旦在运行语句之间再有定义的话,会报错误! 见以下式例: #include &lt;stdio.h&gt; int main() { char char1='A'; printf("大写字符=%c的ASCII码...
  • 使用开源库封装的dll,它里面的接口需要使用dll中定义的结构体变量作为参数,于是把该变量也一起导出了,但在使用时,对该变量取地址总返回未知的值。大概的代码如下: 头文件定义结构体A,并声明 a变量,另外有一...
  • C语言作为一种结构化的程序设计语言,在模块的划分上主要依据功能,C语言模块化程序设计需理解如下概念:  (1) 模块即是一个.c文件和一个.h文件的结合,头文件(.h)是对于该模块接口的声明;  (2) ...
  • Java实例变量和类变量

    万次阅读 多人点赞 2017-09-04 09:02:02
    形参:在方法签名中定义的局部变量,由方法调用者负责为其赋值,随方法的结束而消亡。 方法内的局部变量:在方法内定义的局部变量,必须在方法内对其进行显示初始化。这种类型的局部变量从初始化完成后开始生效,随...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 559,196
精华内容 223,678
关键字:

以下程序中的变量已经正确定义