C++中各种类型的成员变量的初始化方法(mark-好)

刚才编程遇到这样一个问题:

class CA

{

public:

//正确

       static const int rate = 6;

//错误,const double类型成员不能包含类内初始值设定项,int就可以

       static const double rate = 6.5;

 

};


遂找到此篇文章,转载阅读之:

http://blog.csdn.net/yockie/article/details/7868068



C++类中各种不同类型成员根据是否static 、是否const类型的初始化方法不尽相同,写代码时经常搞乱,网上搜了一下资料,全部总结一下。

一、例子

[cpp]  view plain
  1. -----------------Test.h----------------------------  
  2.   
  3. #pragma once  
  4.   
  5. class Test  
  6. {  
  7. private :  
  8.       int   var1;  
  9. //    int   var11= 4; 错误的初始化方法  
  10.       const int   var2 ;  
  11. //    const int   var22 =22222; 错误的初始化方法,const成员和引用成员必须在初始化列表中初始化(因为它们必须在定义时初始化)  
  12.       static int   var3;  
  13. //    static int   var3333=33333; 错误,只有静态常量成员才能直接赋值来初始化  
  14.       static const int   var4=4444;  //正确,静态常量整数成员(此三个条件缺一不可)可以直接初始化  
  15.       static const int   var44;  
  16. public:  
  17.       Test(void);  
  18.        ~Test(void);  
  19. };  

[cpp]  view plain
  1. ----------Test.cpp----------------  
  2.   
  3. #include ".\test.h"  
  4.   
  5. int Test::var3 = 3333333; //静态成员的 正确的初始化方法  
  6.   
  7. //    int Test::var1 = 11111;; 错误 静态成员才能这样初始化  
  8. //    int Test::var2 = 22222; 错误  
  9. //    int Test::var44 = 44444; // 错误的方法,提示重定义,因为此var44与类中声明的var44的修饰符不相同  
  10. const int Test::var44 = 44444; //正确  
  11.   
  12. Test::Test(void) :var1(11111),var2(22222)   //正确的初始化方法 , var3(33333) 不能在这里初始化  
  13. {  
  14.     var1 =11111; //正确, 普通变量也可以在这里初始化  
  15.     //var2 = 222222; 错误,因为const常量不能赋值,只能在 构造函数的初始化列表 那里初始化  
  16.             
  17.     var3 =33;   //经测试,(1)若已经正确定义了var3,即在类定义外部“int Test::var3;”或“int Test::var3=3333333;”,  
  18.                 //则此处赋值(注意是赋值,不是初始化)是正确的 ;  
  19.                 //(2)若按(1)所说的正确定义var3,则此处赋值是错误的,因为var3尚未定义。  
  20. }  
  21.   
  22. Test::~Test(void)  




二、简单概括
有些成员变量的数据类型比较特别,它们的初始化方式也和普通数据类型的成员变量有所不同。这些特殊的类型的成员变量包括:
    a. 常量型成员变量:如 const int temp;
    b. 引用型成员变量:如 int & temp;
    c. 静态成员变量:如 static int temp;
    d. 整型静态常量成员变量:如 static const int temp;
    e. 非整型静态常量成员变量:如 static const double temp;

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

和引用型成员变量赋值的方式是行不通的。
    静态成员变量的初始化也颇有点特别。

    参考下面的代码以及其中注释:

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

三、完整总结

1、普通的变量:一般不考虑啥效率的情况下 可以在构造函数中进行赋值。考虑一下效率的可以再构造函数的初始化列表中进行。

[cpp]  view plain
  1. class CA  
  2. {  
  3. public:  
  4.  int data;  
  5.  ……  
  6. public:  
  7.  CA();  
  8.  ……  
  9. };  
  10. CA::CA():data(0)//……#1……初始化列表方式  
  11. {  
  12.  //data = 0;//……#1……赋值方式  
  13. };  

 

2、static 静态变量:

static变量属于类所有,而不属于类的对象,因此不管类被实例化了多少个对象,该变量都只有一个。

[cpp]  view plain
  1. class CA  
  2. {  
  3. public:  
  4.  static int sum;  
  5.  ……  
  6. public:  
  7.  CA();  
  8.  ……  
  9. };  
  10. int CA::sum=0;//……#……类外进行定义和初始化  


3、const 常量变量:
const常量需要在声明的时候即初始化。因此需要在变量创建的时候进行初始化。一般采用在构造函数的初始化列表中进行。

[cpp]  view plain
  1. class CA  
  2. {  
  3. public:  
  4.  const int max;  
  5.  ……  
  6. public:  
  7.  CA();  
  8.  ……  
  9. };  
  10. CA::CA():max(100)  
  11. {  
  12.  ……  
  13. }  


4、Reference 引用型变量:
引用型变量和const变量类似。需要在创建的时候即进行初始化。也是在初始化列表中进行。但需要注意用Reference类型。

[cpp]  view plain
  1. class CA  
  2. {  
  3. public:  
  4.  int& counter;   
  5.  ……  
  6. public:  
  7.  CA(int i);  
  8.  ……  
  9. };  
  10. CA::CA(int i):counter(i)  
  11. {  
  12.  ……  
  13. }  


5、const static integral 变量:
对于既是const又是static 而且还是整形变量,C++是给予特权的。可以直接在类的定义中初始化。short可以,但float的不可以哦。

[cpp]  view plain
  1. class CA  
  2. {  
  3. public:  
  4.  //static const float fmin = 0.0;   
  5.  // only static const integral data members can be initialized within a class  
  6.  const static int nmin = 0;  
  7.  ……  
  8. public:  
  9.  ……  
  10. };  


总结起来,可以初始化的情况有如下四个地方:
1、在类的定义中进行的,只有const 且 static 且 integral 的变量。
2、在类的构造函数初始化列表中, 包括const对象和Reference对象。
3、在类的定义之外初始化的,包括static变量。因为它是属于类的唯一变量。
4、普通的变量可以在构造函数的内部,通过赋值方式进行。当然这样效率不高。



评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值