C++中的static关键字

C++中的static关键字继承自C语言，包含两方面含义：静态存储和可见性控制。定义成静态类型的变量会被保存在全局数据区，定义成静态类型的变量或 者函数只能在本编译单元内被访问到，这样在不同文件中定义同名的变量就不会发生重复定义错误了。C++中static的应用分为两个方面：一是用于普通的 函数和变量，二是在类中的应用。

    一、在普通函数和变量中的应用
    1、静态全局变量
    在全局变量前面加上static，该变量就成了一个静态全局变量。静态全局变量有如下特点：
    1）、变量存储在全局数据区；
    2）、变量会被自动初始化为0；
    3）、静态全局变量在整个编译单元（整个文件）内都是可见的，而在文件之外是不可见的。
    静态变量自动初始化为0的特性可以给程序开发带来某些便利，比如定义一个字符串数组为了保证字符结尾为'/0'需要遍历整个数组进行初始化，但是定义成静 态的字符串数组会被自动填充为0，'/0'就是0，所以说利用这些特性可以增加程序的运行效率。对于当前编译单元内需要共享的全局变量可以设置为静态的， 这样既不用担心在其他文件中有重名的问题又能满足要求。
    如下代码展示了静态全局变量的特性：

view plain copy to clipboard print ?

1. // file1.cpp   
2. #include <iostream>   
3. using   namespace  std;  
4. static   int  n = 1;  
5. void  fun2();  
6. void  fun1() {  
7.     cout << n << endl;  
8. }  
9. int  main() {  
10.     fun1();  
11.     fun2();  
12.     return  1;  
13. }  

// file1.cpp #include <iostream> using namespace std; static int n = 1; void fun2(); void fun1() { cout << n << endl; } int main() { fun1(); fun2(); return 1; }

view plain copy to clipboard print ?

1. // file2.cpp   
2. #include <iostream>   
3. using   namespace  std;  
4. extern   int  n;  
5. void  fun2() {  
6.     cout << n << endl;  
7. }  

// file2.cpp #include <iostream> using namespace std; extern int n; void fun2() { cout << n << endl; }

    分别编译两个文件，然后连接，出现错误，说找不到n，这就说明n只在file1.cpp中有效file2.cpp。现在将file2中的extern int n改为int n = 2，重新编译运行，将输出：1 2，这说明file1和file2分别用了自己文件中定义的n，这就是可见性控制。

    2、静态局部变量
    在函数体内定义一个局部变量，变量被存储在堆栈中，函数返回后堆栈被恢复变量就被释放了。但是静态局部变量和静态全局变量相同，都是保存在全局数据区，在 没有被显式初始化的情况下也会被初始化为0，函数返回后仍然有效，函数重入后数据依然是上次的结果，这和全局变量有相同的效果，但是全局变量不只是属于函 数本身，其他代码也能看到很容易破坏变量的内容，所以静态局部变量在某些需要保存函数运行状态的时候很有用。
    例如：

view plain copy to clipboard print ?

1. // file3.cpp   
2. #include <iostream>   
3. using   namespace  std;  
4. void  fun() {  
5.     static   int  n = 1;  
6.     cout << n << endl;  
7.     n++;  
8. }  
9. int  main() {  
10.     fun();  
11.     fun();  
12.     fun();  
13.     return  1;  
14. }  

// file3.cpp #include <iostream> using namespace std; void fun() { static int n = 1; cout << n << endl; n++; } int main() { fun(); fun(); fun(); return 1; }

    编译运行，结果将输出1 2 3，这说明函数每次调用n的值都被保存了下来。

    3、静态函数
    在函数定义前加上static就将函数定义为静态了，静态函数的可见性与静态全局变量相同，只在当前文件中有效，不能被其他文件看到。除了这些特点静态函数和其它函数没有什么区别，这一点也就是体现出了static关键字在控制可见性方面的用处。

view plain copy to clipboard print ?

1. // file4.cpp   
2. #include <iostream>   
3. using   namespace  std;  
4. static   void  fun() {  
5.     cout << "fun"  << endl;  
6. }  

// file4.cpp #include <iostream> using namespace std; static void fun() { cout << "fun" << endl; }

view plain copy to clipboard print ?

1. // file5.cpp   
2. void  fun();  
3. int  main() {  
4.     fun();  
5. }  

// file5.cpp void fun(); int main() { fun(); }

    单独编译这两个文件，连接成一个程序会出现错误：找不到fun()函数，将file4中fun函数定义中的static去掉就OK了。

    二、在类中的应用
    1、类中的静态成员变量
    在类的成员变量声明前加上static，该变量就成为了类的静态成员变量，例如：

view plain copy to clipboard print ?

1. // file6.cpp   
2. #include <iostream>   
3. using   namespace  std;  
4. class  A {  
5.     int  size;  
6. public :  
7.     static   int  n;  
8. };  
9. int  A::n = 1;  
10. int  main() {  
11.     A a, b;  
12.     A::n++;  
13.     cout << "A::n = "  << A::n << endl;  
14.     cout << "a.n = "  << a.n <<endl;  
15.     a.n++;  
16.     cout << "b.n = "  << b.n << endl;  
17.     cout << "sizeof(A) = "  <<  sizeof (A) << endl;  
18.     cout << "sizeof(a) = "  <<  sizeof (a) << endl;  
19.     return  1;  
20. }  

// file6.cpp #include <iostream> using namespace std; class A { int size; public: static int n; }; int A::n = 1; int main() { A a, b; A::n++; cout << "A::n = " << A::n << endl; cout << "a.n = " << a.n <<endl; a.n++; cout << "b.n = " << b.n << endl; cout << "sizeof(A) = " << sizeof(A) << endl; cout << "sizeof(a) = " << sizeof(a) << endl; return 1; }

    编译运行，产生如下输出：
    A::n = 2
    a.n = 2
    b.n = 3
    sizeof(A) = 4
    sizeof(a) = 4
    可以看出类的静态成员变量是属于类本身的，而不是属于某个对象的，所有对象看到的n值都相同，然后看类A和对象a的尺寸，只有int的大小4，这说明静态 成员变量和对象本身并不在同一个存储区域，实际上类的静态存成员变量和其他静态变量一样也是存储在全局数据区的，这个问题我在去麦石应聘笔试的时候曾经遇 到过，再关注一下。
    对静态成员变量的初始化可以采用如下形式：
        <类型名> <类名>::<静态成员变量名> = <值>
    对于静态成员变量的引用可以通过如下形式：
        <类名>::<静态成员变量名> = <值>
        <对象名>.<静态成员变量名>
    类的静态成员变量的意义在于某些类可能存在所有对象公共的属性，这个时候就可以使用静态成员变量，不仅可以节省存储空间，而且当公共属性改变后所有对象都 能看到，不需要再通知所有的对象。而且类的静态成员变量和普通成员变量一样都可以设置访问权限控制，比如设置成private，则该变量只能在类内部被调 用。

    2、类的静态成员函数
    类的静态成员函数与静态成员变量一样，属于类而不属于对象。一般类的成员函数都有一个隐含的this指针当做参数，这样函数就可以访问对象的成员变量，但 是静态成员函数没有这个参数，所以静态成员函数不能访问对象的成员变量，而只能访问其他静态成员。下面是使用静态成员函数的例子：

view plain copy to clipboard print ?

1. // file7.cpp   
2. #include <iostream>   
3. using   namespace  std;  
4. class  A {  
5.     int  n;  
6.     static   int  m;  
7. public :  
8.     void  fun1() {  
9.         // 一般函数可以调用静态和非静态成员，无特殊限制   
10.         cout << n + m << endl;  
11.         fun2();  
12.     }  
13.     static   void  fun2() {  
14.         cout << m << endl;  
15.           
16.         // 错误：静态成员函数不能调用非静态成员   
17.         //cout << n << endl;   
18.         //fun1();   
19.     }  
20. };  
21. int  main() {  
22.     A a;  
23.     A::fun2();  
24.     a.fun1();  
25.     a.fun2();  
26. }  

// file7.cpp #include <iostream> using namespace std; class A { int n; static int m; public: void fun1() { // 一般函数可以调用静态和非静态成员，无特殊限制 cout << n + m << endl; fun2(); } static void fun2() { cout << m << endl; // 错误：静态成员函数不能调用非静态成员 //cout << n << endl; //fun1(); } }; int main() { A a; A::fun2(); a.fun1(); a.fun2(); }

    可以看出静态成员函数和静态成员变量的调用方式是相同的。

    三、总结
    C++语言当中有很多细节问题，熟练地在代码中应用这些可以大大的提高我们程序的健壮性和灵活性。最近在应聘工作，这些问题很容易被作为考题，在这里系统的总结一下。