精华内容
下载资源
问答
  • 1、函数定义 linux shell 可以用户定义函数,然后在shell脚本中可以随便调用。Shell 函数定义的语法格式如下: [function] funname [()]{ 函数体 [return int;] } 格式1: 简化写法,不写 function 关键字: ...

    分享知识 传递快乐

     

    1、函数定义

    linux shell 可以用户定义函数,然后在shell脚本中可以随便调用。Shell 函数定义的语法格式如下:

    [function] funname [()]{
        函数体
        [return int;]
    }

    格式1:

    简化写法,不写 function 关键字:

    函数名(){
        函数体
    }

    格式2:

    这是标准写法,也推荐大家使用的写法:

    function 函数名(){
    	命令序列
    }

    这样方便做到一看就懂。

    格式3:

    如果写了 function 关键字,也可以省略函数名后面的小括号:

    function 函数名{
    	命令序列
    }


    说明:

    • function 是 Shell 中的关键字,专门用来定义函数;可以带function funname () 定义,也可以直接funname () 定义,不带任何参数;
    • funname 是函数名;
    • 函数体 是函数要执行的代码,也就是一组语句;
    • return int 表示函数的返回值,其中 return 是 Shell 关键字,专门用在函数中返回一个值;这一部分可以写也可以不写,如果不加,将以最后一条命令运行结果,作为返回值。

     

    2、函数变量

    Shell 函数的变量不像其它语言中需要在变量前定义变量类型什么的,更没有结果符号等。语法:

    num=1

    变量作用域

    局部变量:作用域是函数的生命周期;在函数结束时被自动销毁。定义局部变量的方法:

    local VAR=VALUE

    本地变量:作用域是运行脚本的shell进程的生命周期;因此,其作用范围为当前shell

    示例一:

    #!/bin/bash
    
    #在函数外定义本地变量
    var="Hello,World"
    
    function show() {
        #在函数内改变变量内容
        var="Hi,var is changed"
    }
    echo "$var"
    show
    echo "$var"

    输出结果:

    [guest@localhost shell]$ ./tempsh.sh
    Hello,World
    Hi,var is changed

    结果显示在调用函数后,原有的本地变量var被替换了。还好这个变量并不是重要的部分,想想若是PATH被替换了,那么这个函数的罪过就大了。因此我们如何即调用函数中定义的变量同时又不对本地变量造成任何影响呢?局部变量的出现就是为了解决这个问题。

    下面看看在使用了局部变量后的效果。

    #!/bin/bash
    #在函数外定义本地变量
    var="Hello,World"
    
    function show() {
        #在函数内改变变量内容
        local var="Hi,var is changed"
        echo "$var"
    }
    echo "$var"
    show
    echo "$var"

    输出结果

    [guest@localhost shell]$ ./tempsh.sh
    Hello,World
    Hi,var is changed
    Hello,World

    该实验结果说明,使用局部变量后,函数体中出现的变量作用范围只存在于当前函数生命周期。

     

    3、函数调用

    定义函数的代码段不会自动执行,而是在调用时执行;在函数定义好后,用户可以在shell 中直接调用,调用时不用带上();调用 Shell 函数时可以给它传递参数,也可以不传递。如果不传递参数,直接给出函数名字即可。

    示例一:

    #!/bin/bash
    
    # 函数定义
    function show(){
        echo "Hello word"
    }
    
    # 函数调用
    show

    输出结果:

    Hello word

    函数调用成功。上边的例子是把函数把在脚本上边,那么如果放函数放在下边会怎样呢?

    无非就两种结果:1成功,2失败

    下面我们举例测试一下:

    示例二:

    #!/bin/bash
    
    # 函数调用
    show
    
    #函数定义
    function show(){
        echo "Hello word"
    }

    输出结果:

    ./tempsh.sh:行4: show: 未找到命令

    系统报错,为啥?为什么会报错呢?

    首先,脚本的执行顺序是从上到下顺序执行的,因此会先执行show,通过定义的环境变量$PATH定义的路径找不到show对应的命令因此报“show:未找到命令”。

    我们在终端命令行中输错命令报错也是这个原因。终端命令行默认会将最左面输入的内容当做命令,因此若是错误的命令,不是命令的命令等内容都会报错。

    通过上面的对比,我们至少知道函数的调用若是在同一个脚本中,调用操作需要在定义的函数后面。

     

    4、函数传参

    函数传参调用语法:

    函数名 参数1 参数2 ....

    如果传递参数,那么多个参数之间以空格分隔:

    funname param1 param2 param3

    不管是哪种形式,函数名字后面都不需要带括号。和其它编程语言不同的是,Shell 函数在定义时不能指明参数,但是在调用时却可以传递参数,并且给它传递什么参数它就接收什么参数。

    在Shell中,调用函数时可以向其传递参数。在函数体内部,函数中的变量均为全局变量,没有局部变量,若使用局部变量需要在变量前加上 local,通过 $n 的形式来获取参数的值,例如,$1表示第一个参数,$2表示第二个参数....

    示例:

    #!/bin/bash
    
    function show(){
        echo "第一个参数为 $1 !"
        echo "第二个参数为 $2 !"
        echo "第十个参数为 $10 !"
        echo "第十个参数为 ${10} !"
        echo "第十一个参数为 ${11} !"
        echo "参数总数有 $# 个!"
        echo "作为一个字符串输出所有参数 $* !"
    }
    
    show 0 1 2 3 4 5 6 7 8 9 10 11

    输出结果:

    第一个参数为 0 
    第二个参数为 1 
    第十个参数为 10 
    第十个参数为 9 
    第十一个参数为 10 
    参数总数有 12 个
    作为一个字符串输出所有参数 0 1 2 3 4 5 6 7 8 9 10 11 

    注意:$10 不能获取第十个参数,获取第十个参数需要${10}。当n>=10时,需要使用${n}来获取参数。

    另外,还有几个特殊字符用来处理参数:

    参数处理 说明
    $# 传递到脚本的参数个数
    $* 以一个单字符串显示所有向脚本传递的参数
    $$ 脚本运行的当前进程ID号
    $! 后台运行的最后一个进程的ID号
    $@ 与$*相同,但是使用时加引号,并在引号中返回每个参数。
    $- 显示Shell使用的当前选项,与set命令功能相同。
    $? 显示最后命令的退出状态。0表示没有错误,其他任何值表明有错误。

     

    5、函数返回值

    退出状态码

    在介绍函数返回值前先了解一下跟函数返回值有关的状态退出码。

    Shell 中运行的每个命令都使用退出状态码(exit status)来告诉shell它完成了处理。退出状态码是一个0-255之间的整数值,在命令结束运行时由命令传给shell。你可以捕获这个值并在脚本中使用。

    如何查看退出状态码呢?

    Linux提供了 $? 专属变量来保存上个执行的命令的退出状态码。你必须在你要查看的命令之后马上查看或使用 $? 变量。它的值会变成Shell中执行的最后一条命令的退出状态码。

    退出状态码大体分两种:

    • 一种是命令正确执行的状态码,该状态码为:0
    • 一种是命令错误执行的状态码,为1-255

     Linux退出状态码

    状态码 描述
    0 命令成功结束
    1 通用未知错误
    2 误用shell命令
    126 命令不可执行
    127 没找到命令
    128 无效退出参数
    128+x Linux信号x的严重错误
    130 命令通过Ctrl+C终止
    255 退出状态码越界

    在脚本中也可以指定退出状态码的值,通过命令exit实现。

    状态码取值范围为0-255,如果在指定的状态码大于255,那么shell会通过模(模就是256)运算得到相应的退出状态码。

    示例一:

    成功的

    #!/bin/bash
    
    # 函数定义
    function show(){
        echo $(date +%Y%m%d)
    }
    show
    echo $?

    输出结果:

    0

    示例二:

    失败的

    #!/bin/bash
    
    SYS_DATE=$(date +%Y%m%d)
    
    echo $SYS_DATE
    
    # 函数定义
    function show(){
        log=`lt`
    	echo log
    }
    show
    echo $?

    输出结果:

    [guest@localhost shell]$ ./tempsh.sh 
    20191123
    ./tempsh.sh:行10: lt: 未找到命令
    log
    0
    

    这次,由于函数最后一行命令正确执行,函数的退出状态码就是0,尽管函数中有一条命令没有成功运行。

    使用函数的默认退出状态码是很危险的,幸运的是return命令可以解决这个问题。

    示例:

    #!/bin/bash
    
    SYS_DATE=$(date +%Y%m%d)
    
    echo $SYS_DATE
    
    # 函数定义
    function show(){
        log=`lt`
    	echo log
    	return 2
    }
    show
    echo $?

    输出结果:

    [guest@localhost shell]$ ./tempsh.sh 
    20191123
    ./tempsh.sh:行10: lt: 未找到命令
    
    2
    

    还是使用相同的函数,在函数最后加上return指定的状态码2。

     

    函数返回值

    Shell函数返回值,常用的两种方式:return、echo。

     

    1)return 语句

    Shell函数的返回值,可以和其他语言的返回值一样,通过return语句返回,return只能用来返回整数值。

    示例一:

    #!/bin/bash
    
    function getResultFun(){
        echo "这是我的第一个 shell 函数!"
        return `expr 1 + 1`
    }
    
    getResultFun
    echo $?

    输出结果:

    这是我的第一个 shell 函数!
    2

    Shell 函数返回值只能是整形数值,一般是用来表示函数执行成功与否的,0表示成功,其他值表示失败。用函数返回值来返回函数执行结果是不合适的。如果return某个计算结果,比如一个字符串,往往会得到错误提示:“numeric argument required”。

    如果一定要让函数返回一个或多个值,可以定义全局变量,函数将计算结果赋给全局变量,然后脚本中其他地方通过访问全局变量,就可以获得那个函数“返回”的一个或多个执行结果了。

    示例:

    #!/bin/sh
    
    function getStr(){
    	return "string"
    }
    
    getStr
    echo $?

    输出如下:

    ./test.sh: line 5: return: string: numeric argument required
    255

    可以看到已经提示要求return 整数类型,真实返回值是255。当面对这种问题怎么解决呢?

    别急,断续看下去你就会找到你想要的答案了。

     

    2)echo 语句

    echo是通过输出到标准输出返回,可以返回任何类型的数据。

    示例:

    #!/bin/sh
    
    function test()  {
    	echo "arg1 = $1"
    	if [ $1 = "1" ] ;then
    		echo "1"
    	else
    		echo "0"
    	fi
    }
    
    echo
    echo "test 1"
    test 1
    
    echo
    echo "test 0"
    test 0
    
    echo
    echo "test 2"
    test 2

    输出结果:

    test 1
    arg1 = 1
    1
    
    test 0
    arg1 = 0
    0
    
    test 2
    arg1 = 2
    0

     

    3)函数返回值总结

    学习了上面的函数返回值的操作后我们下面做个知识总结,我们先看一用例:

    #!/bin/bash
    
    function getResultFun(){
        echo "这是我的第一个 shell 函数!"
        return `expr 1 + 1`
    }
    
    getResultFun
    echo $?
    
    function getResultFun2(){
     echo "这是我的第二个 shell 函数!"
     expr 1 + 1
    }
    
    getResultFun2
    echo $?
    
    getResultFun
    echo 在这里插入命令!
    echo $?

    输出结果:

    这是我的第一个 shell 函数!
    2
    这是我的第二个 shell 函数!
    2
    0
    这是我的第一个 shell 函数!
    在这里插入命令!
    0

    这是为什么?

    因为调用 getResultFun2 后,函数最后一条命令 expr 1 + 1 得到的返回值($?值)为 0,意思是这个命令没有出错。所有的命令的返回值仅表示其是否出错,而不会有其他有含义的结果。

    第二次调用 getResultFun 后,没有立即查看 $? 的值,而是先插入了一条别的 echo 命令,最后再查看 $? 的值得到的是 0,也就是上一条 echo 命令的结果,而 getResultFun 的返回值被覆盖了。下面这个测试,连续使用两次 echo $?,得到的结果不同,更为直观:

    #!/bin/bash
    
    function getResult(){
        echo "这是我的第一个 shell 函数!"
        return `expr 1 + 1`
    }
    
    getResult
    echo $?
    echo $?

    输出结果:

    这是我的第一个 shell 函数!
    2
    0

     

    6、获取函数返回值

    我们上面谈到了函数定义、传参、调用、返回结果,那我们如果得到返回结果呢?上面也谈到了一种获取返回结果的方法 $? ,难道只有这一种方式吗?答案肯定不止。

    示例一:

    用 $? 获取返回值,上面已有介绍,在这里就不做介绍了。

    示例二:

    #!/bin/sh
    
    function getStr(){
    	return "string"
    }
    
    #方法一
    echo `getStr` 
    
    #方法二
    echo $(getStr) 

    两种写法的原理一样的,将getStr当成命令执行,然后获取其标准输出。

    示例三:函数传参

    #!/bin/bash
    
    #创建目录
    function createDir(){
    	if [ ! -d $1 ]; then
    		mkdir -p $1
    	fi
    }
    
    DIR="temp/"
    # 两者二先一
    #$(createDir $DIR)
    $(createDir "temp/")

    函数返回值获取的方法总结:

    • 用变量接收函数返回值,函数用echo等标准输出将要返回的东西打印出来。
    • 用 $? 来接收函数的执行状态,但是 $? 要紧跟在函数调用处的后面。

     

     

     

     

     

     

     

     

     

     

    ———————————
    相互学习,共同进步
    如有不足请留言指正

    展开全文
  • 模块模式利用了函数作用域和闭包来创建被绑定对象与私有成员变量的关联,只有特权函数才能够访问特定的私有成员变量(数据对象)。 模块模式(摈弃全局变量的使用,封装程序)的一般形式是: 一个定义了私有变量和...

    模块模式利用了函数作用域和闭包来创建被绑定对象与私有成员变量的关联,只有特权函数才能够访问特定的私有成员变量(数据对象)。

    模块模式(摈弃全局变量的使用,封装程序)的一般形式是:

    一个定义了私有变量和函数的函数;

    利用闭包创建可以访问私有变量和函数的特权函数;

    最后返回这个特权函数,或者把它们保存到一个可以访问到的地方。

     

    //糟糕得例子——预期点击一个节点时应输出节点的序号,但是这个总是会显示节点的数目(因为事件处理器函数绑定了变量i本身,而不是函数在构造时的变量i的值)

    var   add_the_handlers = function(nodes){

        var   i;

        for(i=0;i<nodes.length;i++){

             nodes[i].onclick = function(e){   console.log(i);   }

        }

    }

    //先在循环外创建个辅助函数,这个辅助函数再返回一个绑定了当前i值的函数

    var   add_the_handlers = function(nodes){

         var  helper = function(i){

                return  function(e){   console.log(I);   }

         }

          var  i;

          for(i=0;i<nodes.length;i++){

                 nodes[i].onclick = helper(i);

          }

    };

    展开全文
  • Python之函数变量

    千次阅读 2018-09-20 18:36:54
    任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 函数内容以冒号起始,并且缩进。 return [表达式] 结束函数,选择性...

    一、Python函数的定义和规则:

    1、规则:

    • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()
    • 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
    • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
    • 函数内容以冒号起始,并且缩进。
    • return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

    2、函数的作用:

    (1)、提高应用的模块性

    (2)、提高代码的重复利用率

    (3)、用来实现单一,或相关联功能的代码段

    3、定义

    语法:

    def 函数名(参数列表):
        函数体

    实例:

    def hello():
        """
        仅用于展示函数定义
        :return:
        """
        print("Hello World")
    
    
    hello()  # 函数调用
    # 计算面积函数
    def area(width, height):
        """
        根据宽高计算面积
        :param width: 宽度
        :param height: 高度
        :return: 面积
        """
        return width * height
    
    
    def print_welcome(name):
        """
        根据传入的名字打印欢迎"名字"
        :param name:传入的名字
        :return: 打印语句
        """
        print("Welcome", name)
    
    
    print_welcome("Wangdoudou")
    w = 4
    h = 5
    print("width =", w, " height =", h, " area =", area(w, h))

     

    二、函数的具体使用

    1、参数传递

    (1)、可更改(mutable)对象:列表、字典,修改的跟原来的是同一个引用

    def changeme(mylist):
        """
        修改传入的列表
        :param mylist: 
        :return: 
        """
        mylist.append([1, 2, 3, 4])
        print("函数内取值: ", mylist)
        return
    
    
    # 调用changeme函数
    mylist = [10, 20, 30]
    changeme(mylist)
    print("函数外取值: ", mylist)

     

    (2)、不可更改(immutable)对象:字符串、数字、元组,传参时相当于重新生成了对象

    a = "wangdoudou"
    b = 15
    
    
    def Changestr(a):
        a = "haha"
    
    
    def Changenum(b):
        b = 20
    
    
    Changestr(a)
    Changenum(b)
    
    print("a = ", a)
    print("b = ", b)

     

    2、函数参数:

    函数定义时的参数为形参:调用时才分配内存单元,调用结束释放内存

    调用函数时传入的参数值为实参

    参数类型:

    (1)、必需参数:须以正确的顺序传入函数。调用时的数量必须和声明时的一样

    def printme(str):
        """
        打印任何传入的字符串
        :param str:
        :return:
        """
        print(str)
        return
    
    
    # 调用printme函数
    printme("函数定义了几个参数,就必须传入几个参数")

    (2)、关键字参数:允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值

    def printinfo(name, age):
        """
        打印任何传入的字符串
        :param name: 名字
        :param age: 年龄
        :return:
        """
        print("名字: ", name)
        print("年龄: ", age)
        return
    
    
    # 调用printinfo函数
    printinfo(age=50, name="wangdoudou")

    (3)、默认参数:调用函数时,如果没有传递参数,则会使用默认参数

    def printinfo(name, age=35):
        """
        打印用户的名字和年龄
        :param name:
        :param age:
        :return:
        """
        print("名字: ", name)
        print("年龄: ", age)
        return
    
    
    # 调用printinfo函数
    printinfo(age=50, name="wangdoudou")
    print("------------------------")
    printinfo(name="wangdoudou")

    (4)、不定长参数:处理比声明时更多的参数

    一个星号*:参数会以元组(tuple)的形式导入,存放所有未命名的变量参数

    基本语法:

    def functionname([formal_args,] *var_args_tuple ):
       "函数_文档字符串"
       function_suite
       return [expression]
    def printinfo(arg1, *vartuple):
        print("输出: ")
        print(arg1)
        print(vartuple)
        for var in vartuple:
            print(var)
        return
    
    
    # 调用printinfo 函数
    printinfo(10)
    printinfo(70, 60, 50)

     

    两个星号**:参数会以字典的形式导入

    基本语法:

    def functionname([formal_args,] **var_args_dict ):
       "函数_文档字符串"
       function_suite
       return [expression]
    def printinfo(arg1, **vardict):
        print("输出: ")
        print(arg1)
        print(vardict)
    
    
    # 调用printinfo 函数
    printinfo(1, a=2, b=3)

     

    一个星号和两个星号一块用:可接受任意长度,任意类型的参数

    def test(x, *args, **kwargs):
        print(x)
        print(args, args[3])
        print(kwargs, kwargs['y'])
    
    
    test(1, 2, 3, 4, 5, 6, 7, y="hehe", z=110)

     

    声明函数时,参数中星号 * 可以单独出现,如果单独出现星号 * 后的参数必须用关键字传入:

    def f(a,b,*,c):
        return a+b+c

    错误调用:f(1,2,3) 

    正确调用:f(1,2,c=3)

     

    5、return语句:return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None

    def sum(arg1, arg2):
        """
        返回2个参数的和
        :param arg1:
        :param arg2:
        :return: 返回2个参数的和
        """
        total = arg1 + arg2
        print("函数内 : ", total)
        return total
    
    
    # 调用sum函数
    total = sum(10, 20)
    print("函数外 : ", total)
    
     

    三、匿名函数:python 使用 lambda 来创建匿名函数,不再使用 def 语句这样标准的形式定义一个函数

    1、定义

    语法:

    lambda [arg1 [,arg2,.....argn]]:expression

    实例:

    sum = lambda arg1, arg2: arg1 + arg2
    print("相加后的值为 : ", sum(10, 20))

    2、特性:

    • lambda 只是一个表达式,函数体比 def 简单很多。
    • lambda 的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
    • lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
    • lambda 函数的目的是调用小函数时不占用栈内存从而增加运行效率。

     

    四、变量作用域:变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称

    1、变量作用域类型

    • L (Local) 局部作用域
    • E (Enclosing) 闭包函数外的函数中
    • G (Global) 全局作用域
    • B (Built-in) 内建作用域

    作用域排序:以  L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找

    示例:

    x = int(2.9)  # 内建作用域
    g_count = 0  # 全局作用域
    
    
    def outer():
        o_count = 1  # 闭包函数外的函数中
    
        def inner():
            i_count = 2  # 局部作用域

     

    Tips:Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,其它的代码块(如 if/elif/else/、try/except、for/while等)是不会引入新的作用域的,也就是说这些语句内定义的变量,外部也可以访问

     

    2、全局变量和局部变量:定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域,局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。

    实例:

    total = 0  # 这是一个全局变量
    
    
    def sum(arg1, arg2):
        total = arg1 + arg2  # total在这里是局部变量.
        print("函数内是局部变量 : ", total)
        return total
    
    
    # 调用sum函数
    sum(10, 20)
    print("函数外是全局变量 : ", total)

     

    3、global 关键字:内部作用域修改外部作用域的变量

    实例:

    num = 1
    
    
    def fun1():
        global num  # 使用 global 关键字修改外部变量
        print(num)
        num = 123
        print(num)
    
    
    fun1()
    print(num)

     

    4、nonlocal关键字:修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量

    实例:

    def outer():
        num = 10
    
        def inner():
            nonlocal num  # nonlocal关键字声明
            print(num)
            num = 100
            print(num)
    
        inner()
        print(num)
    
    
    outer()

     

     

    五、函数作用域:输出的结果是从当前运行的代码块开始,然后逐级向上运行

    name = "wangdoudou"
    
    
    def printname():
    	name = "wangdoudou1"
    
    	def test():
    		name = "wangdoudou2"
    		print(name)
    
    	return test
    
    
    # 第一种执行方式
    printname()()
    
    # 第二种执行方式
    res = printname()
    res()

    输出结果:

    
     
    展开全文
  • 全局变量,局部变量形式参数

    千次阅读 2016-03-20 02:07:36
    全局变量:全局变量在整个程序内都是可知的,因此可以被任何代码段所使用,他们在程序中执行时保持他们的值,可以再任何函数之外来创建他们,任何表达式都可访问他们。 全局变量存储在一个固定的存储区,这时由...
    全局变量:全局变量在整个程序内都是可知的,因此可以被任何代码段所使用,他们在程序中执行时保持他们的值,可以再任何函数之外来创建他们,任何表达式都可访问他们。
    全局变量存储在一个固定的存储区,这时由编译器设定的,当程序中多个函数使用一个变量时,全局变量就变得很有用。但是不必要的全局变量却会带来麻烦:
    1、全局变量在整个程序运行中都占据内存,只有当程序结束时才被销毁。
    2、在应该使用局部变量的地方使用全局变量会降低函数的同用行,因为全局变量必须依靠在他本身之外的定义。
    3、使用大量的全局变量会使程序因为不可预知的副作用而产生错误。(有可能会因改变全局变量的值而产生错误)
    例:
    #include<stdio.h>
    intcount;//全局变量
    intmain()
    {
    count=100;//可以使用count
    func1();
    return0;
    }
    局部变量:在函数内部声明的变量成为局部变量,更具体的说是在代码块内部创建的变量叫做局部变量(代码块就是一对{}内的内容),局部变量在进入代码块被创建,出了代码块立即被销毁。
    例如:
    void fun1(void)
    {
    intx;
    x = 10;
    }
    voidfun2(void)
    {
    intx;
    x = -99;
    }
    这两个x就是局部变量。因为局部变量在出了代码块就被销毁,因此我们可以使用static这个关键字修饰变量,使他的值保留下来。没有被static声明过得局部变量都存储在堆栈上。

    例:
    #include<stdio.h>
    intcount;      //全局变量
    voidfunc1(void);
    intmain()
    {
         count=100;
         func1();
         return0;
    }
    voidfunc1(void)
    {
         intcount;   //局部变量
         for(count =1; count <10; count++)
      {
          putchar('.');
      }
    }
    在这个例子中count被定义了两次,一次是全局变量,一次是局部变量,当全局变量和局部变量重名时,在局部变量声明的区域内我们以局部变量作为引用对象,并且再次期间对于全局变量没有任何影响。

    形式参数:形式参数出现在函数内,当函数要接受实参时,必须声明接受实参的变量,这些变量就是形参,同局部变量一样,形参再出了函数之后就被销毁。
    展开全文
  • C++中如何访问全局变量和全局函数

    千次阅读 2017-03-14 14:44:00
    全局变量和全局函数是相对局部变量和局部函数而言的,不在{}或者for, if 等范围内的都是全局变量或者全局函数,最简单的是在同一个文件中去声明。 例如在mian.cpp中 #include &lt;iostream&gt;  int ...
  • C++--函数变量,数组底层表现

    千次阅读 2015-05-11 19:44:49
    函数的工作原理 ...变量在内存中的表现形式 局部变量:保存在栈区,运行时对应申请的内存,生命周期就是在自己的作用域内。 全局变量:表现类似常量,在编译时就已经存在,其内存地址由编译器在运行前
  • (一) 用函数指针变量调用函数

    千次阅读 2012-11-23 11:14:52
    (一) 用函数指针变量调用函数  可以用指针变量指向整形变量、字符串、数组、结构体、也可以指向一个函数。一个函数在编译时被分配一个入口地址。这个入口地址就称为函数指针。可以用一个指针变量指向函数,然后...
  • Lua Module全局变量访问

    万次阅读 2008-12-09 20:49:00
    大体情况是这样的,我在主程序中设定的全局变量,在模块文件中可以访问到,并修改了这个全局变量的值,但是在模块调用返回后,再次使用这个全局变量的值,发现它没有被赋值,没有被改变。究其原因,发现是因为Lua的...
  • Spark变量访问总结

    千次阅读 2016-09-25 20:55:28
    本文通过一组实验来分析Spark各种形式变量的处理方式。  下面这个简单的小程序创建了 - 静态变量staticVariable、静态广播变量staticBroadcast、静态累加器staticAccumulator; - 成员变量objectVariable、成员...
  • jmeter函数变量(二)

    千次阅读 2017-08-21 20:12:18
    接上篇 jmeter函数变量 http://blog.csdn.net/yue530tomtom/article/details/76651040__javaScript函数__javaScript可以用来执行JavaScript代码片段(非Java),并返回结果值。JMeter的__javaScript函数会调用标准...
  • 在Java函数中,有静态函数和非静态函数之分,学习过程中,我们学习到,静态函数不能访问非静态成员变量。 如下代码 class TestJava{ static int a=1; int x=10; static void print(){ System.out.println("a="+...
  • 静态变量http://www.cnblogs.com/dongzhiquan/archive/2009/07/21/1994792.html 一文静态变量进行了充分的阐述,现整理部分重要内容如下,加深印象。1、静态变量的存储方式和生命...2、静态局部变量:定义在函数体内
  • jmeter函数变量(三)

    千次阅读 2017-08-24 17:46:40
    接上篇 jmeter函数变量 http://blog.csdn.net/yue530tomtom/article/details/77456506__log记录一个日志并返回输入的字符串 Attribute Description Required 日志字符串 一个字符串 是 日志级别 OUT、ERR、...
  • 局部变量(内部变量):在定义它的函数内有效,但是函数返回后失效; 全局变量(外部变量):在所有源文件内均有效。在同源文件的函数中使用使用全局变量,需要将全局变量提前声明;同时在不包含全局变量定义的不...
  •  (1)、超全局变量在脚本中,任何一个地方都能被访问使用,任意一层函数,任意一个角落;  (2)、超全局变量主要有$GLOBALS、$_GET、$_POST.......都是以数组的形式展现; $a = 23; $b = 55; ...
  • 闭包是指在一个函数中定义了一个另外一个函数,内函数里运用了外函数的临时变量,并且外函数的返回值是内函数的引用,这样就构成了一个闭包 。 闭包的使用,可以隐藏内部函数的工作细节,只给外部使用者提供一个可以...
  • C语言之跨文件使用函数变量

    千次阅读 2019-07-01 10:10:50
    跨文件使用函数变量 这是主函数的代码: #include <stdio.h> #include <stdlib.h> /* run this program using the console pauser or add your own getch, system("pause") or input loop */ extern ...
  • C++静态成员变量和静态成员函数

    千次阅读 2015-11-29 20:28:41
    C++静态成员变量和静态成员函数 数据成员可以分静态变量、非静态变量两种.  静态成员:静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态...
  • python成员变量,成员函数的总结

    千次阅读 2018-05-01 23:29:54
    先贴代码:# encoding = UTF-8 class Test(object): value1 = 100 #静态成员变量 ... def __init__(self): #构造函数 self.value1 = 100 #成员变量value1,此处的value1和静态的value1不是同一个变量 self.value2 ...
  • javascript的函数内部变量的作用域

    千次阅读 2014-04-17 00:14:22
    javascript中的函数内部任何位置声明的变量,都在整个函数内部有效。 每种语言都有不同的特性,学习语言的时候,如果不透彻,容易有许多想当然的理解,就很容易处错误。自己学习的时候还是要注意呀~
  • 隐藏基类成员函数的情况:如果在派生类中定义了一个与基类同名的函数,不管这个函数的参数列表是不是与基类 中的函数相同,则这个同名的函数就会把基类中的所有这个同名的函数的所有重载版本都隐藏了,这时并不是在...
  • C++成员变量函数内存分配

    千次阅读 2013-08-25 20:36:59
    类分为成员变量和成员函数,我们先来讨论成员变量。 一个类对象的地址就是类所包含的这一片内存空间的首地址,这个首地址也就对应具体某一个成员变量的地址。(在定义类对象的同时这些成员变量也就被定义了)
  • C++ 函数总结(调用+函数+变量)

    千次阅读 2013-07-25 07:38:50
    函数的调用:先明确所调用函数的类型,参数类型,参数的个数,然后确定函数所在的库文件或头文件;明确形参与实参的值传递的过程,以及实参与形参的  区别 ,其中形参是函数中()的参数,如void max(int a, int b) ...
  • c++ 静态成员函数用static 关键字来声明,用于处理静态成员变量,可以用类名来调用,也可以用对象名来调用。 测试代码: #include <iostream> using namespace std; class Point{ public: Po...
  • 形式参数也属于局部变量。 2> 作用域:局部变量只在定义它的函数内部有效,即局部变量只有在定义它的函数内部使用,其它函数不能使用它。 全局变量 1> 定义:在所有函数外部定义的变量,称为全局变量。 2> ...
  • 1. 前带_的变量: 标明是一个私有变量, 只用于标明, 外部类还是可以访问到这个变量 2. 前带两个_ ,后带两个_ 的变量: 标明是内置变量, 3. 大写加下划线的变量: 标明是 不会发生改变的全局变量 函数: 1....
  • C++静态成员变量和成员函数

    千次阅读 2020-11-30 00:38:20
    1、静态成员变量 class Person { public: static int id_; }; int Person::id_ = 10;//int不能省,static不能加 ...1、静态成员函数不可以访问非静态成员。 2、静态成员独立于对象,没有this指针。 ...
  • JS函数概述 函数,是一种封装。就是将一些语句,封装到函数里面。通过调用的形式,执行这些语句。... 函数名字的命名规定,和变量的命名规定一样。只能是字母、数字、下划线、美元符号,不能以数字开头...
  • 1. 多个线程可以使用同一个全局函数,需不需要处理同步视具体情况而定。...3. 全局函数中如果涉及了全局变量,那么该全局变量访问应该进行同步处理,可使用临界区、事件、信号量以及互斥体来进
  • 多维数组作为函数参数的形式

    千次阅读 2015-03-24 14:26:14
     今天在看CSAPP的时候,直接敲入了书中的代码片段(P582),没有多加思考,却出现了段错误coredump,然后再纠结:被调用函数是否可以访问到主函数中的数据,函数中的自动变量存在栈中?最后才知道是函数声明的问题...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407,359
精华内容 162,943
关键字:

对函数变量的访问形式