1.类成员的初始化

c++中提供了初始化列表对类成员变量进行初始化
语法规则：使用在构造函数的定之后，函数体之前

ClassNam::ClassName() : m1(v1), m2(v1, v2), m3(v3)    //初始化列表
{
    //some other initialiaze operatiion
}

注意事项：

a.成员的初始化顺序与成员的声明顺序相同；
b.成员的初始化顺序与初始化列表中的位置无关；（初始化列表中的先后顺序无法决定，成员的初始化顺序。成员的初始化顺序又成员定义的先后顺序决定。即先定义的先初始化，后定义的后初始化）
c.初始化列表先于构造函数的函数体执行；

#include <stdio.h>

class Value
{
private:
    int mi;
public:
    Value(int i)
    {
        printf("i = %d\n", i);
        mi = i;
    }
    int getI()
    {
        return mi;
    }
};

class Test
{
private:
    Value m2;
    Value m3;
    Value m1;        //这里定义了3个变量。定义的顺序2,3,1
public:
    Test() : m1(1), m2(2), m3(3)        //这里调用Value实现初始化，列表顺序1,2,3
    {
        printf("Test::Test()\n");        //初始化完后才执行构造函数的函数体
    }
};


int main()
{
    Test t;
    
    return 0;
}

最后实现的结果是2,3,1

注意：
a.这种类中组合的这关系，类的初始化只能使用初始化列表。
b.类中的const成员会被分配空间
c.类中的const成员的本质是只读变量
d.类中的const成员只能在初始化列表中指定初始值
（编译器无法直接得到const成员的初始值，因此无法进入符号表成为真正意义上的常量）

#include <stdio.h>

class Value
{
private:
    int mi;
    
public:

    Value(int i)
    {
        printf("i = %d\n", i);
        mi = i;
    }

    int getI()
    {
        return mi;
    }    
};

class Test
{
private:
    const int ci;
    Value m2;
    Value m3;
    Value m1;
    
public:
    Test() : m1(1), m2(2), m3(3), ci(100)
    {
         printf("Test::Test()\n");
    }
    
    int getCI()
    {
        return ci;
    }
    
    int setCI(int v)
    {
        int *p = const_cast<int *>(&ci);        //去掉只读属性
        
        *p = v;
    }
};

int main(void)
{
    Test t;
    
    printf("t.ci = %d\n", t.getCI());       //100

    t.setCI(10);
    
    printf("t.ci = %d\n", t.getCI());       //10

    return 0;
}