C++中的const

const

  • 前言
  • 0x00 const修饰变量
    • 0.0 const与无参宏比较
    • 0.1 const常量必须赋初值
    • 0.2 const常量在编译期间值替换
    • 0.3 const全局变量
  • 0x01 const修饰指针
    • 1.0 常量指针与指针常量
    • 1.1 const指针的相互转换
    • 1.2 const指针初始化
    • 1.3 小试牛刀
  • 0x02 const修饰引用
  • 0x03 const在class中的作用
    • 3.0 const成员变量和成员对象
    • 3.1 const成员函数
    • 3.2 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;
};

你可能感兴趣的:(C/C++,c++)