不返回引用或指针的 setter 方法：使用调用链编程（setter 方法返回当前对象引用）；使用 const 对象调用可修改方法：不要对 const 对象调用可修改方法，如果需要修改状态，使用 mutable 关键字；在构造函数中抛出异常：使用 try-catch 块处理异常，构造函数失败时手动释放资源；默认初始化 member 函数指针：显式初始化 member 函数指针或在类定义中使用 extern 关键字；在析构函数中访问非 const 成员：仅访问 const 成员，如果需要修改状态，显式调用 const_cast。
C++ 类方法的常见陷阱和规避方法
引入
在使用 C++ 类方法时，可能会遇到一些常见的陷阱。了解这些陷阱并采用适当的规避方法至关重要，以确保代码的正确性和效率。本文将探讨常见的类方法陷阱及其对应的规避方法。
陷阱 1：不返回引用或指针的 setter 方法
立即学习“C++免费学习笔记（深入）”；
问题：
- setter 方法修改对象的私有数据，但不会通知调用者。
- 导致调用者不知道对象的实际状态，可能产生意外行为。
规避方法：
- 让 setter 方法返回当前对象引用（调用链编程）。
class MyObject {
public:
MyObject& setValue(int value) {
this->value = value;
return *this;
}
private:
int value;
};
int main() {
MyObject obj;
obj.setValue(10).setValue(20); // 调用链编程
}陷阱 2：使用 const 对象调用可修改方法
问题：
- 尝试修改 const 对象的内部状态。
- 编译器会发出错误，因为 const 对象不允许修改。
规避方法：
- 不要对 const 对象调用可修改方法。
- 如果需要修改状态，使用 mutable 关键字。
class MyObject {
public:
void setValue(int value) { value_= value; }
private:
mutable int value_; // 允许修改
};
int main() {
const MyObject obj;
// 编译错误：无法修改 const 对象的内部状态
// obj.setValue(10);
}陷阱 3：在构造函数中抛出异常
问题：
- 构造函数执行失败时抛出异常可能会导致资源泄漏。
- 因为析构函数不会执行，对象拥有的资源无法释放。
规避方法：
- 在构造函数中使用 try-catch 块处理异常。
- 如果构造函数失败，手动释放资源。
class MyObject {
public:
MyObject() {
try {
// 构造代码
} catch (...) {
// 释放已分配的资源
delete[] buffer;
throw;
}
}
private:
int* buffer;
};陷阱 4：默认初始化 member 函数指针
问题：
- 当 member 函数指针未显式初始化时，编译器会将其初始化为 nullptr。
- 导致调用未定义的行为。
规避方法：
- 在构造函数或初始化列表中显式初始化 member 函数指针。
- 在 member 函数指针的类定义中使用 extern 关键字。
class MyObject {
public:
MyObject() : callback(&MyObject::defaultCallback) {}
private:
void defaultCallback() {}
void* callback;
};陷阱 5：在析构函数中访问非 const 成员
问题：
- 析构函数中非 const 成员的修改可能会导致未定义的行为。
- 因为析构函数执行顺序不确定，导致程序崩溃。
规避方法：
- 仅在析构函数中访问 const 成员。
- 如果需要修改状态，在析构函数开始时显式调用 const_cast。
class MyObject {
public:
~MyObject() {
const_cast<int&>(value_) = 0; // 安全地修改 const int
}
private:
int value_;
};实战案例
在以下代码中，避免了上述陷阱：
class MyMath {
public:
MyMath& add(int value) {
sum_ += value;
return *this;
}
void print() {
std::cout << sum_ << std::endl;
}
private:
mutable int sum_ = 0;
};
int main() {
MyMath math;
math.add(10).add(20);
math.print(); // 输出 30
}这个例子中：
- 使用调用链编程规避了陷阱 1。
- 使用了 mutable 规避了陷阱 2。
- 构造函数中没有异常，因此规避了陷阱 3。
- 明确初始化了 member 函数指针，规避了陷阱 4。
- 析构函数中只访问了 const 成员，规避了陷阱 5。
