C++常量成员[编辑 | 编辑源代码]

常量成员是C++面向对象编程中的重要概念，用于定义不可修改的类成员。它包含两种主要形式：常量成员变量和常量成员函数，分别用于保护数据不被修改和保证函数不修改对象状态。

常量成员变量[编辑 | 编辑源代码]

常量成员变量是指在类定义中被声明为const的成员变量，其值在初始化后不能被修改。

语法[编辑 | 编辑源代码]

class ClassName {
    const dataType constMember;
public:
    ClassName(parameters) : constMember(initialValue) { } // 必须通过初始化列表初始化
};

示例[编辑 | 编辑源代码]

#include <iostream>
using namespace std;

class Circle {
    const double PI = 3.14159; // C++11起支持的类内初始化
    double radius;
public:
    Circle(double r) : radius(r) { }
    double area() const { return PI * radius * radius; }
};

int main() {
    Circle c(5.0);
    cout << "Area: " << c.area() << endl; // 输出: Area: 78.5397
    return 0;
}

关键特性[编辑 | 编辑源代码]

必须在构造函数初始化列表中初始化（C++11前）
C++11起支持类内初始化
所有构造函数都必须初始化常量成员
对象创建后值不可更改

常量成员函数[编辑 | 编辑源代码]

常量成员函数是指被声明为const的成员函数，承诺不修改对象的任何成员变量（mutable成员除外）。

语法[编辑 | 编辑源代码]

returnType functionName(parameters) const;

示例[编辑 | 编辑源代码]

#include <iostream>
#include <string>
using namespace std;

class Person {
    string name;
    int age;
public:
    Person(string n, int a) : name(n), age(a) { }
    string getName() const { return name; }    // 常量成员函数
    void setAge(int a) { age = a; }            // 非常量成员函数
};

int main() {
    const Person p("Alice", 30);
    cout << p.getName() << endl;  // 正确: 常量对象可调用常量成员函数
    // p.setAge(31);              // 错误: 不能通过常量对象调用非常量成员函数
    return 0;
}

关键特性[编辑 | 编辑源代码]

可以访问但不能修改成员变量（除非变量被声明为mutable）
常量对象只能调用常量成员函数
非常量对象可以调用常量成员函数
有助于实现const正确性

mutable成员[编辑 | 编辑源代码]

mutable成员可以在常量成员函数中被修改，适用于那些逻辑上不改变对象状态但需要修改的成员。

示例[编辑 | 编辑源代码]

#include <iostream>
using namespace std;

class Cache {
    mutable int accessCount;  // mutable成员
    double data;
public:
    Cache(double d) : data(d), accessCount(0) { }
    double getData() const { 
        accessCount++;       // 允许修改mutable成员
        return data; 
    }
    int getAccessCount() const { return accessCount; }
};

int main() {
    const Cache c(42.0);
    cout << c.getData() << endl;          // 输出: 42
    cout << "Accesses: " << c.getAccessCount() << endl; // 输出: Accesses: 1
    return 0;
}

常量成员与静态成员的结合[编辑 | 编辑源代码]

可以创建static const成员，它们既是类级别的又是不可修改的。

示例[编辑 | 编辑源代码]

#include <iostream>
using namespace std;

class MathConstants {
public:
    static const double PI;  // 声明
};

const double MathConstants::PI = 3.1415926535; // 定义

int main() {
    cout << MathConstants::PI << endl;  // 输出: 3.14159
    return 0;
}

实际应用场景[编辑 | 编辑源代码]

1. 数学常数：如PI、E等不应被修改的值 2. 配置参数：程序运行期间不变的配置 3. 只读数据：如对象ID、创建时间等 4. 缓存系统：使用mutable成员记录访问次数 5. 线程安全：常量成员函数通常更安全

常量成员函数重载[编辑 | 编辑源代码]

可以同时提供常量版本和非常量版本的成员函数，编译器会根据对象类型选择合适版本。

示例[编辑 | 编辑源代码]

#include <iostream>
using namespace std;

class DataHolder {
    int data;
public:
    DataHolder(int d) : data(d) { }
    int& getData() { return data; }             // 非常量版本
    const int& getData() const { return data; } // 常量版本
};

int main() {
    DataHolder dh1(10);
    const DataHolder dh2(20);
    
    dh1.getData() = 15;    // 调用非常量版本
    // dh2.getData() = 25; // 错误: 不能通过常量对象修改
    
    cout << dh1.getData() << endl; // 输出: 15
    cout << dh2.getData() << endl; // 输出: 20
    return 0;
}