当前位置：首页 > article >正文

C++ 构造函数最佳实践

article 2024/11/15 23:33:53

文章目录

- - 1. 构造函数应该做什么
  - - 1.1 初始化成员变量
    - 1.2 分配资源
    - 1.3 遵循 RAII 原则
    - 1.4 处理异常情况
  - 2. 构造函数不应该做什么
  - - 2.1 避免做大量的工作
    - 2.2 不要在构造函数中调用虚函数
    - 2.3 避免在构造函数中执行复杂的初始化逻辑
    - 2.4 避免调用可能抛出异常的代码
  - 3. 构造函数的其他最佳实践
  - - 3.1 使用`explicit`防止隐式转换
    - 3.2 尽量避免在构造函数中使用`new`
    - 3.3 考虑使用委托构造函数
  - 4. 总结
  - - 构造函数应该做：
    - 构造函数不应该做：

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) {}
};