extern用法详解:

1. 声明外部实体

声明外部全局变量或对象，一般用于头文件中，表示在其它编译单元内定义的变量，链接时进行外部链接，如： 
extern int ivalue; 
此时的extern是必须的，省略了extern编译器将视为定义而不是声明，一般地在源代码中定义变量并进行初始化，在头文件中使用extern声明变量。

类似地用于声明外部全局函数，表示该函数在其它编译单元中定义，如： 
extern void func( void ); 
此时的extern可以省略。

2. 声明函数的编译和链接方式

extern 后可以跟"C"或"C++"用于声明全局函数的编译和链接方式，例如： 

1 extern "C" void add( int a, int b); 
2 extern "C++" void sum(int* ia, int leng); 
3 void sum(int* ia, int leng); 

其中的extern "C++"可以省略，它是在C++中默认的链接方式，即后面两种声明方式是等效的。这种声明有两种含义：首先，声明这些函数使用外部链接方式，其实现不在本编译单元之内；另一种含义，则是告诉编译器编译方式，如extern "C"则是告诉编译器使用C语言的编译方式编译该函数。

C++支持函数重载，所以参数不同在编译后生成的函数名也不同，如： 

int max(int a, int b);
int max(float a, float b);

在编译时生成的函数名可能分别为_max_int_int、_max_float_float，通过在函数名后加上参数类型来区分不同的函数，如果使用C语言方式，则生成的函数名中不包含参数信息，只生成_max，所以无法实现重载，也就是说在extern “C”中不能出现函数名重载，例如： 

1 extern "C" {
2     int max(int a, int b);
3     int max(float a, float b);
4 }

非法，编译器将报错。而C++标准中并没有定义extern “C”与extern “C++”的具体实现方式，不同编译器生成的符号规则可能不同。

需要注意的是，如果函数声明使用了extern "C"，则函数定义必须使用C编译器编译，或者使用extern "C"来修改函数的编译方式，一般地将extern "C"声明的函数的定义所在的源程序扩展名使用.c即可，而C++代码放在.cpp文件中。如果将extern "C"声明的函数实现也放在.cpp中，则需要使用extern "C"来声明函数编译方式，例如： 

1 extern "C" {
2     int max( int a, int b)
3     {
4         return a > b ? a : b;
5     }
6 }

只有在C++中使用C语言的库或者两种语言混合编程的时候才会用到extern "C"，而在C语言中是不支持extern "C"的，所以为了头文件通用，需要使用宏来控制，例如： 

 1 #ifndef MAX_H // 防止重复引用 
 2 #define MAX_H 
 3 #ifdef __cplusplus 
 4 extern "C" { 
 5 #endif 
 6 int max (int a, int b); 
 7 #ifdef __cplusplus 
 8 } 
 9 #endif 
10 #endif 

其中__cplusplus为C++定义的宏，凡是C++的编译器都定义了该预编译宏，通过它来检测当前编译器是否使用的是C++编译器。

extern和static比较：

（1）extren表明该变量在别的地方已经定义过，而在这里要使用那个变量。

（2）static表示静态的变量，分配内存时，存储在静态区，不存储在栈上面。

static 作用范围是内部连接的关系, 和extern有点相反.它和对象本身是分开存储的,extern也是分开存储的,但是extern可以被其他的对象用extern 引用,而static 不可以,只允许对象本身用它。

具体差别：首先，static与extern是一对“水火不容”的家伙，也就是说extern和static不能同时修饰一个变量；其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了；最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它,如:

（1）test.h:

1 #ifndef TEST1H
2 #define TEST1H
3 static char g_str[] = "123456";
4 void fun1();
5 #endif

（2）test1.cpp:

1 #include "test.h"
2 void fun1()
3 {
4     cout << g_str << endl;
5 }

（3）test2.cpp

1 #include "test.h"
2 void fun2()
3 {
4     cout << g_str << endl;
5 }

以上两个编译单元可以连接成功, 当你打开test1.obj时，你可以在它里面找到字符串"123456",同时你也可以在test2.obj中找到它们，它们之所以可以连接成功而没有报重复定义的错误是因为虽然它们有相同的内容，但是存储的物理地址并不一样，就像是两个不同变量赋了相同的值一样，而这两个变量分别作用于它们各自的编译单元。 也许你比较较真，自己偷偷的跟踪调试上面的代码,结果你发现两个编译单元（test1,test2）的g_str的内存地址相同，于是你下结论static修饰的变量也可以作用于其他模块，但是我要告诉你，那是你的编译器在欺骗你，大多数编译器都对代码都有优化功能，以达到生成的目标程序更节省内存，执行效率更高，当编译器在连接各个编译单元的时候，它会把相同内容的内存只拷贝一份，比如上面的"123456", 位于两个编译单元中的变量都是同样的内容，那么在连接的时候它在内存中就只会存在一份了，如果你把上面的代码改成下面的样子，你马上就可以拆穿编译器的谎言:

（1）test1.cpp:

1 #include "test.h"
2 void fun1()
3 {
4     g_str[0] = ‘a‘;
5     cout << g_str << endl;
6 }

（2）test2.cpp

1 #include "test.h"
2 void fun2()
3 {
4     cout << g_str << endl;
5 }

（3）main

1 void main()
2 {
3     fun1(); // a23456
4     fun2(); // 123456
5 }

这个时候你在跟踪代码时，就会发现两个编译单元中的g_str地址并不相同，因为你在一处修改了它，所以编译器被强行的恢复内存的原貌，在内存中存在了两份拷贝给两个模块中的变量使用。正是因为static有以上的特性，所以一般定义static全局变量时，都把它放在原文件中而不是头文件，这样就不会给其他模块造成不必要的信息污染，同样记住这个原则吧！

extern和const比较：

C++中const修饰的全局常量据有跟static相同的特性，即它们只能作用于本编译模块中，但是const可以与extern连用来声明该常量可以作用于其他编译模块中, 如extern const char g_str[];
然后在原文件中别忘了定义:     const char g_str[] = "123456"; 

所以当const单独使用时它就与static相同，而当与extern一起合作的时候，它的特性就跟extern的一样了！所以对const我没有什么可以过多的描述，我只是想提醒你，const char* g_str = "123456" 与 const char g_str[] ="123465"是不同的， 前面那个const 修饰的是char *而不是g_str,它的g_str并不是常量，它被看做是一个定义了的全局变量（可以被其他编译单元使用）， 所以如果你像让char*g_str遵守const的全局常量的规则，最好这么定义const char* const g_str="123456"。

[C/C++] extern关键字详解以及与static、const区别