C++类中成员变量初始化

迷南。 2022-08-27 03:53 290阅读 0赞

C++类中成员变量包括主要四种：  
普通成员变量，常量成员变量，静态成员变量，静态常量成员变量  
  
上述成员变量该如何初始化，注意不是赋值。  
由于 普通成员变量和常量成员变量 ，每一个类实例化，都一份内存拷贝。 C++规定成员变量在声明（注意声明与定义区别）时，不允许初始化，因此这些变量只能放在构造函数初始化列表中。  
静态成员变量所有类实例化，只有一份内存拷贝，不能放在构造函数中初始化， 因为共享一份内存。 同时C++规定成员变量在声明（注意声明与定义区别）时，不允许初始化。所以只能定义时初始化。

静态常量成员变量比较特殊化，即不能放在构造函数初始化列表中，也不能定义时初始化，那么只能在声明（注意声明与定义区别）时，初始化。

声明与定义简单区别，声明不分配内存，定义分配内存。类没有产生对象，那么成员变量没有分配内存的，所有其成员变量为声明。注意与C语言区别，C语言变量有时即是定义有时声明， 例如int a;

另外常量成员函数，不能改变成员变量，例如赋值操作，但是可以改变局部变量。  
  
using namespace std;  
\#include<iostream>  
class Test\{   
private:  
        int i;//声明普通成员  
        const int j;//声明常量成员  
public:  
        static int k;//声明静态成员  
        static  const int m = 1; //声明静态&&常量初始化  
        Test(int val):i(val),j(val) //普通成员，常量成员初始化  
        \{   
        \}  
        int getval() const  
        \{   
                //i=5555;  
                return j;  
        \}  
  
\};  
  
int Test:: k=2; //定义静态成员初始化  
int main()  
\{   
        int c;  
        Test test(3);  
        cout<<"const:"<<test.getval();  
        cout<<"static:"<<Test::k;

cout<<"const&static"<<Test::m;

const成员、引用成员初始化必须在构造函数的初始化列表中进行

实例如下：

TEST\_1.h

# ifndef _TEST_H_ 
       # define _TEST_H_ 
        
       class Object 
       { 
        
       public: 
           enum E_TYPE 
            { //对所有对象来说都是常量 
                 TYPE_A = 100,   
                 TYPE_B = 200 
            };  
       public: 
           Object(int num);         
           ~Object(); 
        
           void DisplayKNum(); 
            
       private: 
           int num_; 
           const int kNum_;//仅限于某个对象是常量 
           int& refNum_; 
       }; 
       # endif //_TEST_H_

TEST\_1.cpp

# include "Test_1.h" 
       # include <iostream> 
       using namespace std; 
        
       Object::Object(int num = 0) : num_(num),kNum_(num_),refNum_(num_) 
       {  //本质上是赋值 
                //Knum = 100; error const的初始化必须在初始化列表中初始化 
                //refNum_ = num_; error 引用成员的初始化必须在初始化列表中初始化 
                  cout << "Object "<<num_ << "..." << endl; 
       } 
        
        
        
       void Object::DisplayKNum() 
       { 
               //cout << "kNum = " << kNum_ << endl; 
               cout << "kNum = " << kNum_ << endl; 
       } 
        
       Object::~Object() 
       { 
               cout << "~Object "<<num_<<"..." << endl; 
       }

main.cpp

#include "Test_1.h" 
       # include <iostream> 
       using namespace std; 
        
        
       int main(void) 
       { 
           Object obj1(10); 
           Object obj2(20); 
        
           obj1.DisplayKNum(); 
           obj2.DisplayKNum(); 
            
       //针对类内部是常量，而对于所有对象都是常量要用枚举   
           cout <<obj1.TYPE_A<<endl; 
           cout <<obj2.TYPE_A<<endl<<endl; 
       //适用于任何对象，要用枚举常量 
           cout <<Object::TYPE_A<<endl; 
           cout <<Object::TYPE_B<<endl; 
            
           return 0; 
       }

运行结果：

![Image 1][]

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

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

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

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

示例：

**\[cpp\]**  [view plain][] [copy][view plain]

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. \}

### 特殊数据类型成员变量的初始化   ###

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

a.       常量型成员变量

b.       引用型成员变量

c.        静态成员变量

d.       整型静态常量成员变量

e.       非整型静态常量成员变量

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

静态成员变量的初始化也颇有点特别。

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

// Initialization of Special Data Member

\#include <iostream>