ShenYuanLuo的博客

记录学习的点点滴滴

0%

小谈C语言之static和extern

发表于 更新于 分类于 阅读次数：

变量的不同类型，决定了其生命周期及其作用域。

extern

extern 可以用来修饰变量，也可以用来修饰函数。

  1. 对于函数来说，既可以是声明一个外部函数，也可以是定义一个函数；如：

  • 例子一：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    // test.c    
        
    #include <stdio.h>    
        
    void test()    
    {    
       printf("我是来自源文件test.c中的test函数！");    
    } 


    //main.c    
        
    #include <stdio.h>    
        
    extern void test();  //声明一个外部函数test    
        
    int main()    
    {    
           test();   //调用test.c中的函数test    
        
           return 0;    
    }    

  • 例子二：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    // test.c    
        
    #include <stdio.h>    
        
    extern void test()  //定义一个函数    
    {    
          printf("我是来自源文件test.c中的test函数");    
    }  


    // main.c  
      
    #include <stdio.h>    
        
    extern void test();  //声明一个外部函数test    
        
    int main()    
    {    
           test();   //调用test.c中的函数test    
        
           return 0;    
    }  

  1. 对于变量来说，只能用来声明变量，而**不**可以定义变量；如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    //test.c    
        
    #include <stdio.h>    
        
    int a;  //定义一个变量a    
        
    void test ()    
    {    
           printf("a = %d",a);    
    } 


    //main.c    
        
    #include <stdio.h>    
        
    extern int a;   //声明一个外部变量a ，这里不是定义变量    
    extern void test();   //声明一个外部函数test    
        
    int main()    
    {    
          a = 10;    
          test();    
        
          return 0;    
    } 

static

static 可以用来修饰变量，也可以用来修饰函数。

  1. 对于函数来说，可以定义一个内部函数；如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    //test.c    
        
    #include <stdio.h>    
        
    static void test()    //定义一个内部函数    
    {    
          printf("我是test.c中的内部函数，其他文件无法访问。");    
    }


    //main.c    
        
    #include <stdio.h>    
        
    extern void test();   //声明一个外部函数test，以便main.c文件可以访问    
        
    int main()    
    {    
            test();    //这里调用外部函数test    
        
            return 0;    
    } 

这里编译是没有错误，运行时就会报错，因为main中的test()函数找不到定义。

  1. 对于变量来说，可以定义一个内部变量；如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    //test.c    
        
    #include <stdio.h>    
        
    static int a;    // 定义内部变量
        
    void test()    
    {    
          printf("a = %d",a);    
    }


    #include <stdio.h>    
        
    extern void test();    //声明一个外部函数test，以便main.c中可以访问    
    extern int a;     //声明一个外部变量a，不是定义    
        
    int main()    
    {    
           a = 10;    //对外部变量a进行赋值    
           test();    //调用外部函数    
        
           return 0;    
    }      

    此时的运行结果是 ：** a = 0**
    因为在test.c中的变量a定义为内部变量，默认初始化为0.

小结

extern ：改变作用域
static ：改变生命周期