精华内容
下载资源
问答
  • 一、变量的作用域 所谓作用域(Scope),就是变量的有效...在函数内部定义的变量,它的作用域也仅限于函数内部,我们将这样的变量称为局部变量(Local Variable)。函数的形参也是局部变量,也只能在函数内部使用。.

    一、变量的作用域

    所谓作用域(Scope),就是变量的有效范围,就是变量可以在哪个范围以内使用。有些变量可以在所有代码文件中使用,有些变量只能在当前的文件中使用,有些变量只能在函数内部使用,有些变量只能在 for 循环内部使用。

    变量的作用域由变量的定义位置决定,在不同位置定义的变量,它的作用域是不一样的。


    二、在函数内部定义的变量(局部变量)

    在函数内部定义的变量,它的作用域也仅限于函数内部,我们将这样的变量称为局部变量(Local Variable)。函数的形参也是局部变量,也只能在函数内部使用。请看下面的例子:

    #include <stdio.h>
    
    int sum(int m, int n)
    {
        int i, sum=0;
        //m、n、i、sum 都是局部变量,只能在 sum() 内部使用
    
        for(i=m; i<=n; i++){
            sum+=i;
        }
    
        return sum;
    }
    
    int main()
    {
        int begin = 5, end = 86;
        int result = sum(begin, end);
        //begin、end、result 也都是局部变量,只能在 main() 内部使用
    
        printf("The sum from %d to %d is %d\n", begin, end, result);
    
        return 0;
    }

    m、n、i、sum 是局部变量,只能在 sum() 内部使用;begin、end、result 也是局部变量,只能在 main() 内部使用。

    对局部变量的两点说明:

    • main() 也是一个函数,在 main() 内部定义的变量也是局部变量,只能在 main() 函数内部使用。
    • 形参也是局部变量,将实参传递给形参的过程,就是用实参给局部变量赋值的过程,它和a=b; sum=m+n;这样的赋值没有什么区别。

    三、在所有函数外部定义的变量(全局变量)

    C语言允许在所有函数的外部定义变量,这样的变量称为全局变量(Global Variable)

    全局变量的默认作用域是整个程序,也就是所有的代码文件,包括源文件(.c文件)和头文件(.h文件)。如果给全局变量加上 static 关键字,它的作用域就变成了当前文件,在其它文件中就无效。我们目前编写的代码都是在一个源文件中,所以暂时不用考虑 static 关键字。

    【实例】定义一个函数,根据长方体的长宽高求它的体积以及三个面的面积。

    #include <stdio.h>
    
    //定义三个全局变量,分别表示三个面的面积
    int s1 = 0, s2 = 0, s3 = 0;
    
    int vs(int length, int width, int height)
    {
        int v;  //体积
    
        v = length * width * height;
        s1 = length * width;
        s2 = width * height;
        s3 = length * height;
    
        return v;
    }
    
    int main()
    {
        int v = 0;
    
        v = vs(15, 20, 30);
        printf("v=%d, s1=%d, s2=%d, s3=%d\n", v, s1, s2, s3);
        v = vs(5, 17, 8);
        printf("v=%d, s1=%d, s2=%d, s3=%d\n", v, s1, s2, s3);
    
        return 0;
    }

    运行结果:

    v=9000, s1=300, s2=600, s3=450
    v=680, s1=85, s2=136, s3=40

    根据题意,我们希望借助一个函数得到四份数据:体积 v 以及三个面的面积 s1、s2、s3。遗憾的是,C语言中的函数只能有一个返回值,我们只能将其中的一份数据(也就是体积 v)放到返回值中,其它三份数据(也就是面积 s1、s2、s3)只能保存到全局变量中。

    C语言代码从前往后依次执行,变量在使用之前必须定义或者声明,全局变量 s1、s2、s3 定义在程序开头,所以在 vs() 和 main() 中都有效。

    在 vs() 中将求得的面积放到 s1、s2、s3 中,在 main() 中能够顺利取得它们的值,这说明:在一个函数内部修改全局变量的值会影响其它函数,全局变量的值在函数内部被修改后并不会自动恢复,它会一直保留该值,直到下次被修改。

    全局变量也是变量,变量只能保存一份数据,一旦数据被修改了,原来的数据就被冲刷掉了,再也无法恢复了,所以不管是全局变量还是局部变量,一旦它的值被修改,这种影响都会一直持续下去,直到再次被修改。


    四、关于变量的命名

    每一段可运行的C语言代码都包含了多个作用域,即使最简单的C语言代码也是如此。

    int main()
    {
        return 0;
    }

    这就是最简单的、可运行的C语言代码,它包含了两个作用域,一个是 main() 函数内部的局部作用域,一个是 main() 函数外部的全局作用域。

    C语言规定,在同一个作用域中不能出现两个名字相同的变量,否则会产生命名冲突;但是在不同的作用域中,允许出现名字相同的变量,它们的作用范围不同,彼此之间不会产生冲突。这句话有两层含义:

    • 不同函数内部可以出现同名的变量,不同函数是不同的局部作用域;
    • 函数内部和外部可以出现同名的变量,函数内部是局部作用域,函数外部是全局作用域。


    (1)不同函数内部的同名变量是两个完全独立的变量,它们之间没有任何关联,也不会相互影响。请看下面的代码:

    #include <stdio.h>
    
    void func_a()
    {
        int n = 100;
    
        printf("func_a: n = %d\n", n);
        n = 86;
        printf("func_a: n = %d\n", n);
    }
    
    void func_b()
    {
        int n = 29;
    
        printf("func_b: n = %d\n", n);
        func_a(); //调用func_a()
        printf("func_b: n = %d\n", n);
    }
    
    int main()
    {
        func_b();
        return 0;
    }

    运行结果:

    func_b: n = 29
    func_a: n = 100
    func_a: n = 86
    func_b: n = 29

    func_a() 和 func_b() 内部都定义了一个变量 n,在 func_b() 中,n 的初始值是 29,调用 func_a() 后,n 值还是 29,这说明 func_b() 内部的 n 并没有影响 func_a() 内部的 n。这两个 n 是完全不同的变量,彼此之间根本“不认识”,只是起了个相同的名字而已,这就好像明星撞衫,北京和云南都有叫李红的,赶巧了而已。

    (2)函数内部的局部变量和函数外部的全局变量同名时,在当前函数这个局部作用域中,全局变量会被“屏蔽”,不再起作用。也就是说,在函数内部使用的是局部变量,而不是全局变量。

    变量的使用遵循就近原则,如果在当前的局部作用域中找到了同名变量,就不会再去更大的全局作用域中查找。另外,只能从小的作用域向大的作用域中去寻找变量,而不能反过来,使用更小的作用域中的变量。

    下面我们通过一个具体的例子来说明:

    #include <stdio.h>
    
    int n = 10;  //全局变量
    
    void func1()
    {
        int n = 20;  //局部变量
    
        printf("func1 n: %d\n", n);
    }
    
    void func2(int n)
    {
        printf("func2 n: %d\n", n);
    }
    
    void func3()
    {
        printf("func3 n: %d\n", n);
    }
    
    int main()
    {
        int n = 30;  //局部变量
    
        func1();
        func2(n);
        func3();
        printf("main n: %d\n", n);
       
        return 0;
    }

    运行结果:

    func1 n: 20
    func2 n: 30
    func3 n: 10
    main n: 30

    代码中虽然定义了多个同名变量 n,但它们的作用域不同,所有不会产生命名冲突。

    下面是对输出结果的分析:

    • 对于 func1(),输出结果为 20,显然使用的是 func1() 内部的 n,而不是外部的 n。
    • 调用 func2() 时,会把 main() 中的实参 n 传递给 func2() 中的形参 n,此时形参 n 的值变为 30。形参 n 也是局部变量,所以就使用它了。
    • func3() 输出 10,使用的是全局变量,因为在 func3() 中不存在局部变量 n,所以编译器只能到函数外部,也就是全局作用域中去寻找变量 n。
    • main() 中 printf() 语句输出 30,说明使用的是 main() 中的 n,而不是外部的 n。
    展开全文
  • 函数变量

    2020-01-11 17:17:24
    在函数外部定义的变量称为全局变量,可以在整个程序范围内使用访问,一般用大写字母表示 NAME = "ali" def funA(): age = 18 print(NAME) # 打印全局变量 print(age) #打印局部变量 def funC(): ...

    在函数内部定义的变量称为局部变量,只能在声明该变量的函数内部使用访问,一般用小写字母表示

    在函数外部定义的变量称为全局变量,可以在整个程序范围内使用访问,一般用大写字母表示

    NAME = "ali"
    
    def funA():
    
        age = 18
    
        print(NAME)  # 打印全局变量
    
        print(age)  #打印局部变量
    
    
    
    def funC():
    
        print(NAME)  # 打印全局变量
    
        print(age)
    
    执行funA()输出:
    ali
    18
    funA()
    执行funC()输出:
    ali
    NameError: name 'age' is not defined

    NAME是全局变量,在两个函数中都可以使用

    age是funA函数的局部变量,在funC中使用,提示变量没有定义的错误

     

    • 如果想在函数内部改变全局变量,需要在前面加上global关键字,在执行函数之后,全局变量值也会改变
    NAME = "ali"
    
    def funA():
    
        '''改变全局变量'''
    
        global NAME
    
        NAME = "阿狸"
    
        print("在函数内部将全局变量NAME的值改为: %s" %NAME)
    
    
    
    print("全局变量NAME原值: %s" %NAME)
    
    funA()
    
    print("改变后,全局变量NAME的值: %s" %NAME)

    结果输出

    全局变量NAME原值: ali

    在函数内部将全局变量NAME的值改为: 阿狸

    改变后,全局变量NAME的值: 阿狸

     

    • 在函数内部,如果局部变量与全局变量变量名相同,局部变量优先级高
    NAME = "ali"
    
    def funA():
    
        NAME = "ali001"
    
        print("在函数内部NAME的值是: %s"%NAME)
    
    
    
    funA()
    
    print("全局变量NAME的值是: %s" %NAME)

    结果输出:

    在函数内部NAME的值是: ali001

    全局变量NAME的值是: ali

    展开全文
  • 外部变量外部函数

    千次阅读 2011-08-25 20:29:41
    变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以称为...
    C程序由一组对象组成,这些对象包括程序中所使用的变量和实现特定功能的函数。变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以称为全局变量。

      由于C语言不允许在一个函数中定义其他函数,因此函数本身是外部的。一般情况下,也可以说函数是全局函数。在缺省情况下,外部变量与函数具有如下性质:所有通过名字对外部变量与函数的引用(即使这种引用来自独立编译的函数)都是引用的同一对象(标准中把这一性质称为外部连接)。

      由于外部变量是可以全局访问的,这就为在函数之间交换数据提供了一种可以替代函数变元欲返回值的方法。任何函数都可以用名字来访问外部变量,只要这个名字已在某个地方做了说明或定义。如果要在函数之间共享大量的变量,那么使用外部变量要比使用一个长长的变元表更方便、有效。然而,也可能导致程序在各个函数之间产生太多的数据联系。

      外部变量的用途还表现在它们比内部变量有更大的作用域和更长的生存期。内部自动变量只能在函数内部使用,当其所在函数被调用时开始存在,当函数退出时消失。而外部变量是永久存在的,他们的值在从一次函数调用到下一次函数调用之间保持不变。因此,如果两个函数必须共享某些数据,而这两个函数都互不调用对方,那么最为方便的是,把这些共享数据作为外部变量,而不是作为变元来传递。

    1、外部变量的定义和使用

      根据C语言标准,在程序的所有源文件中,外部变量只能被定义一次,否则会导致重复定义的编译错误。

    1.1 外部变量的定义与声明

      变量声明用于通报变量的性质(主要是变量的类型),而变量定义则除此之外还引起存储分配。如果在函数的外部包含如下说明:
    1. int    VarDesc;
    2. char          Array[MAXVAL];
    复制代码
    那么这两个说明定义了外部变量VarDesc与Array,并为之分配存储单元,同时也用作供源文件其余部分使用的说明。另一方面,如下两行:
    1. extern  int    VarDesc;
    2. extern  char          Array[];
    复制代码
    为源文件剩余部分声明了VarDesc是一个int 类型的外部变量,Array是一个char数组类型的外部变量(数组大小在其他地方确定),但这两个声明并没有建立变量或为它们分配存储单元,其中关键字extern表明该外部变量在其他地方被定义。

      根据C语言标准,外部变量虽然只能在某个文件中定义一次,但其作用域则是从其声明处开始一直到其所在的被编译的文件的末尾。因此其他文件可以通过extern说明来访问它。

    1.2 外部变量的使用方式

      如果外部变量被不同的函数所引用,并且这些函数没有集中在一个源文件中,而是分布在不同的源文件中,那么函数在引用这些外部变量时,必须采取先声明再使用的方式,否则,在编译时会导致重复定义的编译错误。

      若在多个文件的多个函数中引用外部变量,就需要在这些函数中重复声明外部变量。这种方式可以解决编译问题,但是代码不够简洁。因此,在实际的编程中,大都采取了将外部变量统一定义在一个C源文件中,这个C源文件一般被称为global.c,然后在对应的头文件中,一般为global.h,声明外部变量,最后在需要引用外部变量的源文件中使用#include "global.h"的方式,函数就可以引用所有的外部变量。因此,一般情况下,global.c内容为:
    1. #include "global.h"       

    2. /* for example, define two vars */
    3. int    VarDesc;
    4. char          Array[MAXVAL];
    5. /* other external var define */
    复制代码
    在对应的global.h头文件的内容则为:
    1. #ifndef _GLOBAL_H   /* please insure _GLOBAL_H unique */
    2. #define _GLOBAL_H   /* avoid quotation iterativly */

    3. #ifdef __cplusplus
    4. extern "C" {
    5. #endif   /*__cplusplus */

    6. /* for example, declare two vars */
    7. extern  int    VarDesc;
    8. extern  char          Array[];

    9. /* other external vars declaration */

    10. #ifdef __cplusplus
    11. }
    12. #endif  /* __cplusplus */

    13. #endif        /* _GLOBAL_H */
    复制代码
    此外,在实际的编程中,这两个文件头部还应当有公司copyright声明、文件功能说明、版本说明、创建、修改历史等。

    2、函数的定义和使用

      根据C语言标准,函数只能被定义一次,而且在函数中,不能再定义函数,因此函数本身是外部的。

    2.1 函数的定义与声明

      定义函数是给出函数体的函数描述。一个函数只有在声明之后才能被引用。函数声明中,需给出函数名、返回类型、参数列表等。

      函数的作用域从其声明处开始一直到其所在的被编译的文件的末尾,如果一个函数在定义之前就要使用到,或者这个函数定义在与所要使用它的源文件不相同的源文件中,那么就需要在使用该函数前,使用关键字extern声明该函数,但由于函数默认是external的,因此函数声明前的extern可以省略,这也是标准库函数的头文件中,函数声明前没有extern的原因,但在实际的编程中,一般不推荐这样做,应当在函数声明前加上extern。

    2.2 函数的组织和使用

      如果某个函数需要引用另一个函数,则需要在引用该函数前声明被引用的函数,否则可能会导致函数未定义错误。

      为了避免被引用函数的重复声明和方便函数的引用,在实际的编程之中,采用在对应的头文件中,统一声明函数的方式。需要引用某一个函数时,只需要在该函数的定义源文件中包含被引用函数的头文件即可。

      在实际的编程中,在头文件中声明函数,即声明函数原型,在对应的C源文件中,定义函数及其实现代码。因此,函数说明的头文件内容和格式为:
    1. #ifndef _FUNCNAME_H   /* please insure _ FUNCNAME _H unique */
    2. #define _ FUNCNAME _H   /* avoid quotation iterativly */

    3. #ifdef __cplusplus
    4. extern "C" {
    5. #endif   /*__cplusplus */

    6. /* for example, declare functions */
    7. extern  int    func (int, int, int);
    8. /* of course, maybe declare functions like below
    9. * int    func (int, int, int);
    10. */
    11. /* other functions declaration */

    12. #ifdef __cplusplus
    13. }
    14. #endif  /* __cplusplus */

    15. #endif        /* _ FUNCNAME _H */
    复制代码
    而在对应的C源文件内容为:
    1. #include " funcname.h"

    2. /* for example, define two vars */
    3. int    func (int a, int b, int c)
    4. {
    5.                 // functions body
    6. }

    7. /* other functions define */
    复制代码
    在实际的函数头文件和定义文件中还应当包含相应的头文件等,以及公司copyright声明、文件功能说明、版本说明、创建、修改历史等。对于具体的函数,还应当有函数说明、输入参数说明、返回说明、例外等。

    3、静态外部变量和函数

      如果某外部变量和函数仅供它们各自所在的源文件中的函数使用,而不能被其他函数访问,那么就必须使用static关键字定义外部变量和函数。static说明适用于外部变量与函数,用于把这些对象的作用域限定为被编译源文件的剩余部分。通过外部static对象,可以把一些外部变量和函数隐藏在某个源文件中,使得这些外部变量和函数仅仅可以被该源文件使用和共享,但不能被该源文件之外的函数所引用。

      另外,static说明也可以用于说明内部变量。内部静态变量就像自动变量一样局部于某一个特定函数,只能在该函数中使用,但与自动变量不同的是,不管其所作函数是否被调用,它都是一直存在的,而不像自动变量那样,随着所在函数的调用与退出而存在与消失。换而言之,内部静态变量是一种只能在某一特定函数中使用的但一直占据存储空间的变量。

      一般情况下,为保证静态外部变量和函数能够被本源文件的函数所引用,需要在该源文件的所有函数之前定义静态外部变量和函数。那么,该C源文件的内容为:
    1. #include “funcname.h”       

    2. /* for example, define one static external var and one static function */
    3. static   int VarName = 0;
    4. static   int function (int a)
    5. {
    6.                 // function body
    7. }
    8. /* other static vars and functions */

    9. /* for example, define one function */
    10. char          func (char*, char)
    11. {               
    12.                 VarName = 5;
    13.                 function (VarName);
    14.                 // other function body
    15. }

    16. /* other functions define */
    复制代码




    外部变量,变量定义在其他文件中全局变量
    
    extern可以置于变量或者函数前,以表示变量或者函数的定义在别的文件中,提示编译器遇到此变量和函数时在其他模块中寻找其定义。


    C语言外部变量的使用以及extern的用法

    C语言的外部变量的定义和引用对初学者来说,是个难点.

    对外部变量的说明和定义不是一回事.对外部变量的说明,只是声明该变量是在外部定义过的一个全局变量..在这里引用.而对外部变量的定义,则是要分配存储单元.一个全局变量只能定义一次,却可以多次引用.

    用extern声明外部变量,目的是可以在其它的文件中调用.具体使用见下面的例子:

                    file1.c                                                       file2.c

            int i,j;//定义全局变量                                extern   int i,j;//外部变量说明

            char c;                                                        extern char c;

           void func()                                                    void func1()

         {                                                                     {

             }                                                                    }

    在file2.c中对外部变量i,j,c进行了说明,就可以直接调用file1.c中定义的全局变量了

    静态变量static的使用

    有时在中断程序中定义了变量,不希望每次进入中断程序,变量就被赋初值.这时就要使用static变量.静态局部变量在编译时赋初值,既只赋初值一次.见下例:

    void serial_interrupt() interrupt 4 using 3

    { static uchar i="0";

       i++;

    }

    上例中,编译时,i被赋初值0,以后每进入一次中断,i+1,而不是每次进入中断,i都被请零,再加1

    如果在a.c中要调用在b.c中定义的函数func(),需要在a.c中声明该函数,表示该函数在别的源文件中定义。函数是可以互相调用的,因此函数都具有外部存储种类的属性。原则上调用一个在在本程序模块文件以外的其他模块文件所定义的函数,必须用关键字extern说明被调用函数是一个外部函数。实际使用中可以省掉extern。即下面两个函数声明没有明显的区别:

    extern int f();和int f();

    例如;

    #include "2.h"
    extern int a;
    int _tmain(int argc, _TCHAR* argv[])
    {
     test();
     printf("%d\n",a);
     
     return 0;
    }

     

    #include "2.h"
     int a;
    int test()
    {
     a=10;
     return 0;
    }

    //结果a=10;

    展开全文
  • 变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以称为...

    C程序由一组对象组成,这些对象包括程序中所使用的变量和实现特定功能的函数。变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以称为全局变量。

    由于C语言不允许在一个函数中定义其他函数,因此函数本身是外部的。一般情况下,也可以说函数是全局函数。
    在缺省情况下,外部变量与函数具有如下性质:所有通过名字对外部变量与函数的引用(即使这种引用来自独立编译的函数)都是引用的同一对象(标准中把这一性质称为外部连接)。

    由于外部变量是可以全局访问的,这就为在函数之间交换数据提供了一种可以替代函数变元欲返回值的方法。任何函数都可以用名字来访问外部变量,只要这个名字已在某个地方做了说明或定义。
    如果要在函数之间共享大量的变量,那么使用外部变量要比使用一个长长的变元表更方便、有效。然而,也可能导致程序在各个函数之间产生太多的数据联系。

    外部变量的用途还表现在它们比内部变量有更大的作用域和更长的生存期。内部自动变量只能在函数内部使用,当其所在函数被调用时开始存在,当函数退出时消失。而外部变量是永久存在的,他们的值在从一次函数调用到下一次函数调用之间保持不变。因此,如果两个函数必须共享某些数据,而这两个函数都互不调用对方,那么最为方便的是,把这些共享数据作为外部变量,而不是作为变元来传递。

    1、外部变量的定义和使用

    根据C语言标准,在程序的所有源文件中,外部变量只能被定义一次,否则会导致重复定义的编译错误。

    1.1 外部变量的定义与声明

    变量声明用于通报变量的性质(主要是变量的类型),而变量定义则除此之外还引起存储分配。如果在函数的外部包含如下说明:

    1.int    VarDesc;
    2.char      Array[MAXVAL];

    那么这两个说明定义了外部变量VarDesc与Array,并为之分配存储单元,同时也用作供源文件其余部分使用的说明。另一方面,如下两行:

    1.extern  int    VarDesc;
    2.extern  char      Array[];

    为源文件剩余部分声明了VarDesc是一个int 类型的外部变量,Array是一个char数组类型的外部变量(数组大小在其他地方确定),但这两个声明并没有建立变量或为它们分配存储单元,其中关键字extern表明该外部变量在其他地方被定义。

    根据C语言标准,外部变量虽然只能在某个文件中定义一次,但其作用域则是从其声明处开始一直到其所在的被编译的文件的末尾。因此其他文件可以通过extern说明来访问它。

    1.2 外部变量的使用方式

    如果外部变量被不同的函数所引用,并且这些函数没有集中在一个源文件中,而是分布在不同的源文件中,那么函数在引用这些外部变量时,必须采取先声明再使用的方式,否则,在编译时会导致重复定义的编译错误。

    若在多个文件的多个函数中引用外部变量,就需要在这些函数中重复声明外部变量。这种方式可以解决编译问题,但是代码不够简洁。因此,在实际的编程中,大都采取了将外部变量统一定义在一个C源文件中,这个C源文件一般被称为global.c,然后在对应的头文件中,一般为global.h,声明外部变量,最后在需要引用外部变量的源文件中使用#include "global.h"的方式,函数就可以引用所有的外部变量。因此,一般情况下,global.c内容为:

    1.#include "global.h"
    2. 
    3./* for example, define two vars */
    4.int    VarDesc;
    5.char      Array[MAXVAL];
    6./* other external var define */

    在对应的global.h头文件的内容则为:

    01.#ifndef _GLOBAL_H   /* please insure _GLOBAL_H unique */
    02.#define _GLOBAL_H   /* avoid quotation iterativly */
    03. 
    04.#ifdef __cplusplus
    05.extern "C" {
    06.#endif   /*__cplusplus */
    07. 
    08./* for example, declare two vars */
    09.extern  int    VarDesc;
    10.extern  char      Array[];
    11. 
    12./* other external vars declaration */
    13. 
    14.#ifdef __cplusplus
    15.}
    16.#endif  /* __cplusplus */
    17. 
    18.#endif  /* _GLOBAL_H */

    此外,在实际的编程中,这两个文件头部还应当有公司copyright声明、文件功能说明、版本说明、创建、修改历史等。

    2、函数的定义和使用

    根据C语言标准,函数只能被定义一次,而且在函数中,不能再定义函数,因此函数本身是外部的。

    2.1 函数的定义与声明

    定义函数是给出函数体的函数描述。一个函数只有在声明之后才能被引用。函数声明中,需给出函数名、返回类型、参数列表等。

    函数的作用域从其声明处开始一直到其所在的被编译的文件的末尾,如果一个函数在定义之前就要使用到,或者这个函数定义在与所要使用它的源文件不相同的源文件中,那么就需要在使用该函数前,使用关键字extern声明该函数,但由于函数默认是external的,因此函数声明前的extern可以省略,这也是标准库函数的头文件中,函数声明前没有extern的原因,但在实际的编程中,一般不推荐这样做,应当在函数声明前加上extern。

    2.2 函数的组织和使用

    如果某个函数需要引用另一个函数,则需要在引用该函数前声明被引用的函数,否则可能会导致函数未定义错误。

    为了避免被引用函数的重复声明和方便函数的引用,在实际的编程之中,采用在对应的头文件中,统一声明函数的方式。需要引用某一个函数时,只需要在该函数的定义源文件中包含被引用函数的头文件即可。

    在实际的编程中,在头文件中声明函数,即声明函数原型,在对应的C源文件中,定义函数及其实现代码。因此,函数说明的头文件内容和格式为:

    01.#ifndef _FUNCNAME_H   /* please insure _ FUNCNAME _H unique */
    02.#define _ FUNCNAME _H   /* avoid quotation iterativly */
    03. 
    04.#ifdef __cplusplus
    05.extern "C" {
    06.#endif   /*__cplusplus */
    07. 
    08./* for example, declare functions */
    09.extern  int    func (intintint);
    10./* of course, maybe declare functions like below
    11.* int    func (int, int, int);
    12.*/
    13./* other functions declaration */
    14. 
    15.#ifdef __cplusplus
    16.}
    17.#endif  /* __cplusplus */
    18. 
    19.#endif  /* _ FUNCNAME _H */
    20. 
    21.而在对应的C源文件内容为:
    22.#include " funcname.h"
    23. 
    24./* for example, define two vars */
    25.int    func (int a, int b, int c)
    26.{
    27.// functions body
    28.}
    29. 
    30./* other functions define */

    在实际的函数头文件和定义文件中还应当包含相应的头文件等,以及公司copyright声明、文件功能说明、版本说明、创建、修改历史等。对于具体的函数,还应当有函数说明、输入参数说明、返回说明、例外等。

    3、静态外部变量和函数

    如果某外部变量和函数仅供它们各自所在的源文件中的函数使用,而不能被其他函数访问,那么就必须使用static关键字定义外部变量和函数。static说明适用于外部变量与函数,用于把这些对象的作用域限定为被编译源文件的剩余部分。通过外部static对象,可以把一些外部变量和函数隐藏在某个源文件中,使得这些外部变量和函数仅仅可以被该源文件使用和共享,但不能被该源文件之外的函数所引用。

    另外,static说明也可以用于说明内部变量。内部静态变量就像自动变量一样局部于某一个特定函数,只能在该函数中使用,但与自动变量不同的是,不管其所作函数是否被调用,它都是一直存在的,而不像自动变量那样,随着所在函数的调用与退出而存在与消失。换而言之,内部静态变量是一种只能在某一特定函数中使用的但一直占据存储空间的变量。

    一般情况下,为保证静态外部变量和函数能够被本源文件的函数所引用,需要在该源文件的所有函数之前定义静态外部变量和函数。那么,该C源文件的内容为:

    01.#include “funcname.h”  
    02. 
    03./* for example, define one static external var and one static function */
    04.static   int VarName = 0;
    05.static   int function (int a)
    06.{
    07.// function body
    08.}
    09./* other static vars and functions */
    10. 
    11./* for example, define one function */
    12.char      func (char*, char)
    13.{      
    14.VarName = 5;
    15.function (VarName);
    16.// other function body
    17.}
    18. 
    19./* other functions define */

    参考文献:

    B.W.Kernighan, D.M.Ritchie著,徐宝文译,机械工业出版社 《C程序设计语言(第2版)》

    Bjarne Stroustrup著,裘宗燕译, 机械工业出版社 《C++程序设计语言(特别版)》

    展开全文
  • 变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以称为...
  • 声明部分出现的变量有两种情况:一种是需要建立存储空间的(如“int a;”),另一种是不需要建立存储空间的(如“extern int a;”)。前者称为定义性声明,或简称定义(definition);后者称为引用性声明。 广义地...
  • 声明部分出现的变量有两种情况:一种是需要建立存储空间的(如"int a;"), 另一种是不需要建立存储空间的(如"extern a;"). 前者称为定义性声明(defining declaration),或简称定义(definition); 后者称为引用性声明...
  • C++外部变量定义与使用

    千次阅读 2019-04-26 19:54:49
    在C++中, 定义于函数外的变量称为外部变量, 函数内的变量称为局部变量, 也叫自动变量. 外部变量只能被定义一次, 而且在函数内对外部变量的引用必须进行声明, 可用extern语句进行显示声明, 也可以上下文隐式声明, ...
  • 变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以称为...
  • 函数的变量 局部变量:在函数中定义的...注意,函数只能对全局变量做 print 操作,如果要做其他操作要用 global 声明是全局变量,同理,如果要在函数外部使用函数内部的全局变量也是用 global 来声明是全局变量 x...
  • 变量可以分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为外部变量,一般情况下,也可以
  • 全局变量 也称外部变量,在函数体外定义。 全局变量分为外部全局变量和静态...相对于全局变量而言的,即在函数定义的变量称为局部变量。形参也是一种局部变量。 生存期 所谓的生存期,是指变量占用内存或者寄...
  • C程式中外部变量和函数关系解惑 ...变量能够分为函数内部定义、使用的变量和函数外部定义的变量,通常情况下,把函数内部定义、使用的变量称为内部变量或局部变量,而将在函数外部定义的、供许多函数所使用的变量称为
  •  任何在函数中定义的变量,都可以认为是私有变量,因为不能在函数外部访问这些变量。私有变量包括函数的参数、局部变量和在函数内部定义的其他函数  【2】【特权方法】  如果在函数内部创建一个闭包,那么...
  • 任何在函数定义的变量,都可以认为是私有变量,因为不能再函数外部访问这些变量。私有变量包括函数的参数、局部变量和函数内部定义的其他函数。 【2】 【特权方法】 如果在函数内部创建一个闭包,那么闭包...
  • C语言局部变量外部变量

    千次阅读 2015-08-14 06:03:04
    在函数体或复合语句中声明的变量为局部变量。函数中的形式变量也是局部变量。在所有函数体外定义的变量称为外部变量(或全局变量)。
  • 全局变量和局部变量

    2020-08-04 22:07:31
    我们来了解一下全局变量和局部变量,在函数外部定义的变量称为全局变量 ,在函数内部定义的变量称为局部变量,全局变量可以在任意函数中使用,局部变量只能在函数定义局部变量的内部使用。下面,我们就通过汇编语言...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 718
精华内容 287
关键字:

在函数外部定义的变量称为