C++ static、const和static const类型成员变量声明以及初始化

下面的文章是我从网上找了好久，整理了好久的，对我有很大帮助，原址已经记不住了，算我自己原创的了哇！

C++ static、const和static const 以及它们的初始化

const定义的常量在超出其作用域之后其空间会被释放，而static定义的静态常量在函数执行后不会释放其存储空间。

static表示的是静态的。类的静态成员函数、静态成员变量是和类相关的，而不是和类的具体对象相关的。即使没有具体对象，也能调用类的静态成员函数和成员变量。一般类的静态函数几乎就是一个全局函数，只不过它的作用域限于包含它的文件中。

在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，如：double Account::Rate = 2.25;static关键字只能用于类定义体内部的声明中，定义时不能标示为static

在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。

const数据成员 只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的对象没被创建时，编译器不知道const数据成员的值是什么。

const数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。

[cpp]  view plain copy

1. class Test{  
2. public:  
3.     Test():a(0){}  
4.     enum {size1=100,size2=200};  
5. private:  
6.     const int a;//只能在构造函数初始化列表中初始化  
7.     static int b;//在类的实现文件中定义并初始化  
8.     conststatic int c;//与 static const int c;相同。  
9. };  
10.    
11. int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。  
12. cosnt intTest::c=0;//注意：给静态成员变量赋值时，不需要加static修饰符，但要加cosnt。  

[cpp]  view plain copy

1. <span style="background-color:white">  
2. </span>  

cosnt成员函数主要目的是防止成员函数修改对象的内容。即const成员函数不能修改成员变量的值，但可以访问成员变量。当方法成员函数时，该函数只能是const成员函数。

static成员函数主要目的是作为类作用域的全局函数。不能访问类的非静态数据成员。类的静态成员函数没有this指针，这导致：1、不能直接存取类的非静态成员变量，调用非静态成员函数2、不能被声明为virtual

 

关于static、const、static cosnt、const static成员的初始化问题：

1、类里的const成员初始化：

在一个类里建立一个const时，不能给他初值

[cpp]  view plain copy

1. class foo{  
2. public:  
3.     foo():i(100){}  
4. private:  
5.     const int i=100;//error!!!  
6. };  
7. //或者通过这样的方式来进行初始化  
8. foo::foo():i(100){}  

 

2、类里的static成员初始化：

类中的static变量是属于类的，不属于某个对象，它在整个程序的运行过程中只有一个副本，因此不能在定义对象时 对变量进行初始化，就是不能用构造函数进行初始化，其正确的初始化方法是：

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

[cpp]  view plain copy

1. class foo{  
2. public:  
3.     foo();  
4. private:  
5. staticint i;  
6. };  
7.   
8. intfoo::i=20;  

.这表明：

1、初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆

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

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

 

3、类里的static cosnt 和 const static成员初始化

这两种写法的作用一样，为了便于记忆，在此值说明一种通用的初始化方法：

[cpp]  view plain copy

1. class Test{  
2. public:  
3.     static const int mask1;  
4.     conststatic int mask2;  
5. };  
6. constTest::mask1=0xffff;  
7. constTest::mask2=0xffff;  
8. //它们的初始化没有区别，虽然一个是静态常量一个是常量静态。静态都将存储在全局变量区域，其实最后结果都一样。可能在不同编译器内，不同处理，但最后结果都一样。  

这是一个完整的例子：

[cpp]  view plain copy

1. #ifdef A_H_  
2. #define A_H_  
3. #include <iostream>  
4. usingnamespace std;  
5. class A{  
6. public:  
7.     A(int a);  
8.     staticvoid print();//静态成员函数  
9. private:  
10.     static int aa;//静态数据成员的声明  
11.     staticconst int count;//常量静态数据成员（可以在构造函数中初始化）  
12.     const int bb;//常量数据成员  
13. };  
14.   
15. int A::aa=0;//静态成员的定义+初始化  
16. const int A::count=25;//静态常量成员定义+初始化  
17.   
18. A::A(int a):bb(a){//常量成员的初始化  
19. aa+=1;  
20. }  
21.   
22. void A::print(){  
23. cout<<"count="<<count<<endl;  
24. cout<<"aa="<<aa<<endl;  
25. }  
26.   
27. #endif  
28.   
29. void main(){  
30.     A a(10);  
31.     A::print();//通过类访问静态成员函数  
32.     a.print();//通过对象访问静态成员函数  
33. }  

 

初始化位置

静态成员不能在类的定义里初始化（除int外）。不能在头文件里初始化。
比如定义了 myclass.h，一般放到myclass.cpp里初始化它。

 

C++ 类的静态成员(static)

静态成员的提出是为了解决数据共享的问题。实现共享有许多方法，如：设置全局性的变量或对象是一种方法。但是，全局变量或对象是有局限性的。这一章里，我们主要讲述类的静态成员来实现数据的共享。

静态数据成员

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

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

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

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

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

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

　　这表明：

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

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

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

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

　　4、引用静态数据成员时，采用如下格式：

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

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

　　下面举一例子，说明静态数据成员的应用：

[cpp]  view plain copy

1. #include …  
2. class Myclass{  
3. public:  
4.     Myclass(int a, int b, int c);  
5.     void GetNumber();  
6.     void GetSum();  
7. private:  
8.     int A, B, C;  
9.     static int Sum;  
10. };  
11.   
12. int Myclass::Sum = 0;  
13.   
14. Myclass::Myclass(int a, int b, int c){  
15.     A = a;  
16.     B = b;  
17.     C = c;  
18.     Sum += A+B+C;  
19. }  
20.   
21. void Myclass::GetNumber(){  
22.     cout<<"Number="<<a<<","<<b<<","<<c<<endl;  
23.  }  
24.   
25. void Myclass::GetSum(){  
26.     cout<<"Sum="<<sum<<endl;  
27.  }  
28.   
29. void main(){  
30.     Myclass M(3, 7, 10),N(14, 9, 11);  
31.     M.GetNumber();  
32.     N.GetNumber();  
33.     M.GetSum();  
34.     N.GetSum();  
35. }  

　　从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时，将M对象的三个int型数据成员的值求和后赋给了Sum，于是Sum保存了该值。在初始化N对象时，对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上，于是Sum将保存另后的值。所以，不论是通过对象M还是通过对象N来引用的值都是一样的，即为54。

静态成员函数

静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。

　　在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时，可通过对象来引用。下面通过例子来说明这一点。

[cpp]  view plain copy

1. #include …  
2. class M{  
3. public:  
4.     M(int a){  
5.         A=a;  
6.         B+=a;  
7.     }  
8.       
9.     static void f1(M m);  
10. private:  
11.     int A;  
12.     static int B;  
13. };  
14.   
15. void M::f1(M m)  
16. {  
17.     cout<<"A="<<m.a<<endl;  
18.     cout<<"B="<<b<<endl;  
19. }  
20.   
21. int M::B=0;  
22.   
23. void main()  
24. {  
25.     M P(5),Q(10);  
26.     M::f1(P); //调用时不用对象名  
27.     M::f1(Q);  
28. }  

　　读者可以自行分析其结果。从中可看出，调用静态成员函数使用如下格式：

　　<类名>::<静态成员函数名>(<参数表>);

 

C++中各种类型的成员变量的初始化方法

c++各种不同类型成员根据是否static、时候const类型的初始化方法不尽相同，java的语法就没有这么复杂，怪的得那么多人都跑去学Java了。以前面试时被人问到这个问题回答不出来，写代码时也经常搞乱了，这里翻了下书，总结一下。

[cpp]  view plain copy

1. -----------------Test.h----------------------------  
2. #pragma once  
3. class Test  
4. {  
5. private :  
6.     int var1;  
7.     // int var11= 4; 错误的初始化方法  
8.     const int var2 ;  
9.     // const int var22 =22222; 错误的初始化方法  
10.     static int var3;  
11.     // static int var3333=33333; 错误，只有静态常量int成员才能直接赋值来初始化  
12.     static const int var4=4444; //正确，静态常量成员可以直接初始化    
13.     static const int var44;  
14. public:  
15.     Test(void);  
16.     ~Test(void);  
17. };  
18. --------------------Test.cpp-----------------------------------  
19. #include ".\test.h"  
20.   
21. int Test::var3 = 3333333; //静态成员的正确的初始化方法  
22.   
23. // int Test::var1 = 11111;; 错误静态成员才能初始化  
24. // int Test::var2 = 22222; 错误  
25. // int Test::var44 = 44444; // 错误的方法，提示重定义  
26. Test::Test(void)：var1(11111),var2(22222)正确的初始化方法//var3(33333)不能在这里初始化  
27. {  
28.     var1 =11111; //正确, 普通变量也可以在这里初始化  
29.     //var2 = 222222; 错误，因为常量不能赋值，只能在 “constructor initializer （构造函数的初始化列表）” 那里初始化  
30.             
31.     var3 =44444; //这个赋值是正确的，不过因为所有对象一个静态成员，所以会影响到其他的，这不能叫做初始化了吧  
32. }  
33. Test::~Test(void){}  
34. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  

有些成员变量的数据类型比较特别，它们的初始化方式也和普通数据类型的成员变量有所不同。这些特殊的类型的成员变量包括：

    a. 常量型成员变量
    b. 引用型成员变量
    c. 静态成员变量
    d. 整型静态常量成员变量
    e. 非整型静态常量成员变量

  对于常量型成员变量和引用型成员变量的初始化，必须通过构造函数初始化列表的方式进行。在构造函数体内给常量型成员变量和引用型成员变量赋值的方式是行不通的。

    静态成员变量的初始化也颇有点特别。
   参考下面的代码以及其中注释：

[cpp]  view plain copy

1. // Initialization of Special Data Member  
2. #include <iostream>  
3. using namespace std;       
4.   
5. class BClass  
6. {  
7. public:  
8.     BClass() : i(1),ci(2), ri(i) // 对于常量型成员变量和引用型成员变量，必须通过    
9.     {               // 参数化列表的方式进行初始化。在构造函数体内进行赋值的方式，是行不通的。  
10.     }   
11.   
12.     voidprint_values()  
13.     {  
14.         cout<< "i =\t" << i << endl;  
15.         cout<< "ci =\t" << ci << endl;  
16.         cout<< "ri =\t" << ri << endl;  
17.         cout<< "si =\t" << si << endl;  
18.         cout<< "csi =\t" << csi << endl;  
19.         cout<< "csi2 =\t" << csi2 << endl;  
20.         cout<< "csd =\t" << csd << endl;  
21.     }  
22.   
23. private:  
24.     inti; // 普通成员变量  
25.     constint ci; // 常量成员变量  
26.     int&ri; // 引用成员变量  
27.     staticint si; // 静态成员变量  
28.     //staticint si2 = 100; // error: 只有静态常量成员变量，才可以这样初始化  
29.     staticconst int csi; // 静态常量成员变量  
30.     staticconst int csi2 = 100; // 静态常量成员变量的初始化(Integral type) (1)  
31.     staticconst double csd; // 静态常量成员变量(non-Integral type)  
32.     //staticconst double csd2 = 99.9; // error: 只有静态常量整型数据成员才可以在类中初始化  
33. };  
34. // 静态成员变量的初始化(Integral type)  
35. int BClass::si = 0;  
36. // 静态常量成员变量的初始化(Integral type)  
37. const int BClass::csi = 1;  
38. // 静态常量成员变量的初始化(non-Integral type)  
39. const double BClass::csd = 99.9;  
40.   
41. // 在初始化(1)中的csi2时，根据Stanley B. Lippman的说法下面这行是必须的。  
42. // 但在VC2003中如果有下面一行将会产生错误，而在VC2005中，下面这行则可有可无，这个和编译器有关。  
43. const int BClass::csi2;  
44.   
45. int main(void)  
46. {  
47.     BClassb_class;  
48.     b_class.print_values();   
49.     return0;  
50. }  

 

c++静态成员小结,c++,static

类中的静态成员真是个让人爱恨交加的特性。我曾经在面试时，被主考官抓住这个问题一阵穷追猛打，直把我问的面红耳赤，败下阵来。所以回来之后，我痛定思痛，决定好好总结一下静态类成员的知识点，以便自己在以后面试中，在此类问题上不在被动。 
静态类成员包括静态数据成员和静态函数成员两部分。 

静态数据成员

类体中的数据成员的声明前加上static关键字，该数据成员就成为了该类的静态数据成员。和其他数据成员一样，静态数据成员也遵守public/protected/private访问规则。同时，静态数据成员还具有以下特点： 

1.静态数据成员的定义。 
静态数据成员实际上是类域中的全局变量。所以，静态数据成员的定义(初始化)不应该被放在头文件中。 （声明vs.定义（初始化））
其定义方式与全局变量相同。举例如下： 

[cpp]  view plain copy

1. xxx.h文件   
2. class base{   
3. private:   
4.     static const int _i;//声明，标准c++支持有序类型在类体中初始化,但vc6不支持。   
5. };   
6.   
7. xxx.cpp文件   
8. const int base::_i=10;//定义(初始化)时不受private和protected访问限制.   

注：不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。 即使加上 #ifndef #define #endif 或者 #pragma once 也不行。  

2. 静态数据成员被类的所有对象所共享，包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。 举例如下：  

[cpp]  view plain copy

1. <pre name="code" class="cpp">class base{   
2. public :   
3.     static int _num;//声明   
4. };   
5. int base::_num=0;//静态数据成员的真正定义   
6.   
7. class derived:public base{ };   
8.   
9. main()   
10. {   
11.     base a;   
12.     derived b;   
13.     a._num++;   
14.     cout<<"base class static data number_num is"<<a._num<<endl;   
15.     b._num++;   
16.     cout<<"derived class static datanumber _num is"<<b._num<<endl;   
17. }   
18. // 结果为1,2;可见派生类与基类共用一个静态数据成员。 </pre><br><br>  

3. 静态数据成员可以成为成员函数的 可选参数，而普通数据成员则不可以。举例如下：  

[cpp]  view plain copy

1. class base{   
2. public :   
3.     static int _staticVar;   
4.     int _var;   
5.     void foo1(int i=_staticVar);//正确,_staticVar为静态数据成员   
6.     void foo2(int i=_var);//错误,_var为普通数据成员   
7. };   

4. ★ 静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为所属类类型的指针或引用。 举例如下：  

[cpp]  view plain copy

1. class base{   
2. public :   
3.     static base_object1;//正确，静态数据成员   
4.     base _object2;//错误   
5.     base *pObject;//正确，指针   
6.     base &mObject;//正确，引用   
7. };   

5. ★ 这个特性，我不知道是属于标准 c++ 中的特性，还是 vc6 自己的特性。  
静态数据成员的值在const成员函数中可以被合法的改变 。举例如下：  

[cpp]  view plain copy

1. class base{   
2. public:   
3.     base(){  
4.         _i=0;  
5.         _val=0;  
6.     }   
7.   
8.     mutable int _i;   
9.     static int _staticVal;   
10.     int _val;   
11.     void test() const{//const 成员函数   
12.         _i++;//正确，mutable数据成员   
13.         _staticVal++;//正确，static数据成员   
14.         _val++;//错误   
15.     }   
16. };   
17. int base::_staticVal=0;   

 

静态成员函数 

静态成员函数没有什么太多好讲的。 

1.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用类成员函数指针来储存。举例如下： 

[cpp]  view plain copy

1. class base{   
2.     static int func1();   
3.     int func2();   
4. };   
5.   
6. int (*pf1)()=&base::func1;//普通的函数指针   
7. int (base::*pf2)()=&base::func2;//成员函数指针   

2. 静态成员函数不可以调用类的非静态成员 。因为静态成员函数不含 this指针 。  

3. 静态成员函数不可以同时声明为 virtual、const、volatile函数 。举例如下：  

[cpp]  view plain copy

1. class base{   
2.     virtual static void func1();//错误   
3.     static void func2() const;//错误   
4.     static void func3() volatile;//错误   
5. };   

最后要说的一点是，静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。