C++中static，extern和extern "C"关键字

1. extern 变量

　　extern 表明该变量在别的地方已经定义过了，在这里要使用那个变量。

　　当extern不与"C"在一起修饰变量或函数时，如在头文件中: extern int g_Int; 它的作用就是声明函数或全局变量的作用范围的关键字，其声明的函数和变量可以在本模块活其他模块中使用，记住它是一个声明不是定义!也就是说B模块(编译单元)要是引用模块(编译单元)A中定义的全局变量或函数时，它只要包含A模块的头文件即可,在编译阶段，模块B虽然找不到该函数或变量，但它不会报错，它会在连接时从模块A生成的目标代码中找到此函数。

　　源文件使用头文件中的变量不需要extern，#include指令已经足够，在某个源文件如果需要使用其他源文件中声明的变量就需要extern。

需要注意的地方：
　　在一个源文件里定义了一个数组：char a[6]; 只能在另一个文件使用extern char a[ ]而不是extern char *a，原因在于，指向类型T的指针并不等价于类型T的数组。extern char *a声明的是一个指针变量而不是字符数组，因此与实际的定义不同，从而造成运行时非法访问（注意，编译的时候是可以过的，但是运行的时候是一定出错）如果a[] = "abcd"，则外部变量a=0x61626364 (abcd的ASCII码值)，*a显然没有意义显然a指向的空间（0x61626364）没有意义，易出现非法内存访问。

　　一般不要在头文件extern函数，如果要使用函数，直接声明即可，可以避免函数修改的问题。一般extern函数可以用来连接其他cpp的函数，如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。下面例子

在test1.h中有下列声明：

#ifndef TEST1H
#define TEST1H
extern char g_str[]; 
// 声明全局变量g_strvoid fun1();#endif

　　在test1.cpp中

1 #include "test1.h"

char g_str[] = "123456"; // 定义全局变量g_str
2 void fun1()
3 { 
4     cout << g_str << endl; 
5 }

　　以上是test1模块，它的编译和连接都可以通过,如果我们还有test2模块也想使用g_str,只需要在原文件中引用就可以了

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

以上test1和test2可以同时编译连接通过，如果你感兴趣的话可以用ultraEdit打开test1.obj,你可以在里面找到"123456"这个字符串,但是你却不能在test2.obj里面找到，这是因为g_str是整个工程的全局变量，在内存中只存在一份，test2.obj这个编译单元不需要再有一份了，不然会在连接时报告重复定义这个错误!

有些人喜欢把全局变量的声明和定义放在一起，这样可以防止忘记了定义，如把上面test1.h改为

extern char g_str[] = "123456"; 
// 这个时候相当于没有extern

　　然后把test1.cpp中的g_str的定义去掉,这个时候再编译连接test1和test2两个模块时，会报连接错误，这是因为你把全局变量g_str的定义放在了头文件之后，test1.cpp这个模块包含了test1.h所以定义了一次g_str,而test2.cpp也包含了test1.h所以再一次定义了g_str,这个时候连接器在连接test1和test2时发现两个g_str。如果你非要把g_str的定义放在test1.h中的话，那么就把test2的代码中#include "test1.h"去掉换成：

1 extern char g_str[];
2 void fun2() 
3 { 
4      cout << g_str << endl; 
5 }

这个时候编译器就知道g_str是引自于外部的一个编译模块了，不会在本模块中再重复定义一个出来，但是我想说这样做非常糟糕，因为你由于无法在test2.cpp中使用#include "test1.h",那么test1.h中声明的其他函数你也无法使用了。

2. static变量

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

　　static 作用范围是内部连接的关系，和extern有点相反.它和对象本身是分开存储的,extern也是分开存储的,但是extern可以被其他的对象用extern引用,而static 不可以，只允许对象本身用它。具体差别首先，extern和static不能同时修饰一个变量；其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了；最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它，如：

 1 //(1) test1.h:#ifndef TEST1H#define TEST1H
 2 static char g_str[] = "123456";
 3 void fun1();
 4 #endif
 5 //(2) test1.cpp:
 6 #include "test1.h"
 7 void fun1() 
 8 { 
 9     cout << g_str << endl; 
10 }
11 //(3) test2.cpp
12 #include "test1.h"
13 void fun2() 
14 { 
15     cout << g_str << endl; 
16 }

以上两个编译单元可以连接成功, 当你打开test1.obj时，你可以在它里面找到字符串"123456",同时你也可以在test2.obj中找到它们，它们之所以可以连接成功而没有报重复定义的错误是因为虽然它们有相同的内容，但是存储的物理地址并不一样，就像是两个不同变量赋了相同的值一样，而这两个变量分别作用于它们各自的编译单元。但大多数编译器都对代码都有优化功能，以达到生成的目标程序更节省内存，执行效率更高，当编译器在连接各个编译单元的时候，它会把相同内容的内存只拷贝一份，比如上面的"123456", 位于两个编译单元中的变量都是同样的内容，那么在连接的时候它在内存中就只会存在一份了，但如果你把上面的代码改成下面的样子，这个优化就会被忽略：

//(1) test1.cpp:
#include "test1.h"
void fun1()
{
     g_str[0] = ''a'';
     cout << g_str << endl;
}
//(2) test2.cpp
#include "test1.h"
void fun2() 
{ 
     cout << g_str << endl; 
}
//(3) main.cppint 
int main(int argc, char *argv[]) 
{
     fun1(); // a23456
     fun2(); // 123456
}

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

3. 关于extern "C"

C++是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C有明显的不同。为了支持C函数的使用，加了extern "C"关键字。

1. 未加extern “C”声明时的编译方式

　　首先看看C++中对类似C的函数是怎样编译的。
　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
　　void foo( int x, int y );
　　该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。
　　同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。
　　假设在C++中，模块A的头文件如下：

// 模块A头文件　moduleA.h#ifndef MODULE_A_H
#define MODULE_A_H
int foo(int x, int y);
#endif

　　在模块B中引用该函数：

// 模块B实现文件　moduleB.cpp
#include "moduleA.h"
foo(2, 3);

　　实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号。
　　加extern "C"声明后，模块A的头文件变为：

// 模块A头文件　moduleA.h#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo(int x, int y);
#endif

　　在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：
　　（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；
　　（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。
　　如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

　　2. 在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

extern "C"
{　　
     #include "cExample.h"
}

　　而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

3. 在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件C++中定义的extern "C"函数声明为extern类型。
　　C引用C++函数例子工程中包含的三个文件的源代码如下：

 1 //C++头文件 cppExample.h
 2 #ifndef CPP_EXAMPLE_H
 3 #define CPP_EXAMPLE_H
 4 extern "C" int add(int x, int y);
 5 #endif
 6 //C++实现文件 cppExample.cpp
 7 #include "cppExample.h"
 8 int add(int x, int y)
 9 {
10     return x + y;
11 }
12 /* C实现文件 cFile.c
13 /* 这样会编译出错：#include "cExample.h" */（C不允许extern "C"）
14 extern int add(int x, int y);
15 int main(int argc, char* argv[])
16 {
17     add(2, 3);
18     return 0;
19 }
20

　　4. 在C++环境下使用C函数的时候，常常会出现编译器无法找到obj模块中的C函数定义，从而导致链接失败的情况，C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，下面是一个标准的写法：

 1 #ifdef __cplusplus
 2 #if __cplusplus
 3 extern "C" {
 4 #endif
 5 #endif /* __cplusplus */ 
 6     void fcn1()
 7     {
 8         cout << std::left << std::setw(30) << &num << num << endl;
 9     }
10 //.h文件结束的地方
11 #ifdef __cplusplus
12 #if __cplusplus
13 }
14 #endif
15 #endif /* __cplusplus */

Reference:

　　http://blog.csdn.net/lwbeyond/article/details/6579512

　　http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777431.html