C++ const关键字详解

最新推荐文章于 2025-06-13 15:32:06 发布

原创最新推荐文章于 2025-06-13 15:32:06 发布 · 660 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

const 是 C++ 中的关键字，表示常量，它的用途非常广泛，能够帮助保证程序的正确性和优化。根据 const 在不同地方的使用，语法和效果也有所不同。下面我将详细介绍 const 关键字的各种用法。

1. 常量变量（const 变量）

通过 const 定义的变量是不可修改的，必须在初始化时给定值，并且在之后的程序中不能改变其值。

示例：

const int x = 10;  // x是常量，不能再修改
// x = 20; // 编译错误：不能修改常量变量的值

解释：

const 在变量前面，表示该变量的值在初始化后不可修改。尝试修改常量会导致编译错误。

常量指针和常量值

常量指针：指针的值不能更改，即指针不能指向其他地址。
常量值：指针指向的值不能更改，即指向的数据不能修改。

2. 常量指针（const pointer）

指针的值不可修改，但可以通过指针修改所指向的内容。

int a = 10;
int b = 20;
int* const ptr = &a;  // 常量指针，指针不可修改
*ptr = 30;  // 可以修改ptr指向的内容
// ptr = &b; // 编译错误，ptr是常量指针，不能指向其他地址

解释：

int* const ptr 表示常量指针，ptr 在初始化后不能指向其他地址，但可以修改 ptr 所指向地址的值。

3. 指向常量的指针（pointer to const）

指针的值可以更改，但不能通过指针修改所指向的内容。

int a = 10;
int b = 20;
const int* ptr = &a;  // 指向常量的指针，不能修改指向的内容
// *ptr = 30; // 编译错误，不能修改指向的内容
ptr = &b;  // 可以修改指针，指向另一个地址

解释：

const int* ptr 表示指向常量的指针，指针可以修改指向的地址，但不能通过指针修改地址中的值。

4. 常量成员函数（const member functions）

在类中，常量成员函数是不能修改类的成员变量的。通常用于只读取成员变量而不修改它们的函数。常量成员函数的声明会加上 const 关键字，放在成员函数的后面。

示例：

class MyClass {
public:
    void display() const {  // 常量成员函数
        std::cout << "This is a constant member function." << std::endl;
        // value = 10; // 编译错误，不能在常量成员函数中修改成员变量
    }

private:
    int value;
};

解释：

const 放在函数签名的末尾，表示该成员函数不能修改类的成员变量。

5. 常量引用（const reference）

常量引用可以避免复制大型对象的开销，同时确保对象不会被修改。对于大型对象或复杂类型，使用常量引用是一个有效的优化方式。

示例：

void print(const std::string& str) {  // 使用常量引用，避免复制
    std::cout << str << std::endl;
}

解释：

使用 const 引用传递参数，保证函数内部不会修改传递的参数，同时避免了对象复制的开销。

6. 常量数组和常量指针数组

当数组或指针作为常量时，通常意味着不能修改其内容或指向。

示例：

常量数组：

const int arr[5] = {1, 2, 3, 4, 5};
// arr[0] = 10; // 编译错误，数组元素不能修改

指向常量的指针数组：

const int* arr[5];  // 数组的每个元素都是一个指向常量整数的指针

7. 常量的指针数组

指针数组中的指针是常量，意味着指针不能改变，但指针指向的值是可以修改的。

int a = 10;
int b = 20;
int* const arr[5] = { &a, &b };  // 每个元素都是常量指针
// arr[0] = &b; // 编译错误，指针不可修改
*arr[0] = 30;  // 可以通过指针修改内容

解释：

int* const arr[5] 是一个包含常量指针的数组。指针的值不能改变，但指针指向的内容是可以修改的。

8. `const` 与 `volatile` 配合使用

const 和 volatile 可以一起使用，volatile 表示该变量的值可能会被外部因素（如硬件或多线程）改变，告诉编译器不要优化对该变量的访问。而 const 表示该变量的值不应被修改。

const volatile int regValue = 100;  // 变量是常量但可能被外部修改

解释：

const volatile 结合了常量性和易变性的特性，表示该变量不应该被修改，但它的值可以在程序外部变化（如硬件寄存器的值）。

9. `const` 在函数参数中的应用

函数参数中的 const：通常情况下，const 被用于函数的参数，尤其是传递大型对象时，以避免不必要的复制，并保证在函数内部不修改该对象。

示例：

void printMessage(const std::string& msg) {  // 使用常量引用避免复制
    std::cout << msg << std::endl;
}

int main() {
    std::string message = "Hello, world!";
    printMessage(message);  // 传递常量引用，避免复制
}

解释：

const std::string& 作为参数，表示 msg 是一个常量引用，函数内部不能修改 msg 的值，同时避免了复制 std::string 对象的开销。

10. `const` 在指针类型声明中的应用

const 在声明指针类型时，可以放在指针的左边或右边，具体含义不同：

常量指针（int* const）：指针本身是常量，不能指向其他对象，但可以修改指向的内容。
指向常量的指针（const int*）：指针可以指向其他对象，但不能修改指向的内容。
常量指针指向常量的内容（const int* const）：指针本身和指向的内容都不能修改。

int a = 10, b = 20;
int* const ptr1 = &a;    // 常量指针，不能更改指向的地址
const int* ptr2 = &a;    // 指向常量的指针，不能修改所指向的值
const int* const ptr3 = &a; // 常量指针指向常量，指针和指向的值都不能更改