编辑“︁C++ 常量成员”︁

= C++常量成员 =

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

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

=== 语法 ===
<syntaxhighlight lang="cpp">
class ClassName {
    const dataType constMember;
public:
    ClassName(parameters) : constMember(initialValue) { } // 必须通过初始化列表初始化
};
</syntaxhighlight>

=== 示例 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

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

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

=== 语法 ===
<syntaxhighlight lang="cpp">
returnType functionName(parameters) const;
</syntaxhighlight>

=== 示例 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

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

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

=== 示例 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

== 常量成员与静态成员的结合 ==
可以创建<code>static const</code>成员，它们既是类级别的又是不可修改的。

=== 示例 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

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

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

=== 示例 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

== 最佳实践 ==
1. 尽可能将不修改对象状态的成员函数声明为const
2. 对于不应修改的成员变量使用const
3. 谨慎使用mutable，确保它不会破坏逻辑常量性
4. 优先使用const引用传递对象以避免不必要的拷贝
5. 在重载运算符时提供const版本

== 常见误区 ==
1. 忘记初始化const成员变量
2. 在常量成员函数中尝试修改非mutable成员
3. 认为const成员函数不能调用任何非常量成员函数
4. 忽略const正确性导致编译错误
5. 混淆顶层const和底层const

== 性能考虑 ==
常量成员通常不会带来性能开销，反而可能帮助编译器优化：
* const成员变量可能被放入只读内存段
* const成员函数更容易被内联
* 更好的类型安全性可以减少运行时检查

通过合理使用常量成员，可以提高代码的安全性、可读性和可维护性，是C++编程中重要的最佳实践之一。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 面向对象基础]]