C++中的const

---

前言

const关键字其实在C中就有，C中的const可以修饰变量、修饰指针。
C++包含了C的所有，由于C++中又加了引用的机制、类和对象，因此C++中的const还可以修饰引用、修饰类对象、修饰类成员函数。

0x00 const修饰变量

0.0 const与无参宏比较

C++中的const常量替代了C语言中的无参宏。比较一下const常量与无参宏：

	const常量	无参宏
0x01	可以查看内存，便于调试	无法调试
0x02	有类型检查	无类型，可能会有精度损失

const变量相比于无参常量宏，具有以下优点：

1. 可以取地址，在内存中查看变量的值，便于调试。
2. 有类型检查。基本类型与对应的值匹配。
3. 有作用域。全局变量和局部变量。

0.1 const常量必须赋初值

首先需要知道的是const修饰的变量不能修改(const变量也被称为const常量)，因此const常量必须赋初值。

const int PI;
PI = 3;
// error C2734: “PI”: 如果不是外部的，则必须初始化常量对象
// error C3892: “PI”: 不能给常量赋值

0.2 const常量在编译期间值替换

下面的代码中，const常量N在Debug和Release版本不同。

debug版N占用内存。release版N不占用内存，利用指针强转修改N处的没有对应的代码，不能下断点。

int main(int argc, char* argv[])
{
    const int N = 100;

    *(int*)&N = 10;

    int n = N;
    cout << n << endl; // 100
    return 0;
}

在C++中，n的值为100。常量N地址的内容确实已经被修改为10，但是由于编译期间会把常量给替换，所以n的初值为100。

在C中，n的初值为10。C语言中，const常量只对语法层面进行检查，如不能修改const常量，常量必须赋初值。const常量占用内存，因此可以被修改。

const修饰变量，变量就是个常量。编译期间会进行值替换。

0.3 const全局变量

const的全局变量，在已初始化的只读数据区，不可以修改。

const int g_N = 999;

int main(int argc, char* argv[])
{

    *(int*)&g_N = 1000; // 0xC0000005异常，程序退出

    int n = g_N;
    printf("%d\r\n", n);

    return 0;
}

0x01 const修饰指针

const修饰指针，可以提高程序的可读性，防止开发者的一些误操作。

1.0 常量指针与指针常量

const修饰指针，const在星号的不同位置的对指针有不同的影响。

const在星号左边（常量指针） - 内容不能改
const在星号右边（指针常量） - 指针不能改

// 常量指针
char buf[] = "hello";
const char* p = buf;   //指针指向的内容不可修改, 指针的值可以修改
p[0] = 'a';   // error


// 指针常量
char* const p3 = buf; //指针指向的内容可修改, 指针变量不可修改
*p3 = 'a';
//p3 = nullptr; //error

1.1 const指针的相互转换

cosnt指针的相互转换不同于下面的赋初值。

用const类型指针赋值给已存在的const类型指针，也就是const类型指针的相互转换问题。

判定的规则就是指针常量不能修改。

判定的方法：看等号左边的变量类型，等号左边的变量是否是指针常量，也就是等号左边变量的类型中看const在星号右边？星号右边有const的不能修改。

int main(int argc, char* argv[])
{
    const int* pn1 = nullptr;
    int* const pn2 = nullptr;
    const int* const pn3 = nullptr;

    //看星右
    /*0*/pn1 = pn2;//通过
    /*1*/pn1 = pn3;//通过
    /*2*/pn2 = pn1;//不 指针被const修改，不能修改
    /*3*/pn2 = pn3;//不
    /*4*/pn3 = pn1;//不
    /*5*/pn3 = pn2;//不

    return 0;
}

1.2 const指针初始化

const指针初始化不同于上面const指针的相互转换。

const指针初始化，可以分为用const指针初始化普通指针，和用const指针初始化const指针。

判定的规则就是限制多的不能初始化为限制少的。

判定的方法就是看初始化时，等号两边变量的类型，并且看两边变量类型中星号的左边。如果等号两边变量类型中星号的左边类型，满足上面的判定规则，则可以初始化。

int main(int argc, char* argv[])
{
    int i = 100;

    const int* p1 = &i;
    // error C2440: “初始化”: 无法从“const int *”转换为“int *”
    //int* p11 = p1; // p11的*左边为int与p1的*左边const int不同，编译报错

    int* const p2 = &i;
    int* p22 = p2; // p22的*左边与p2的*左边都为int 编译通过

    return 0;
}

const指针初始化普通指针，分别看等号两边的指针类型， * 左边的内容是否合理，限制多的不能转换为限制少的。

---

int main(int argc, char* argv[])
{
    const int* pn1 = nullptr;
    int* const pn2 = nullptr;
    const int* const pn3 = nullptr;

    //可以添加限制，不能去掉限制，就看星左边
    /*0*/const int* pn4 = pn2; //能
    /*1*/const int* pn41 = pn3; //能
    /*2*/int* const pn5 = pn1; //不能 ,相当于去掉了内容不能修改的限制
    /*3*/int* const pn51 = pn3; //不能 ,相当于去掉了内容不能修改的限制
    /*4*/const int* const pn6 = pn1;//能
    /*5*/const int* const pn61 = pn2;//能

    return 0;
}

const指针初始化const指针。应该比较等号两边变量的类型，等号左边的变量类型要看 * 左边， 等号右边变量的类型也要看 * 左边。限制多的不能转换为限制少的。

1.3 小试牛刀

int main()
{
    int nVal1 = 8;
    int nVal2 = 9;

    const int* p1 = &nVal1;
    int const* p2 = &nVal2;
    int* const p99 = &nVal2;

    const int* const p3 = &nVal1;
    const int* const p4 = p1;
    const int* const p5 = p2;

    int* p6 = p1;
    int* p7 = p3;
    const int* p8 = p3; 
    int* const p9 = p3;
    int* const p10 = p1;

    return 0;
}

参考答案：

int main()
{
    int nVal1 = 8;
    int nVal2 = 9;

    // 赋初值，限制多的不能赋值给限制少的。const char*不能赋值给char*
    // 等号左边的类型要看*左边
    const int* p1 = &nVal1;
    int const* p2 = &nVal2;
    int* const p88 = &nVal2;

    const int* const p3 = &nVal1;
    const int* const p4 = p1;
    const int* const p5 = p2;

    //int* p6 = p1; // 不可以，丢掉了“指向的内容不能修改”的限制
    //int* p7 = p3; // 不可以，丢掉了“指向的内容与指针变量不能修改”的限制
    const int* p8 = p3; // 等号左右类型都要看*左边，都为const int*
    //int* const p9 = p3; // 不可以，丢掉了“指向的内容不能修改”的限制
    //int* const p10 = p1; // 不可以，丢掉了“指向的内容不能修改”的限制

    return 0;
}

0x02 const修饰引用

const修饰引用，见C++中的引用

0x03 const在class中的作用

3.0 const成员变量和成员对象

在构造类对象时，调用该类的构造函数，如果该类有成员对象，在该类的构造函数中，则会先调用成员对象的构造函数。如果开发者没有写构造函数，编译器会添加默认的构造函数。

通过构造函数中的初始化列表，可以指定成员对象的构造函数进行初始化。

const修饰变量时必须初始化。

const成员变量和成员对象只有一种初始化方法，那就是使用构造函数的初始化列表。

3.1 const成员函数

常量成员函数的this指针类型：const CString *。
普通成员函数的this指针类型：CString *。

所以常成员函数里面不能修改成员数据。因此只要不修改数据成员的函数都应该声明常量成员函数。

class CString
{
public:
    const char* GetBuf() const 
    {
        //  error C2440: “初始化”: 无法从“const CString *”转换为“int *”
        //int* p = this;
        return m_pBuf;
    }
    const char* GetBuf()
    {
        // error C2440: “初始化”: 无法从“CString *”转换为“int *”
        //int* p = this;
        return m_pBuf;
    }
private:
    char* m_pBuf;
};

3.2 const对象

const对象通常和引用一起作为函数的参数。

const对象无法修改数据成员。
不允许调用任何成员函数。
只能调用常成员函数。

因为const对象无法修改数据成员，常成员函数中的this指针是常对象指针，所以常成员函数中通过this指针不能修改数据成员。

class CString
{
public:
    const char* GetBuf() const 
    {
        // error C3490: 由于正在通过常量对象访问“m_pBuf”，因此无法对其进行修改
        //m_pBuf = nullptr;
        return m_pBuf;
    }
    const char* GetBuf()
    {
        m_pBuf = nullptr;
        return m_pBuf;
    }
private:
    char* m_pBuf;
};