CPlusPlus - #011 const的用法

const的用法

1 目标

本文的目的是了解const的用法。

2 示例代码

2.1 常量变量

定义一个常量变量，变量的值不能被修改。

const int x = 10;  // x 是一个常量，不能被修改
// x = 20;  // 错误：不能修改常量变量

2.2 常量指针

2.2.1 指向常量的指针

指针指向的值是常量，不能通过该指针修改值。

const int y = 10;
const int* ptr = &y;  // ptr 是指向常量 int 的指针
// *ptr = 20;  // 错误：不能通过 ptr 修改 y 的值
int z = 20;
ptr = &z;  // 可以修改 ptr 本身指向其他地址

2.2.2 常量指针

指针本身是常量，不能修改指针指向的地址，但可以通过指针修改值。

int a = 10;
int* const ptr2 = &a;  // ptr2 是常量指针
*ptr2 = 20;  // 可以通过 ptr2 修改 a 的值
// ptr2 = &b;  // 错误：不能修改 ptr2 指向的地址

2.2.3 指向常量的常量指针

指针本身和指针指向的值都是常量。

const int b = 10;
const int* const ptr3 = &b;  // ptr3 是指向常量的常量指针
// *ptr3 = 20;  // 错误：不能通过 ptr3 修改 b 的值
// ptr3 = &c;  // 错误：不能修改 ptr3 指向的地址

2.3 常量函数参数

2.3.1 常量值参数

传递给函数的参数在函数内部不能被修改。

void printValue(const int value) {
    // value = 20;  // 错误：不能修改常量参数
    std::cout << value << std::endl;
}

2.3.2 指向常量的指针参数

指针参数指向的值在函数内部不能被修改。

void printPointerValue(const int* ptr) {
    // *ptr = 20;  // 错误：不能通过 ptr 修改值
    std::cout << *ptr << std::endl;
}

2.4 常量成员函数

常量成员函数保证函数内部不会修改对象的成员变量。

class MyClass {
private:
    int value;

public:
    MyClass(int val) : value(val) {}

    int getValue() const {
        // this->value = 20;  // 错误：不能在常量成员函数中修改成员变量
        return value;
    }
};

2.5 常量对象

定义一个常量对象，该对象的成员变量不能被修改。

#include <iostream>

class MyClass {
private:
      int value;

public:
    MyClass(int val) : value(val) {}

    int getValue() const {
        // this->value = 20;  // 错误：不能在常量成员函数中修改成员变量
        return value;
    }

    void setValue(int value)  {
        this->value = value;  
    }
};

int main()
{
    const MyClass obj(10);
    // obj.setValue(20); // 错误：不能通过常量对象调用非常量成员函数
    return 0;
}

如何一定要调用，那么需要使用mutable和const

#include <iostream>

class MyClass {
private:
    mutable  int value;

public:
    MyClass(int val) : value(val) {}

    int getValue() const {
        // this->value = 20;  // 错误：不能在常量成员函数中修改成员变量
        return value;
    }

    void setValue(int value) const {
        this->value = value;  
    }
};

int main()
{
    const MyClass obj(10);
    obj.setValue(20); 
    return 0;
}

2.6 常量引用

常量引用通常用于函数参数，避免在传递大型对象时进行不必要的拷贝，同时保护原对象不被修改。

void printObject(const MyClass& obj) {
    std::cout << obj.getValue() << std::endl;
}

2.7 顶层 const 和 底层 const

• 顶层 const: 修饰指针本身，使其为常量。
• 底层 const: 修饰指针指向的对象，使其为常量。

int x = 10;
int* p1 = &x;                // 非常量指针指向非常量
const int* p2 = &x;          // 底层 const，p2 是指向常量的指针
int* const p3 = &x;          // 顶层 const，p3 是常量指针
const int* const p4 = &x;    // 顶层和底层 const，p4 是指向常量的常量指针