const 在类中的应用

在 C++ 中，const 关键字在类中的应用非常广泛，它可以用于声明常量数据成员、常量成员函数、常量对象等。下面是 const 在类中的几个常见应用场景及其说明：

1. 常量数据成员

在类中，const 数据成员的值在对象创建时必须初始化，并且不能在对象的生命周期内更改。

#include <iostream>

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

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

private:
    const int value; // 常量数据成员，必须在构造函数中初始化
};

int main() {
    MyClass obj(42);
    obj.printValue(); // 输出 Value: 42

    return 0;
}

2. 常量成员函数

常量成员函数不会修改对象的状态，它可以在常量对象上调用。这些函数在声明时使用 const 关键字修饰。

#include <iostream>

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

    // 常量成员函数
    int getValue() const {
        return value;
    }

    // 修改值的成员函数
    void setValue(int val) {
        value = val;
    }

private:
    int value;
};

int main() {
    MyClass obj(42);
    const MyClass& constRef = obj; // 常量引用

    std::cout << "Value: " << constRef.getValue() << std::endl; // 可以调用常量成员函数

    // constRef.setValue(100); // 错误：不能在常量对象上调用非常量成员函数

    return 0;
}

3. 常量对象

常量对象是 const 修饰的对象，它的状态不能被修改。只能调用常量成员函数。

#include <iostream>

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

    int getValue() const {
        return value;
    }

    void setValue(int val) {
        value = val;
    }

private:
    int value;
};

int main() {
    const MyClass constObj(42); // 常量对象

    std::cout << "Value: " << constObj.getValue() << std::endl; // 可以调用常量成员函数

    // constObj.setValue(100); // 错误：不能在常量对象上调用非常量成员函数

    return 0;
}

4. 常量引用参数

函数参数为 const 引用时，函数可以接受常量对象和非常量对象，但函数内部不能修改被引用的对象。

#include <iostream>

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

    int getValue() const {
        return value;
    }

private:
    int value;
};

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

int main() {
    MyClass obj(42);
    printValue(obj); // 传递非常量对象

    const MyClass constObj(100);
    printValue(constObj); // 传递常量对象

    return 0;
}

5. 常量成员函数与修改成员

常量成员函数保证不修改对象的状态，这使得它们可以在常量对象上被调用。对于非常量成员函数，它们可以修改对象的状态，并且不能在常量对象上调用。

#include <iostream>

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

    // 常量成员函数
    int getValue() const {
        return value;
    }

    // 非常量成员函数
    void setValue(int val) {
        value = val;
    }

private:
    int value;
};

int main() {
    MyClass obj(42);
    const MyClass& constRef = obj;

    std::cout << "Value: " << constRef.getValue() << std::endl; // 正确：调用常量成员函数

    // constRef.setValue(100); // 错误：不能调用非常量成员函数

    return 0;
}

总结

• 常量数据成员：const 数据成员必须在构造函数中初始化，并且不能被修改。
• 常量成员函数：用 const 修饰的成员函数承诺不会修改对象的状态，可以在常量对象上调用。
• 常量对象：用 const 修饰的对象其状态不能被修改，只能调用常量成员函数。
• 常量引用参数：可以绑定到常量对象或非常量对象，函数内部不能修改被引用的对象。

const 关键字在类中的应用提供了一种机制来确保对象的不可变性和数据的安全性，有助于编写更加稳定和可靠的代码。