C++ 构造函数最佳实践

C++ 中，构造函数是类的初始化方法，构造的主要目的是为对象分配资源并设置初始状态。在设计和使用构造函数时，最佳实践可以使得代码更健壮、清晰且高效。

本篇文章 即 C++ 构造函数最佳实践。

1. 构造函数应该做什么

1.1 初始化成员变量

构造函数的首要职责是确保对象的所有成员变量都被正确初始化。C++ 提供了构造函数初始化列表，应该优先使用这种方式来初始化成员，而不是在构造函数体中赋值。这是因为初始化列表可以直接调用成员的构造函数，而赋值则会先调用默认构造函数，然后进行赋值，可能会导致额外的性能开销。

示例：

class MyClass {
private:int x;std::string name;
public:// 使用初始化列表进行成员初始化MyClass(int a, const std::string& n) : x(a), name(n) {}
};

1.2 分配资源

构造函数的另一个主要职责是为对象动态分配资源，如动态内存、文件句柄等。在分配资源时，确保使用适当的资源管理机制（如智能指针）来防止资源泄漏。

示例：

class MyClass {
private:std::unique_ptr<int> data;
public:MyClass(int value) : data(std::make_unique<int>(value)) {}  // 使用智能指针管理资源
};

1.3 遵循 RAII 原则

C++ 的资源管理通常基于RAII（Resource Acquisition Is Initialization，资源获取即初始化）原则。构造函数应该负责资源的获取，而析构函数则负责释放资源。通过遵循这一原则，构造函数能够确保对象在其生命周期内持有有效的资源。

示例：

class FileHandler {
private:std::fstream file;
public:FileHandler(const std::string& filename) : file(filename) {if (!file.is_open()) {throw std::runtime_error("Failed to open file");}}~FileHandler() {file.close();  // 析构函数负责资源释放}
};

1.4 处理异常情况

如果构造函数中可能会遇到无法继续初始化的情况（如分配资源失败），应该在构造函数中抛出异常，确保对象不会处于部分初始化状态。一般情况下，构造函数要么成功创建一个有效的对象，要么抛出异常，表明对象创建失败。

示例：

class MyClass {
public:MyClass(int value) {if (value < 0) {throw std::invalid_argument("Negative value is not allowed");}}
};

2. 构造函数不应该做什么

2.1 避免做大量的工作

构造函数的职责是初始化对象，而不是执行复杂的逻辑。构造函数不应该执行大量计算、网络调用、文件操作等繁重任务。如果需要做这些工作，应该将它们放在单独的初始化函数或惰性加载机制中，以避免构造函数的复杂化。

错误示例：

class MyClass {
public:MyClass() {// 错误：构造函数中进行大量计算for (int i = 0; i < 1000000; ++i) {// 复杂计算}}
};

改进：

class MyClass {
public:MyClass() {// 构造函数尽量简单}void initData() {for (int i = 0; i < 1000000; ++i) {// 将复杂逻辑移出构造函数}}
};

2.2 不要在构造函数中调用虚函数

在构造函数中调用虚函数会导致意外行为，因为在构造函数执行期间，派生类的部分还没有被构造，虚函数的多态性机制还没有完全生效。因此，在构造函数中调用虚函数时，实际上调用的是当前类的版本，而不是派生类中的重写版本。

对象构造遵循从基类到派生类的顺序：
①首先调用基类的构造函数，完成基类部分的初始化。
②然后调用派生类的构造函数，完成派生类部分的初始化。

派生类还没有构造完成，先构造了基类，虚函数指针指向基类函数地址，调用执行后调用的就是基类的函数了。
错误示例：

#include <iostream>class Base {
public:Base() {std::cout << "Base constructor called" << std::endl;print();  // 在构造函数中调用虚函数}virtual void print() const {std::cout << "Base::print" << std::endl;}
};class Derived : public Base {
private:int value;
public:Derived(int v) : value(v) {std::cout << "Derived constructor called" << std::endl;}virtual void print() const override {std::cout << "Derived::print, value = " << value << std::endl;}
};int main() {Derived d(10);return 0;
}

编译运行：

[jn@jn build]$ ./a.out
Base constructor called
Base::print
Derived constructor called
[jn@jn build]$ 

改进：

• 在构造函数中避免使用虚函数。如果需要在对象创建后调用某些逻辑，考虑将其放在专门的初始化函数中或工厂函数中。

2.3 避免在构造函数中执行复杂的初始化逻辑

构造函数应该尽量保持简洁，不应该执行过多的复杂逻辑或初始化。复杂的初始化可以通过专门的初始化函数来实现，特别是在需要初始化多个资源或对象的情况下。

错误示例：

class MyClass {
public:MyClass() {// 错误：构造函数中执行复杂初始化逻辑initializeResources();setupConnections();}private:void initializeResources() {// 复杂资源初始化}void setupConnections() {// 网络或数据库连接初始化}
};

改进：

class MyClass {
public:MyClass() {// 构造函数尽量简单}void initialize() {initializeResources();setupConnections();}private:void initializeResources() {// 复杂资源初始化}void setupConnections() {// 网络或数据库连接初始化}
};

2.4 避免调用可能抛出异常的代码

在构造函数中，如果发生异常，可能会导致对象处于部分初始化状态。虽然 C++ 会在构造函数抛出异常时自动调用析构函数来清理已分配的资源，但避免在构造函数中进行可能抛出异常的操作仍是一个好的实践。如果确实需要处理异常，最好将复杂逻辑放在其他成员函数中。

错误示例：

class MyClass {
public:MyClass() {// 错误：构造函数中调用可能抛出异常的操作performRiskyOperation();}private:void performRiskyOperation() {throw std::runtime_error("Operation failed");}
};

改进：

class MyClass {
public:MyClass() {// 构造函数保持简单}void initialize() {try {performRiskyOperation();} catch (const std::exception& e) {std::cerr << "Error: " << e.what() << std::endl;}}private:void performRiskyOperation() {throw std::runtime_error("Operation failed");}
};

3. 构造函数的其他最佳实践

3.1 使用explicit防止隐式转换

构造函数在某些情况下可能会被用作隐式转换函数，导致意外的行为。为了避免这种情况，使用 explicit 关键字显式禁止构造函数的隐式转换。

示例：

class MyClass {
public:explicit MyClass(int value) {// 禁止隐式转换}
};MyClass obj = 10;  // 错误：隐式转换被 explicit 禁止

3.2 尽量避免在构造函数中使用new

尽量避免在构造函数中直接使用 new 分配动态内存，而是使用智能指针（如 std::unique_ptr 或 std::shared_ptr）来管理资源，避免内存泄漏。

错误示例：

class MyClass {
private:int* data;
public:MyClass() {data = new int[100];  // 错误：直接使用 new 分配内存}~MyClass() {delete[] data;}
};

改进：

class MyClass {
private:std::unique_ptr<int[]> data;  // 使用智能指针管理内存
public:MyClass() : data(std::make_unique<int[]>(100)) {}
};

3.3 考虑使用委托构造函数

C++11 引入了委托构造函数的概念，可以减少代码重复，避免在多个构造函数中进行相同的初始化操作。

示例：

class MyClass {
private:int x;std::string name;
public:MyClass(int a) : MyClass(a, "Default") {}  // 委托给另一个构造函数MyClass(int a, const std::string& n) : x(a), name(n) {}
};

4. 总结

构造函数应该做：

1. 初始化成员变量，尤其是通过初始化列表（注意初始化顺序问题）。
2. 分配资源，如动态内存、文件句柄等，并遵循 RAII 原则。
3. 处理异常情况，在无法初始化时抛出异常，避免部分初始化对象。

构造函数不应该做：

1. 不要做大量工作，如复杂的计算或 I/O 操作。
2. 不要调用虚函数，因为在构造期间虚函数的多态性机制尚未生效。
3. 避免复杂的初始化逻辑，这些逻辑可以放在单独的函数中。
4. 避免调用可能抛出异常的代码，并确保异常得到适当处理。