第20课

第20课 - 初始化列表的使用

0. 问题

　　类中是否可以定义 const 成员？

　　下面的类定义是否合法？如果合法，ci 的值是什么，存储在哪里？

class Test
{
private:
    const int ci;
public:
    int getCI() { return ci;}
};

#include <stdio.h>

class Test
{
private:
    const int ci;
public:
    Test()
    {
        ci = 10;
    }
    int getCI() 
    { 
        return ci; 
    }
};


int main()
{
    Test t;
    
    printf("t.ci = %d
", t.getCI());
    
    return 0;
}

在C中：const 修饰的变量必须在定义的时候进行初始化，不能在定义之后对其进行赋值操作，违背了const 的含义。

在C++中：构造函数内部是对成员变量进行赋值操作，而不是初始化。初始化需要初始化列表。

1. 类成员的初始化

　　（1）C++ 中提供了初始化列表，可以对成员变量进行初始化

　　（2）语法规则：

ClassName::ClassName():m1(v1), m2(v2,v3),m3(v3) 
{
     //其它初始化操作
}

// 构造函数是对变量进行赋值操作，初始化列表是进行初始化操作，两个是不同的概念

#include <stdio.h>

class Test
{
private:
    int i;
    int j;
    const int k;
public:
    int getI()
    {
        return i;
    }
    int getJ()
    {
        return j;
    }
    int getK()
    {
        return k;
    }
    
    Test() : k(10)
    {
        printf("invoke consttuctor!
");
        i = 1;
        j = 2;
    }
};

int main(void)
{
    Test t1;
    
    printf("t1.getI() = %d, t1.getJ() = %d, t1.getK() = %d
", t1.getI(), t1.getJ(), t1.getK());

    return 0;
}

　　（3）注意事项

　　　　① 成员的初始化顺序与成员的声明顺序相同，而与初始化列表中的位置无关

　　　　② 初始化列表先于构造函数的函数体执行

#include <stdio.h>

class value
{
private:
    int m_i;
public:
    value(int val) : m_i(100)
    {
        printf("in value!
");
        printf("m_i = %d
", m_i);
        m_i = val;
    }    

    int getM_i()
    {
        return m_i;
    }
};

class Test
{
private:
    value m1;
    value m2;
public:
    Test() : m1(1), m2(2)    // 初始化列表，对m1, m2进行初始化。初始化还是调用value类中的构造函数，但还是先执行value中的初始化列表
    {
        printf("in Test!
");
    }
    
    int get()
    {
        return m1.getM_i();
    }
};

int main(void)
{
    Test t1;
    
    printf("t1.get() = %d
", t1.get());
    
    return 0;
}

2. 类中的 const 成员

　　（1）类中的 const 成员会被分配空间，局部对象会分配栈空间、动态对象会分配堆空间、全局对象会分配静态存储空间（和const int i; 不同）

　　（2）类中的 const 成员的本质是只读变量，可以通过指针隐式的修改。编译器无法直接得到 const 成员的初始值，因此无法进入符号表成为真正意义上的常量

　　（3）类中的 const 成员只能在初始化列表中指定初始值

#include <stdio.h>

class Value
{
private:
    int mi;
public:
    Value(int i)
    {
        printf("i = %d
", 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()
");
    }
    
    int getCI()
    {
        return ci;
    }

    int setCI(int v)
    {
        // 说明ci是个只读变量，可以通过指针修改内存值
        int* p = const_cast<int*>(&ci);
        *p = v;
    }
};

int main()
{
    Test t;

    printf("t.ci = %d
", t.getCI());

    t.setCI(10);

    printf("t.ci = %d
", t.getCI());

    return 0;
}

【小插曲】初始化与赋值不同

　　（1）初始化：对正在创建的对象进行初值设置
　　（2）赋值：   对已经存在的对象进行值设置

3. 小结

　　（1）类中可以使用初始化列表对成员进行初始化

　　（2）初始化列表先于构造函数体执行

　　（3）类中可以定义 const 成员变量

　　（4）const 成员变量必须在初始化列表中指定初始值

　　（5）const 成员变量为只读变量