C语言 static extern 关键字详解-CSDN博客

 

---

 

在C语言中主要是用来修饰变量和函数

1 全局变量

全局变量的作用域十分的广只要在一个源文件中定义后应用中所有的所有源文件、对象以及函数都可以调用生命周期更是贯穿整个程序

代码说明

文件 global_test.cpp 中

int g_num = 100;//定义全局变量

文件 main.cpp 中

extern int g_num;//声明全局变量 不需要包含头文件 也可以引用 使用extern关键字

int32 get_g_num();

int main()
{
    get_g_num();
    return 0;
}

int32 get_g_num()
{
    return g_num;
}

 

---

2 static 修饰全局变量

 

1. static 修饰全局变量其作用域会被限制在当前文件中

文件 global_test.cpp 中

#include "global_test.h"
// 如果全局变量被static修饰
// 那这个外部链接属性就会被修改成内部链接属性,
// 此时这个全局变量就只能在自己的源文件中使用
static int g_num = 100;//static 修饰全局变量 变量的作用域会被限制在当前文件中

文件 main.cpp 中

#include "keyword.h"
extern int g_num;//声明全局变量 不需要包含头文件 也可以引用 使用extern关键字
int main()
{
    printf("g_num = %d\n",g_num);
    return 0;
}

此时编译会发现没有定义变量 g_num 说明 g_num被限制在了 global_test.cpp

其本质是

全局变量本身是具有外部链接属性的在A文件中定义的全局变量在B文件中可以通过【链接】来使用
但如果全局变量被static修饰那这个外部链接属性就会被修改成内部链接属性此时这个全局变量就只能在自己的源文件中使用

2. 对static全局变量的修改对其他文件不可见

在另一个头文件中包含定义有静态全局变量头文件,此静态全局变量可以被引用

文件 global_test.h 中

static int g_num = 100;

文件 test.h 中

#ifndef KEYWORD_H
#define KEYWORD_H
#include "ctest.h"
#include "global_test.h" 
int32 print_g_num();
#endif // KEYWORD_H

文件 test.cpp 中

#include "keyword.h"

int32 print_g_num()
{
    // 在 global_test.h 头文件中定义的静态全局变量在文件被包含之后可以被正常访问
    printf("g_num = %d",g_num);
    return 0;
}

文件 main.c 中

#include <stdio.h>
#include "test.h"
int main()
{
    print_g_num();
    return 0;
}

静态全局变量被多次包含会出现重复定义错误么? 答案是不会 接下来验证

在 test_2.cpp中包含头文件 global_test.h

#include "global_test.h"
#include "stdio.h"
int print_g_num_1()
{
    printf("g_num = %d\n",g_num);
    return 0;
}

文件 main.c 中

#include <stdio.h>
#include "test.h"
extern int print_g_num_1();//函数声明
int main()
{
    print_g_num();// 正常访问 g_num
    print_g_num_1();// 正常访问 g_num
    return 0;
}

如果将 global_test.h 中的 static 关键字去掉,则上述代码编译之后会出现重复定义错误

在一个文件中对静态全局变量进行修改对其他文件不可见

global.h

#ifndef GLOBAL_TEST_H
#define GLOBAL_TEST_H
static int g_num = 100;//定义静态全局变量
int set_num_3(int num);
int print_num_3();
#endif // GLOBAL_TEST_H

global.c

#include "global_test.h"
int set_num_3(int num)
{
    printf("set_num_1 modi befor g_num = %d\n",g_num);
    g_num  = num;
}

int print_num_3()
{
    printf("g_num = %d\n",g_num);
    return 0;
}

test.c

int print_num_1()
{
    printf("g_num = %d\n",g_num);
    return 0;
}

int set_num_1(int num)
{
    printf("set_num_1 modi befor g_num = %d\n",g_num);
    g_num  = num;
}

#include "global_test.h"
#include "stdio.h"
int print_g_num_1()
{
    printf("g_num = %d\n",g_num);
    return 0;
}

int set_num_2(int num)
{
    printf("set_num_1 modi befor g_num = %d\n",g_num);
    g_num  = num;
}

int print_num_2()
{
    printf("g_num = %d\n",g_num);
    return 0;
}

main.c

#include <stdio.h>
#include "test.h"
#include "global_test.h"
//函数声明
extern int print_g_num_1();
extern int set_num_1(int);
extern int set_num_2(int);
extern int print_num_1();
extern int print_num_2();

int main()
{
     set_num_3(3);
     print_num_3();

     set_num_2(2);
     print_num_2();

     set_num_1(1);
     print_num_1();
}

输出结果

从输出结果可以得出结论 :
对静态全局变量的修改对其他文件是不可见的,相当于每个文件中都有一份初始的值,都一样,各自修改各自的,互不影响

 

---

3 static 修饰局部变量

 

看 coding
test.c

int  local_var_test()
{
    /**
       * 局部变量只是在第一次调用时会被初始化一次 数据是存储在全局区
       */
    static int index = 0;
    index ++;
    printf("index =  %d \n",index);
    return 0;
}

int  test()
{
    for (int i = 0;i < 10;++i){
         local_var_test();
    }
}

main.c

extern int  test();
int main()
{
    test();
}

output

index = 1
index = 2
index = 3
index = 4
index = 5
index = 6
index = 7
index = 8
index = 9
index = 10

 

---

4 static 修饰函数

 

在上面的代码中 我们只需要在 main.c中 声明 函数,即可完成对函数的调用

现在我们把函数声明为静态函数,即使用 static修饰,则此函数将会被限制在所在文件中,使用extern关键字也无法调用该函数

test.c

static int static_func_test()
{
    printf("static_func_test \n");
    return 0;
}

extern static_func_test();
int main()
{
    static_func_test();
}

此时编译报错,没有定义引用 static_func_test

函数本身也是有外部链接属性的
被static修饰后函数的外部链接属性被修改成内部链接属性使得这个函数只能在自己的源文件内被使用因此函数的作用域就变小了。

 

---

5 extern 关键字

 

extern 是一种外部声明的关键字字面意思就是在此处声明某种变量或函数在外部定义。

 
1 修饰变量

在其它文件中定义变量

int extern_val = 100;//定义变量 并进行初始化

在当前文件中引用变量

#include <stdio.h>
extern int extern_val;//声明变量 表示此处要进行引用
int main()
{
    printf("extern_val = %d\n",extern_val);
    return 0;
}

 

2 修饰函数
 

在其它头文件中定义函数
 

// 函数的定义
int printArr(int* pIntArr,int ilen){
    if (pIntArr == NULL || ilen == 0)
    {
        return 0;
    }
    for (int index = 0; index < ilen; index++){
        printf("%d ",pIntArr[index]);
    }
    return 0;
}

 

声明并引用函数
 

extern int printArr(int* pIntArr,int ilen);//函数的声明
int main()
{
    int intArr[] = {1,20,7,3,12};
    printArr(intArr,sizeof(intArr) / sizeof(int));
    return 0;
}