C++全局变量、extern/static/const浅析

例子：
头文件：state.h 源文件：state.cpp
其它源文件：t1.cpp t2.cpp t3.cpp, 这些源文件都包含头文件state.h。
需要定义一个全局变量供这些源文件中使用：方法如下
1、在 state.h声明全局变量： extern int a;
2、在state.cpp中定义该全局变量：int a = 10;
这样其它源文件就可以使用该变量啦

这里需要的是“声明”，不是“定义”！根据C++标准的规定，一个变量声明必须同时满足两个条件，否则就是定义：
(1)声明必须使用extern关键字；
(2)不能给变量赋初值

extern int a;   //声明 
int a;   //定义
int a=0; //定义
extern int a=0; //定义

头文件中应使用extern 关键字声明全局变量（不定义），如果这个变量有多个文件用到，可以新建一个cpp，在其中定义，把这个cpp加入工程即可。头文件请不要定义任何变量，那是非常业余的行为……
一般在头文件中申明，用extern, 在cpp中定义。 如果在头文件中定义，如果这个头文件被多个cpp引用，会造成重复定义的链接错误。
头文件只能申明全局变量（extern），不可定义（不推荐使用） .cpp里，在最外层定义即可（int gi），直接引用
如果在.cpp里使用static定义，则该变量只在当前cpp文件中有效，在别的文件中无效
在.h里使用static定义，不会进行编译（.h文件不编译），只会在其每个include的cpp文件中包含编译，相当于在.cpp里使用static 定义。

转自：http://blog.sina.com.cn/s/blog_74a459380101rjh4.html

---

另一篇文章：
全局变量｜extern ｜static｜const 用法小结

1，声明与定义的区别
函数或变量在声明时，并没有给它实际的物理内存空间 。只有当函数或变量定义的时候，才在内存中分配实际的物理空间。声明有时可以保证程序编译通过，但是，如果你在编译模块中引用的外部变量没有在整个工程中任何一个地方定义的话，那么即使它在编译时可以通过，在连接时也会报错，因为程序在内存中找不到这个变量。对同一个变量或函数的声明可以有多次，而定义只能有一次!（我一般在头文件中声明，在.c/.cpp文件中定义）。
2，全局变量
全局变量：在函数外定义，存储在静态存储区，在程序运行期间都不释放。全局变量的作用域为从声明或定义处开始，到文件结束。当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问（不能直接访问，需要先使用extern声明才能访问）。
3，extern
extern有两个作用。
第一个,当它与”C”一起连用时，如: extern “C” void fun(int a, int b); 则告诉编译器在编译fun这个函数名时按着C的规则去翻译相应的函数名而不是C++的， C++的规则在翻译这个函数名时会把fun这个名字变得面目全非，可能是[e-mail]_int_int#%$也可能是别的，不同的编译器采用的方法不一样（原因是：C++支持函数的重载）。
第二种，当extern不与”C”在一起修饰变量或函数时，如在头文件中: extern int g_Int; 它的作用就是声明函数或全局变量的作用范围的关键字，其声明的函数和变量可以在本模块或者其他模块中使用，记住它是一个声明不是定义!也就是说B模块(编译单元)要是引用模块(编译单元)A中定义的全局变量或函数时，它只要包含A模块的头文件即可,在编译阶段，模块B虽然找不到该函数或变量，但它不会报错，它会在连接时从模块A生成的目标代码中找到此函数。
用extern修饰的全局变量
以上已经说了extern的作用，下面我们来举个例子,如:

在test1.h中有下列声明:  
#ifndef TEST1H  
#define TEST1H  
extern char g_str[]; // 声明全局变量g_str  
void fun1();  
#endif  
在test1.cpp中  
#include "test1.h"  

char g_str[] = "123456"; // 定义全局变量g_str  

void fun1()  
{  
    cout << g_str << endl;  
}  

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

void fun2()  
{  
    cout << g_str << endl;  
}  

以上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”去掉换成:

extern char g_str[];  
void fun2()  
{  
    cout << g_str << endl;  
}  

这个时候编译器就知道g_str是引自于外部的一个编译模块了，不会在本模块中再重复定义一个出来，但是我想说这样做非常糟糕，因为你由于无法在 test2.cpp中使用#include “test1.h”,那么test1.h中声明的其他函数你也无法使用了，除非也用都用extern修饰，这样的话你光声明的函数就要一大串，而且头文件的作用就是要给外部提供接口使用的，所以请记住，只在头文件中做声明，真理总是这么简单。

4.static
static分配在静态存储区, 在程序整个运行期间都不释放。static与extern是一对“水火不容”的家伙，也就是说extern和static不能同时修饰一个变量；其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了；最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它
(1)static局部变量
static局部变量在所处模块在初次运行时进行初始化工作, 且只操作一次。对于局部静态变量, 如果不赋初值, 编译期会自动赋初值0或空字符。
（2）外部静态变量／函数
用来表示不能被其它文件访问的全局变量和函数。, 但为了限制全局变量/函数的作用域, 函数或变量前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。注意此时, 对于外部(全局)变量, 不论是否有static限制, 它的存储区域都是在静态存储区, 生存期都是全局的. 此时的static只是起作用域限制作用, 限定作用域在本模块(文件)内部.
使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。
示例程序三:

//file1.cpp

static int varA;
int varB;
extern void funA()
{
……
}

static void funB()
{
……
}

//file2.cpp

extern int varB; // 使用file1.cpp中定义的全局变量
extern int varA; // 错误! varA是static类型, 无法在其他文件中使用
extern vod funA(); // 使用file1.cpp中定义的函数
extern void funB(); // 错误! 无法使用file1.cpp文件中static函数

C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数. 这是与普通成员函数的最大区别, 也是其应用所在, 比如在对某一个类的对象进行计数时, 计数生成多少个类的实例, 就可以用到静态数据成员. 在这里面, static既不是限定作用域的, 也不是扩展生存期的作用, 而是指示变量/函数在此类中的唯一性. 这也是”属于一个类而不是属于此类的任何特定对象的变量和函数”的含义. 因为它是对整个类来说是唯一的, 因此不可能属于某一个实例对象的. (针对静态数据成员而言, 成员函数不管是否是static, 在内存中只有一个副本, 普通成员函数调用时, 需要传入this指针, static成员函数调用时, 没有this指针. )
请看示例程序四(

class EnemyTarget {
public:
  EnemyTarget() { ++numTargets; }
  EnemyTarget(const EnemyTarget&) { ++numTargets; }
  ~EnemyTarget() { --numTargets; }
  static size_t numberOfTargets() { return numTargets; }
  bool destroy();   // returns success of attempt to destroy EnemyTarget object
private:
  static size_t numTargets;               // object counter
};
// class statics must be defined outside the class;
// initialization is to 0 by default
size_t EnemyTarget::numTargets;

另外, 在设计类的多线程操作时, 由于POSIX库下的线程函数pthread_create()要求是全局的, 普通成员函数无法直接做为线程函数, 可以考虑用Static成员函数做线程函数.
正是因为static有以上的特性，所以一般定义static全局变量时，都把它放在原文件中而不是头文件，这样就不会给其他模块造成不必要的信息污染。

5，const

const修饰的全局常量据有跟static相同的特性(有条件的，感谢sswv的提醒，const放在只读静态存储区)，即它们只能作用于本编译模块中，但是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”.