C++静态变量使用方法

在C++中，静态成员是属于整个类的而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则，保证了安全性还可以节省内存。

静态成员的定义或声明要加个关键static。静态成员可以是Public，Private，Protected；Public的静态成员可以通过双冒号来使用即<类名>::<静态成员名>。

 

在C++中类的静态成员变量和静态成员函数是个容易出错的地方，本文先通过几个例子来总结静态成员变量和成员函数使用规则，再给出一个实例来加深印象。希望阅读本文可以使读者对类的静态成员变量和成员函数有更为深刻的认识。

 

第一个例子，通过类名调用静态成员函数和非静态成员函数

[cpp]  view plain copy

1. class Point  
2. {  
3. public:   
4.     void init()  
5.     {    
6.     }  
7.     static void output()  
8.     {  
9.     }  
10. };  
11. void main()  
12. {  
13.     Point::init();  
14.     Point::output();  
15. }  

编译出错：error C2352: 'Point::init' : illegal call of non-static member function

结论1：不能通过类名来调用类的非静态成员函数。

 

第二个例子，通过类的对象调用静态成员函数和非静态成员函数

将上例的main()改为：

[cpp]  view plain copy

1. void main()  
2. {  
3.     Point pt;  
4.     pt.init();  
5.     pt.output();  
6. }  

编译通过。

结论2：类的对象可以使用静态成员函数和非静态成员函数。

 

第三个例子，在类的静态成员函数中使用类的非静态成员

[cpp]  view plain copy

1. #include <stdio.h>  
2. class Point  
3. {  
4. public:   
5.     void init()  
6.     {    
7.     }  
8.     static void output()  
9.     {  
10.         printf("%d\n", m_x);  
11.     }  
12. private:  
13.     int m_x;  
14. };  
15. void main()  
16. {  
17.     Point pt;  
18.     pt.output();  
19. }  

编译出错：error C2597: illegal reference to data member 'Point::m_x' in a static member function

因为静态成员函数属于整个类，在类实例化对象之前就已经分配空间了，而类的非静态成员必须在类实例化对象后才有内存空间，所以这个调用就出错了，就好比没有声明一个变量却提前使用它一样。

结论3：静态成员函数中不能引用非静态成员。

 

第四个例子，在类的非静态成员函数中使用类的静态成员

[cpp]  view plain copy

1. class Point  
2. {  
3. public:   
4.     void init()  
5.     {    
6.         output();  
7.     }  
8.     static void output()  
9.     {  
10.     }  
11. };  
12. void main()  
13. {  
14.     Point pt;  
15.     pt.output();  
16. }  

编译通过。

结论4：类的非静态成员函数可以调用用静态成员函数，但反之不能。

 

第五个例子，使用类的静态成员变量

[cpp]  view plain copy

1. #include <stdio.h>  
2. class Point  
3. {  
4. public:   
5.     Point()  
6.     {    
7.         m_nPointCount++;  
8.     }  
9.     ~Point()  
10.     {  
11.         m_nPointCount--;  
12.     }  
13.     static void output()  
14.     {  
15.         printf("%d\n", m_nPointCount);  
16.     }  
17. private:  
18.     static int m_nPointCount;  
19. };  
20. void main()  
21. {  
22.     Point pt;  
23.     pt.output();  
24. }  

按Ctrl+F7编译无错误，按F7生成EXE程序时报链接错误

error LNK2001: unresolved external symbol "private: static int Point::m_nPointCount" (?m_nPointCount@Point@@0HA)

这是因为类的静态成员变量在使用前必须先初始化。

在main()函数前加上int Point::m_nPointCount = 0;

再编译链接无错误，运行程序将输出1。

结论5：类的静态成员变量必须先初始化再使用。

 

结合上面的五个例子，对类的静态成员变量和成员函数作个总结：

一。静态成员函数中不能调用非静态成员。

二。非静态成员函数中可以调用静态成员。因为静态成员属于类本身，在类的对象产生之前就已经存在了，所以在非静态成员函数中是可以调用静态成员的。

三。静态成员变量使用前必须先初始化(如int MyClass::m_nNumber = 0;)，否则会在linker时出错。

 

再给一个利用类的静态成员变量和函数的例子以加深理解，这个例子建立一个学生类，每个学生类的对象将组成一个双向链表，用一个静态成员变量记录这个双向链表的表头，一个静态成员函数输出这个双向链表。

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. const int MAX_NAME_SIZE = 30;    
4.   
5. class Student    
6. {    
7. public:    
8.     Student(char *pszName);  
9.     ~Student();  
10. public:  
11.     static void PrintfAllStudents();  
12. private:    
13.     char    m_name[MAX_NAME_SIZE];    
14.     Student *next;  
15.     Student *prev;  
16.     static Student *m_head;  
17. };    
18.   
19. Student::Student(char *pszName)  
20. {    
21.     strcpy(this->m_name, pszName);  
22.   
23.     //建立双向链表，新数据从链表头部插入。  
24.     this->next = m_head;  
25.     this->prev = NULL;  
26.     if (m_head != NULL)  
27.         m_head->prev = this;  
28.     m_head = this;    
29. }    
30.   
31. Student::~Student ()//析构过程就是节点的脱离过程    
32. {    
33.     if (this == m_head) //该节点就是头节点。  
34.     {  
35.         m_head = this->next;  
36.     }  
37.     else  
38.     {  
39.         this->prev->next = this->next;  
40.         this->next->prev = this->prev;  
41.     }  
42. }    
43.   
44. void Student::PrintfAllStudents()  
45. {  
46.     for (Student *p = m_head; p != NULL; p = p->next)  
47.         printf("%s\n", p->m_name);  
48. }  
49.   
50. Student* Student::m_head = NULL;    
51.   
52. void main()    
53. {     
54.     Student studentA("AAA");  
55.     Student studentB("BBB");  
56.     Student studentC("CCC");  
57.     Student studentD("DDD");  
58.     Student student("MoreWindows");  
59.     Student::PrintfAllStudents();  
60. }  

程序将输出：

在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。

　　使用静态数据成员可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

　　静态数据成员的使用方法和注意事项如下：

　　1、静态数据成员在定义或说明时前面加关键字static。

　　2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下：

　　　　<数据类型><类名>::<静态数据成员名>=<值>

        在初始化时与具体的访问权限无关，因为必须要初始化且总能初始化。

　　这表明：

      (1) 初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆。除非是const static 可以在类内初始化。

　　(2) 初始化时不加该成员的访问权限控制符private，public等。

　　(3) 初始化时使用作用域运算符来标明它所属类，因此，静态数据成员是类的成员，而不是对象的成员。

　　3、静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。

　　4、引用静态数据成员时(即public的成员)，采用如下格式：

　　　<类名>::<静态成员名>

　　如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。

有关const成员、static成员、const static成员的初始化：

 

1、const成员：只能在构造函数后的初始化列表中初始化

2、static成员：初始化在类外，且不加static修饰

3、const static成员：类只有唯一一份拷贝，且数值不能改变。因此，可以在类中声明处初始化，也可以像static在类外初始化

 

示例：

[cpp]  view plain copy

1. #include <iostream>  
2. using std::cout;  
3. using std::endl;  
4. class base  
5. {  
6. public:  
7.     base(int x=8):a(x){};//const成员在构造函数初始化  
8.     const int a;  
9.     static int b;  
10.     const static int c=9;//const static成员在类内初始化  
11. };  
12. int base::b=9;//static成员在类外初始化，可以修改  
13. //const int base::c=10;//也可以像static在类外初始化  
14. int main()  
15. {  
16.     base obj;  
17.     cout<<obj.a<<endl;  
18.     cout<<base::b<<endl;  
19.     cout<<base::c<<endl;  
20. }  

 

注：类的静态成员本质上是类的成员，但是由于他属于类，在静态存储区，所以有自己的一些特性。在理解的时候要抓住双重特性，是类的成员，同时是静态的。