extern与static分析

本文转载链接：http://blog.csdn.net/feliciafay/article/details/12251923

本文参考了《Linux一站式编程》第 19 章  汇编与C之间的关系，第20章链接详解。这里主要区分static和external的在链接属性上的不同，它们的其它用法不涉及。static和external可以修饰变量也可以修饰函数，下文主要分成这两块来讲述。

1 原理 

1.1 首先，关于声明和定义的区别。

[cpp] view plain copy

1. void print_one_line(void);  

这种写法(函数原型后加;号表示结束的写法)只能叫函数声明而不能叫函数定义，

只有带函数体的声明才叫定义，比如下面

[cpp] view plain copy

1. void print_one_line(void)  
2. {  
3.     print("\n");  
4. }  

只有分配存储空间的变量声明才叫变量定义，其实函数也是一样，编译器只有见到函数定义才会生成指令，而指令在程序运行时当然也要占存储空间。那么没有函数体的函数声明有什么用呢？它为编译器提供了有用的信息，编译器在翻译代码的过程中，只有见到函数原型（不管带不带函数体）之后才知道这个函数的名字、参数类型和返回值，这样碰到函数调用时才知道怎么生成相应的指令，所以函数原型必须出现在函数调用之前，这也是遵循“先声明后使用”的原则。

1.2 标识符的链接属性（Linkage）有三种

外部链接（ExternalLinkage）

如果最终的可执行文件由多个程序文件链接而成，一个标识符在任意程序文件中即使声明多次也都代表同一个变量或函数，则这个标识符具有External Linkage。具有External Linkage的标识符编译后在符号表中是GLOBAL的符号。

内部链接（InternalLinkage）

如果一个标识符在某个程序文件中即使声明多次也都代表同一个变量或函数，则这个标识符具有Internal Linkage。具有Internal Linkage的标识符编译后在符号表中是LOCAL的符号。

无链接（NoLinkage）

除以上情况之外的标识符都属于No Linkage的，例如函数的局部变量，以及不表示变量和函数的其它标识符。

1.3 声明和定义的次数限制

凡是被多次声明的变量或函数，必须有且只有一个声明是定义，如果有多个定义，或者一个定义都没有，链接器就无法完成链接。

显然，声明可以有很多次。

2 用extern和static修饰函数

测试案例2.1

[cpp] view plain copy

1. // extern_static_test1.h 文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include <stdlib.h>  
3. #include <stdio.h>  
4.   
5. void print_01(void);//函数不写任何声明的情况和写了extern声明的情况等价  
6. extern void print_02(void);//函数不写任何声明的情况和写了extern声明的情况等价，函数的声明默认是extern的  
7. static void print_03(void);//static修饰函数声明，说明此函数仅仅被此文件内部使用,即被extern_static_test1.h和extern_static_test1.cpp内部调用。不能被main.cpp调用。  
8. void  print_04(void);  

[cpp] view plain copy

1. //extern_static_test1.cpp 文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. void print_01(void)  
4. {  
5.     printf("test_01\n");  
6.     return;  
7. }  
8.   
9. void print_02(void)  
10. {  
11.     printf("test_02\n");  
12.     return;  
13. }  
14.   
15. void print_03(void)  
16. {  
17.     printf("test_03\n");  
18.     return;  
19. }  
20.   
21. void print_04(void)  
22. {  
23.     printf("call print_03() in print_04() start\n");  
24.     print_03();  
25.     printf("call print_03() in print_04() finish\n");     
26.     return;  
27. }  

[cpp] view plain copy

1. //main.cpp文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. int main()  
4. {  
5.     print_01();  
6.     print_02();  
7.     print_03();  
8.     print_04();  
9.   
10.     int a =getchar();  
11. }  

测试案例2.1结果

编译不能通过，error C2129: 静态函数“void print_03(void)”已声明但未定义

因为print_03在extern_static_test1.h中被声明为static。当static修饰函数的时候，说明此函数只能被自己内部的文件使用，即具有internal linkage.因此main不能调用extern_static_test1.h中被static修饰的函数。

如有有这样几个文件a.h, a.cpp, main.cpp。其中a.h被a.cpp和main.cpp所包含，那么a.h中用static 修饰的函数只能被a.cpp中的函数调用，不能被main.cpp中的函数调用.这个internal linkage属性就被确定了。即使你故意在main.cpp中进行一次external的声明(如extern void print_03(void);)也不能改变此internal linkage链接属性。

测试案例2.2

为了修正测试案例2.1的错误，在main.cpp中删除print_03();其它文件保持不变

[cpp] view plain copy

1. //main.cpp文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. int main()  
4. {  
5.     print_01();  
6.     print_02();  
7. //  print_03(); 链接出错，故删除  
8.     print_04();  
9.   
10.     int a =getchar();  
11. }  

则编译没有错误了，运行结果是,

测试案例2.2结果

1.  print_02()说明，函数被声明为external后，才能做到在多个文件中多次声明的情况下，依然指示同一个定义。

2.  print_01()说明，函数声明如果不加external，也不加static，则默认为external.

3.  print_04()说明，如果函数声明使用了static修饰符，则这个函数具有internallinkage，只能被声明所在的文件内部调用。所以这里的print_04()调用了声明为static的print_03()。print_04()不具有static属性，所以在main.cpp中能够被调用。

测试案例2.3

在main.cpp中强制用extern修饰符声明print_03();其它文件保持不变会发生什么？

[cpp] view plain copy

1. //main.cpp文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. extern void print_03(void);  
4. int main()  
5. {  
6.     print_01();  
7.     print_02();  
8.     print_03();  
9.     print_04();  
10.   
11.     int a =getchar();  
12. }  

测试案例2.3结果

依然出现编译错误。说明，在a.h中已经被声明为static的文件，被main.cpp包含之后，main.cpp中不能修改它的属性为external。

3 用extern和static修饰变量

测试案例3.1

由于是变量定义，所以不写在extern_static_test1.h中，extern_static_test1.h和上文保持基本一致，为了简化，只保留了一个函数。

[cpp] view plain copy

1. // extern_static_test1.h 文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include <stdlib.h>  
3. #include <stdio.h>  
4. void print_01(void);   

变量定义写在了extern_static_test1.cpp中，如下

[cpp] view plain copy

1. //extern_static_test1.cpp 文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. int var1=0;  
4. extern int var2=0;  
5. static int var3=0;  
6. void print_01(void)  
7. {  
8.     printf("test_01\n");  
9.     return;  
10. }  

现在来看看main.cpp文件

[cpp] view plain copy

1. //main.cpp文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. extern int var1;  
4. extern int var2;  
5. extern int var3;  
6. int main()  
7. {  
8.     print_01();  
9.       
10.     var1=10;  
11.     printf("var1 = %d\n",var1);  
12.       
13.     var2 = 20;  
14.     printf("var2 = %d\n",var2);  
15.       
16.     var3=30;  
17.     printf("var2 = %d\n",var3);  
18.   
19.     int a =getchar();  
20. }  

测试案例3.1结果

编译发现，var1和var3都出现了编译错误。

这说明，虽然已经在这里丧心病狂地对3个变量的生命都写明了extern.

extern int var1;

extern int var2;

extern int var3

但是，

因为在extern_static_test1.cpp的文件中，var3已经被定义为了static，所以它具有internallinkage了，只能在extern_static_test1.cpp中被使用了，不能在main.cpp中被使用了

因为在extern_static_test1.cpp的文件中，var1没有修饰符，变量如果没有链接属性的修饰符，默认是static。这和函数正好相反，函数如果没有链接属性的修饰符，默认是external。想想，这样设定是符合实际需求的，函数就是用来进行操作，被调用的，默认external更方便，变量不应该被随意使用，而应该被函数操作，这样才安全。

main.cpp修改之后，正确

[cpp] view plain copy

1. //main.cpp文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. external int var2;  
4. int main()  
5. {  
6.     print_01();   
7.     var2 = 20;  
8.     printf("var2 = %d\n",var2);  
9.       
10.     int a =getchar();  
11. }  

测试案例3.2

如果把main.cpp中external声明的关键字external去掉，extern_static_test1.h和extern_static_test1.cpp保持不变，这样是否正确呢?

[cpp] view plain copy

1. //main.cpp文件，参考《LINUX一站式编程》测试static 和extern的用法  
2. #include "extern_static_test1.h"  
3. int var2;  
4. int main()  
5. {  
6.     print_01();   
7.     var2 = 20;  
8.     printf("var2 = %d\n",var2);  
9.       
10.     int a =getchar();  
11. }  

测试案例3.2结果

出现编译错误，说明，如果要使得一个变量具有external linkage，必须在定义时和声明时都得加上external 修饰符，比如这里需要在extern_static_test1.cpp中var2的定义和main.cpp中的var2的声明中都写上external修饰符。因为变量默认是static，你要不特别说明它是external，那就默认是static了。