C++中的‘const‘关键字

目录

`const` 变量

`const` 指针

1. 指向 `const` 对象的指针

2. `const` 指针

3. 指向 `const` 对象的 `const` 指针

`const` 函数参数

1. 按值传递的 `const` 参数

2. 按引用传递的 `const` 参数

`const` 成员函数

`const` 成员变量

返回 `const` 值

`const` 迭代器

`const` 函数返回类型

总结

---

摘要

在 C++ 中，`const` 关键字用于表示某个值不能被修改。它可以用于变量、函数参数、成员函数、指针等多个场景，主要是增强代码的安全性和可读性。

`const` 变量

声明一个不可修改的变量。

#include <iostream>

int main() {
    const int x = 10;
    // x = 20; // 错误，x 是 const 变量，不能被修改

    std::cout << "x: " << x << std::endl;
    return 0;
}

`const` 指针

1. 指向 `const` 对象的指针

指针指向的对象是 `const`，不能通过指针修改对象的值。

#include <iostream>

int main() {
    int x = 10;
    const int *ptr = &x;

    // *ptr = 20; // 错误，不能通过 ptr 修改 x 的值

    x = 30; // 可以直接修改 x
    std::cout << "x: " << x << std::endl;

    return 0;
}

2. `const` 指针

指针本身是 `const`，指针的地址不能修改。

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x;

    // ptr = &y; // 错误，ptr 是 const 指针，不能修改地址

    *ptr = 30; // 可以通过 ptr 修改 x 的值
    std::cout << "x: " << x << std::endl;

    return 0;
}

3. 指向 `const` 对象的 `const` 指针

指针本身和指针指向的对象都是 `const`。

#include <iostream>

int main() {
    int x = 10;
    const int *const ptr = &x;

    // *ptr = 20; // 错误，不能通过 ptr 修改 x 的值
    // ptr = &y;  // 错误，ptr 是 const 指针，不能修改地址

    std::cout << "x: " << x << std::endl;
    return 0;
}

`const` 函数参数

1. 按值传递的 `const` 参数

不能在函数内部修改传入的参数。

#include <iostream>

void printValue(const int value) {
    // value = 20; // 错误，value 是 const 参数，不能修改
    std::cout << "Value: " << value << std::endl;
}

int main() {
    int x = 10;
    printValue(x);
    return 0;
}

2. 按引用传递的 `const` 参数

传递引用时避免拷贝，并且保证引用的对象不会被修改。

#include <iostream>

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

int main() {
    int x = 10;
    printValue(x);
    return 0;
}

`const` 成员函数

表示该成员函数不会修改类的任何成员变量。

#include <iostream>

class MyClass {
public:
    MyClass(int v) : value(v) {}

    void printValue() const {
        std::cout << "Value: " << value << std::endl;
    }

    // void setValue(int v) const {
    //     value = v; // 错误，不能在 const 成员函数中修改成员变量
    // }

private:
    int value;
};

int main() {
    MyClass obj(10);
    obj.printValue();
    return 0;
}

`const` 成员变量

类中的成员变量一旦初始化后就不能被修改。需要在构造函数初始化列表中进行初始化。

#include <iostream>

class MyClass {
public:
    MyClass(int v) : value(v) {}

    void printValue() const {
        std::cout << "Value: " << value << std::endl;
    }

private:
    const int value;
};

int main() {
    MyClass obj(10);
    obj.printValue();
    return 0;
}

返回 `const` 值

避免返回值被修改。

#include <iostream>

const int getValue() {
    return 10;
}

int main() {
    const int x = getValue();
    // x = 20; // 错误，x 是 const 变量，不能修改

    std::cout << "x: " << x << std::endl;
    return 0;
}

`const` 迭代器

STL 容器的 `const` 迭代器，保证迭代器指向的元素不能被修改。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    std::vector<int>::const_iterator it = vec.begin();
    // *it = 10; // 错误，不能修改 const 迭代器指向的元素

    for (; it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

`const` 函数返回类型

保证函数返回的指针或引用不能修改所指对象。

#include <iostream>

class MyClass {
public:
    MyClass(int v) : value(v) {}

    const int& getValue() const {
        return value;
    }

private:
    int value;
};

int main() {
    MyClass obj(10);
    const int& val = obj.getValue();
    // val = 20; // 错误，不能修改 const 引用

    std::cout << "Value: " << val << std::endl;
    return 0;
}

总结

在 C++ 中`const` 有广泛的使用场景。我们在开发时使用 `const` 可以提高代码的可读性和安全性，防止无意中修改变量的值。需要注意合理使用‘const’才能更好的把代码编写规范。