C++ const用法详解 - 摩柯技术社区

1. const 修饰普通变量

在 C++ 中，const 关键字用于声明常量，被 const 修饰的变量其值不能被修改。例如：

const int num = 10;
// num = 20;  // 这行代码会报错，因为 num 是常量，不能被修改

上述代码中，num 被声明为 const int 类型，即常量整数，一旦初始化后就不能再修改其值。如果尝试修改，编译器会抛出错误。

1.1 初始化的必要性

const 修饰的变量必须在声明时进行初始化，否则会导致编译错误。如下代码是错误的：

const int num;  // 错误，未初始化

正确的做法是在声明时赋予初始值：

const int num = 10;

1.2 const 与类型推导

在 C++11 引入 auto 关键字后，类型推导变得更加方便。当 auto 与 const 结合时，编译器会根据初始化表达式推导类型并应用 const 限定。例如：

const auto value = 10;  // value 被推导为 const int 类型

这里，value 的类型被推导为 const int，因为初始值 10 是 int 类型，并且 const 关键字修饰了 auto。

2. const 修饰指针

const 修饰指针时，情况较为复杂，有两种主要的形式：指向常量的指针和常量指针。

2.1 指向常量的指针

指向常量的指针是指指针所指向的对象是常量，不能通过该指针修改所指向对象的值，但指针本身的值（即所指向的地址）可以改变。声明形式如下：

const int *ptr;  // 指向常量的指针
int const *ptr;  // 这与上面的声明等价

示例代码：

int num1 = 10;
int num2 = 20;
const int *ptr = &num1;
// *ptr = 30;  // 错误，不能通过指向常量的指针修改所指向的值
ptr = &num2;  // 正确，指针本身的值可以改变

在上述代码中，ptr 是一个指向常量 int 类型的指针，它可以指向不同的 int 变量，但不能通过 ptr 修改所指向变量的值。

2.2 常量指针

常量指针是指指针本身是常量，其值（即所指向的地址）不能改变，但可以通过该指针修改所指向对象的值（前提是对象本身不是常量）。声明形式如下：

int * const ptr = &num;

示例代码：

int num = 10;
int * const ptr = &num;
*ptr = 20;  // 正确，可以通过常量指针修改所指向的值
// ptr = &other_num;  // 错误，常量指针的值不能改变

这里，ptr 是一个常量指针，它在初始化时指向 num，之后不能再改变其指向的地址，但可以通过 ptr 修改 num 的值。

2.3 指向常量的常量指针

还可以声明指向常量的常量指针，即指针本身是常量且所指向的对象也是常量。声明形式如下：

const int * const ptr = &num;

示例代码：

int num = 10;
const int * const ptr = &num;
// *ptr = 20;  // 错误，所指向的对象是常量，不能修改
// ptr = &other_num;  // 错误，指针本身是常量，不能改变指向

在这种情况下，无论是通过指针修改所指向的值，还是改变指针的指向，都会导致编译错误。

3. const 修饰引用

const 修饰引用时，表示引用的对象是常量，不能通过该引用修改对象的值。声明形式如下：

const int &ref = num;

示例代码：

int num = 10;
const int &ref = num;
// ref = 20;  // 错误，不能通过 const 引用修改对象的值

这里，ref 是对 num 的 const 引用，不能通过 ref 修改 num 的值。const 引用在函数参数传递和返回值中有着重要的应用。

3.1 const 引用作为函数参数

当函数参数为 const 引用时，可以避免对象的拷贝，提高效率，同时保证函数内部不会修改传入对象的值。例如：

void printValue(const int &value) {
    std::cout << "Value: " << value << std::endl;
    // value = 100;  // 错误，不能修改 const 引用的值
}

在上述函数中，value 是 const 引用，函数内部只能读取其值，不能修改。这样可以确保传入的对象在函数内部不会被意外修改，同时对于较大的对象，通过引用传递避免了拷贝开销。

3.2 const 引用作为函数返回值

将 const 引用作为函数返回值，可以防止返回值被意外修改。例如：

const int &getMax(const int &a, const int &b) {
    return a > b? a : b;
}

调用该函数时，返回的是一个 const 引用，调用者不能通过返回的引用修改返回的对象的值。

4. const 修饰成员函数

在类中，const 可以修饰成员函数。被 const 修饰的成员函数称为常量成员函数，它承诺不会修改对象的成员变量（除非成员变量被声明为 mutable）。

4.1 常量成员函数的声明

常量成员函数在声明和定义时，在参数列表后加上 const 关键字。例如：

class MyClass {
private:
    int data;
public:
    MyClass(int value) : data(value) {}
    int getData() const {  // 常量成员函数
        return data;
    }
};

在上述代码中，getData 函数是一个常量成员函数，它只能读取 data 成员变量的值，不能修改它。

4.2 常量对象与常量成员函数

常量对象只能调用常量成员函数，因为非常量成员函数可能会修改对象的状态，而常量对象的状态是不允许被修改的。例如：

const MyClass obj(10);
// obj.setData(20);  // 错误，常量对象不能调用非常量成员函数
int value = obj.getData();  // 正确，常量对象可以调用常量成员函数

非常量对象既可以调用常量成员函数，也可以调用非常量成员函数。

4.3 mutable 关键字与常量成员函数

mutable 关键字用于声明类的成员变量，使得即使在常量成员函数中也可以修改该成员变量。例如：

class Counter {
private:
    mutable int count;
public:
    Counter() : count(0) {}
    void increment() const {
        ++count;
    }
    int getCount() const {
        return count;
    }
};

在上述代码中，count 被声明为 mutable，因此在常量成员函数 increment 中可以修改它的值。

5. const 修饰类对象

当类对象被声明为 const 时，该对象的所有成员变量都成为常量，只能调用类的常量成员函数。

5.1 const 对象的创建与使用

例如：

class MyClass {
private:
    int data;
public:
    MyClass(int value) : data(value) {}
    int getData() const {
        return data;
    }
    void setData(int value) {
        data = value;
    }
};

const MyClass obj(10);
// obj.setData(20);  // 错误，const 对象不能调用非常量成员函数
int value = obj.getData();  // 正确，const 对象可以调用常量成员函数

这里，obj 是 const 对象，它只能调用 getData 这样的常量成员函数，不能调用 setData 这样的非常量成员函数。

5.2 const 对象数组

可以创建 const 对象数组，数组中的每个对象都是 const 的。例如：

const MyClass objects[3] = {MyClass(1), MyClass(2), MyClass(3)};
for (size_t i = 0; i < 3; ++i) {
    std::cout << "Object " << i << ": " << objects[i].getData() << std::endl;
}

在上述代码中，objects 是一个 const MyClass 类型的数组，数组中的每个元素都是 const 对象，只能调用常量成员函数。

6. const 与函数重载

const 可以用于函数重载，根据对象是否为 const 来调用不同的函数版本。例如：

class MyClass {
private:
    char *data;
public:
    MyClass(const char *str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    ~MyClass() {
        delete[] data;
    }
    char& operator[](size_t index) {
        return data[index];
    }
    const char& operator[](size_t index) const {
        return data[index];
    }
};

在上述代码中，MyClass 类重载了 [] 运算符，一个版本用于非常量对象，返回 char&，允许修改对象中的字符；另一个版本用于 const 对象，返回 const char&，防止通过 const 对象修改字符。

MyClass obj("Hello");
obj[0] = 'h';  // 正确，非常量对象调用非常量版本的 [] 运算符
const MyClass constObj("World");
// constObj[0] = 'w';  // 错误，const 对象调用常量版本的 [] 运算符，不能修改字符
char ch = constObj[0];  // 正确，const 对象调用常量版本的 [] 运算符，读取字符

7. const 与模板

在模板编程中，const 同样起着重要的作用。

7.1 模板函数中的 const

当编写模板函数时，const 可以用于修饰函数参数、返回值等，以保证数据的常量性。例如：

template <typename T>
void printValue(const T &value) {
    std::cout << "Value: " << value << std::endl;
}

在上述模板函数中，value 是 const 引用，保证了函数内部不会修改传入对象的值，同时适用于各种类型的对象。

7.2 模板类中的 const

在模板类中，const 可以用于修饰成员函数、对象等。例如：

template <typename T>
class Stack {
private:
    T *data;
    size_t top;
    size_t capacity;
public:
    Stack(size_t cap) : top(-1), capacity(cap) {
        data = new T[capacity];
    }
    ~Stack() {
        delete[] data;
    }
    void push(const T &value) {
        if (top < capacity - 1) {
            data[++top] = value;
        }
    }
    T pop() {
        if (top >= 0) {
            return data[top--];
        }
        throw std::underflow_error("Stack is empty");
    }
    const T& peek() const {
        if (top >= 0) {
            return data[top];
        }
        throw std::underflow_error("Stack is empty");
    }
};

在上述模板类 Stack 中，push 函数的参数 value 是 const 引用，防止在压栈操作时意外修改传入的值。peek 函数是常量成员函数，用于获取栈顶元素且不修改栈的状态，返回值也是 const 引用，防止通过返回值修改栈顶元素。

8. const_cast 运算符与 const

const_cast 是 C++ 中的一种类型转换运算符，用于去除对象的 const 或 volatile 限定。但使用 const_cast 需要谨慎，因为它打破了 const 的保护机制。

8.1 const_cast 的基本用法

例如：

const int num = 10;
int *ptr = const_cast<int*>(&num);
*ptr = 20;  // 未定义行为，虽然编译器可能不会报错，但修改 const 对象是危险的

在上述代码中，通过 const_cast 将 const int* 转换为 int*，然后尝试修改 num 的值，这会导致未定义行为。因为 num 原本是 const 对象，修改它的值违反了 const 的语义。

8.2 正确使用 const_cast 的场景

在某些情况下，const_cast 是有用的。例如，当一个函数既有 const 版本又有非 const 版本，且 const 版本需要调用非 const 版本来实现部分功能时，可以使用 const_cast。

class MyClass {
private:
    int data;
public:
    MyClass(int value) : data(value) {}
    void modifyData(int newData) {
        data = newData;
    }
    void constModifyData(int newData) const {
        MyClass *mutableThis = const_cast<MyClass*>(this);
        mutableThis->modifyData(newData);
    }
};

在上述代码中，constModifyData 是 const 成员函数，它通过 const_cast 将 this 指针转换为非 const 指针，然后调用 modifyData 函数来修改 data 成员变量。这种用法虽然不太常见，但在特定的设计场景下是合理的。不过要注意，只有在 const 成员函数内部，且明确知道对象的实际状态允许修改时，才能使用这种方法。

9. 总结 const 的注意事项

初始化问题：const 修饰的变量必须在声明时初始化，否则会导致编译错误。
指针和引用：注意区分指向常量的指针、常量指针以及 const 引用的不同语义和用法，避免混淆。
类成员函数：常量成员函数不能修改对象的成员变量（除非成员变量是 mutable），常量对象只能调用常量成员函数。
函数重载：利用 const 进行函数重载时，要确保函数的语义清晰，避免不必要的复杂性。
模板：在模板编程中，合理使用 const 可以增强代码的通用性和安全性。
const_cast：尽量避免使用 const_cast，因为它破坏了 const 的保护机制，只有在非常明确和必要的情况下才使用，并且要注意可能导致的未定义行为。

通过深入理解 const 在 C++ 中的各种用法，可以编写出更健壮、更安全的代码，提高程序的可靠性和可维护性。在实际编程中，要根据具体的需求和场景，合理地使用 const 关键字来限定数据的常量性，以达到最佳的编程效果。