共有5种方法。

第1种,在无参数的构造函数中初始化;

第2种，带参数的构造函数中初始化；

第3种,直接给成员变量赋值;

第4种,调用成员函数来初始化成员变量;

第5种，用this指针；

分别叙述。

方法一：

 
  
  1. class animal 
  2. { 
  3. public: 
  4.     int a,b; 
  5.     animal(); 
  6. }; 
  7. animal::animal() 
  8.  
  9. { 
  10.     a=5; 
  11.     b=3; 
  12. } 
 
  
方法二：
 
  
 
  
  1. class animal 
  2. { 
  3. public: 
  4.     int a,b; 
  5.     animal(int x,int y);//构造函数，有参数 
  6. }; 
  7. animal::animal(int x,int y) 
  8. { 
  9.     a=x; 
  10.     b=y; 
  11. } 
 
  
方法三：
 
  
 
  
  1. class animal 
  2. { 
  3. public: 
  4.     int a,b; 
  5. }; 
  6. void main() 
  7. { 
  8.     animal cat; 
  9.     cat.a=5;//直接给成员变量赋值 
  10.  
  11.     cat.b=3; 
  12.     cout<<cat.a<<endl<<cat.b<<endl; 
  13. } 
 
  
方法四：
 
  
 
 
  
 
  
  1. class animal 
  2. { 
  3. public: 
  4.     int a,b; 
  5.     void init(int x,int y); 
  6. }; 
  7. void animal::init(int x,int y) 
  8. { 
  9.     a=x; 
  10.     b=y; 
  11. } 
  12.  
  13. void main() 
  14. { 
  15.     animal cat; 
  16.     cat.init(5,3);//调用成员函数的方法给成员变量初始化 
  17.  
  18.     cout<<cat.a<<endl<<cat.b<<endl; 
  19. } 
 
  
方法五：
 
  
 
  
  1. class animal 
  2. { 
  3. public: 
  4.     int a,b; 
  5.     void init(int x,int y); 
  6. }; 
  7. void animal::init(int a,int b) 
  8. { 
  9.     this->aa=a;//当形参变量名与成员变量名发生冲突时，用this指针区分想对哪个变量赋值 
  10.  
  11.     this->bb=b; 
  12. } 
 
  
针对不同的变量类型，在选择初始化方法时，有不同的优先顺序。总结如下：
 
  
普通的变量：
 
  
一般不考虑啥效率的情况下 可以在构造函数中进行赋值。考虑一下效率的可以再构造函数的初始化列表中进行。
 
  
 
  
  1. class CA 
  2. { 
  3. public: 
  4.    int data; 
  5.    public: 
  6.    CA(); 
  7. }; 
  8. CA::CA():data(0)//……#1……初始化列表方式 
  9. { 
  10. //data = 0;//……#1……赋值方式 
  11. }; 
 
  
 
  
static 静态变量：
 static变量属于类所有，而不属于类的对象，因此不管类被实例化了多少个对象，该变量都只有一个。在这种性质上理解，有点类似于全局变量的唯一性。
 
  
 
  
  1. class CA 
  2. { 
  3. public: 
  4. static int sum; 
  5. public: 
  6. CA(); 
  7. }; 
  8. int CA::sum=0;//……#2……类外进行初始化 
 
  
const 常量变量： const常量需要在声明的时候即初始化。因此需要在变量创建的时候进行初始化。必须采用在构造函数的初始化列表中进行。
 
  
 
  
  1. class CA 
  2. { 
  3. public: 
  4. const int max; 
  5. public: 
  6. CA(); 
  7. }; 
  8. CA::CA():max(100) 
  9. { 
  10. …… 
  11. } 
 
  
Reference 引用型变量： 引用型变量和const变量类似。需要在创建的时候即进行初始化。也是必须在初始化列表中进行。
 
  
 
 
  
 
  
  1. class CA 
  2. { 
  3. public: 
  4. int init; 
  5. int& counter;  
  6. …… 
  7. public: 
  8. CA(); 
  9. …… 
  10. }; 
  11. CA::CA():counter(init) 
  12. { 
  13. …… 
  14. } 
 
  
const static integral 变量: 对于既是const又是static 而且还是×××变量，C++是给予特权的。可以直接在类的定义中初始化。short可以，但float的不可以哦。
 
  
 
 
  
 
  
  1. class CA 
  2. { 
  3. public: 
  4. //static const float fmin = 0.0;// only static const integral data members can be initialized within a class 
  5. const static int nmin = 0; 
  6. public: 
  7. }; 
 
  
总结起来，可以初始化的情况有如下四个地方： 1、在类的定义中进行的，只有const 且 static 且 integral 的变量。 2、在类的构造函数初始化列表中， 包括普通变量，const常量（不包含第一种情况）和Reference变量。 3、在类的定义之外初始化的，包括static变量。因为它是属于类的唯一变量。 4、普通的变量可以在构造函数的内部，通过赋值方式进行。当然这样效率不高。 5.const数据成员（非static）必须在构造函数的初始化列表中初始化。 6.数组成员是不能在初始化列表里初始化的。 7.const static 和static const是一样的，这样的变量可以直接在类定义中初始化，也可以在类外。 说明了一个问题：C++里面是不能定义常量数组的！因为5和6的矛盾。 类对象的构造顺序是这样的： 1.分配内存，调用构造函数时，隐式／显示的初始化各数据成员 2.进入构造函数后在构造函数中执行一般计算