C++ 构造函数与析构函数：对象生命周期的守护者-CSDN博客

本文链接：https://blog.csdn.net/vvilkim/article/details/147655381

在C++编程中，对象的创建与销毁是程序运行的基础。构造函数和析构函数作为类的特殊成员函数，分别负责对象的初始化和清理工作。理解它们的原理和使用方法，是掌握C++面向对象编程的关键。本文将深入探讨构造函数和析构函数的各个方面，包括基本概念、使用方法、最佳实践以及常见陷阱。

一、构造函数的基本概念

构造函数是一种特殊的成员函数，它在创建类对象时自动调用。它的主要职责是初始化对象的状态，确保对象在创建后处于有效且可用的状态。

1.1 构造函数的特性

构造函数具有以下显著特征：

命名与类名完全相同：这是识别构造函数的最明显标志
没有返回类型：甚至不需要void关键字
自动调用：当对象创建时由编译器自动调用
可以重载：一个类可以有多个不同参数的构造函数
访问控制：可以是public、protected或private，影响对象的创建方式

1.2 构造函数的分类

C++中的构造函数可以分为以下几类：

默认构造函数：无参或所有参数都有默认值的构造函数
参数化构造函数：接受一个或多个参数的构造函数
拷贝构造函数：接受同类型对象引用的构造函数
移动构造函数（C++11）：接受同类型右值引用的构造函数
委托构造函数（C++11）：调用同类其他构造函数的构造函数

1.3 构造函数的定义与使用

class Book {
public:
    // 默认构造函数
    Book() : title("Untitled"), pages(0), price(0.0) {}
    
    // 参数化构造函数
    Book(const std::string& t, int p, double pr) 
        : title(t), pages(p), price(pr) {}
    
    // 拷贝构造函数
    Book(const Book& other) 
        : title(other.title), pages(other.pages), price(other.price) {}
    
    // 移动构造函数（C++11）
    Book(Book&& other) noexcept 
        : title(std::move(other.title)), pages(other.pages), price(other.price) {
        other.pages = 0;
        other.price = 0.0;
    }
    
private:
    std::string title;
    int pages;
    double price;
};

二、构造函数的高级特性

2.1 构造函数初始化列表

构造函数初始化列表是初始化类成员的高效方式，它出现在构造函数参数列表之后，函数体之前，以冒号开头。

为什么使用初始化列表？

性能优势：避免先默认初始化再赋值的开销
必要性：对于const成员、引用成员和没有默认构造函数的类成员，必须使用初始化列表
顺序一致性：成员初始化的顺序由它们在类中的声明顺序决定，而非初始化列表中的顺序

class Student {
public:
    Student(int id, const std::string& name) 
        : studentId(id), studentName(name), coursesTaken(0) {
        // 构造函数体
    }
    
private:
    const int studentId;  // const成员必须用初始化列表
    std::string studentName;
    int coursesTaken;
};

2.2 委托构造函数（C++11）

委托构造函数允许一个构造函数调用同类中的另一个构造函数，避免了代码重复。

class Rectangle {
public:
    // 委托构造函数
    Rectangle() : Rectangle(1, 1) {}  // 委托给下面的构造函数
    
    Rectangle(int w, int h) : width(w), height(h) {
        if (width <= 0 || height <= 0) {
            throw std::invalid_argument("Dimensions must be positive");
        }
    }
    
private:
    int width;
    int height;
};

2.3 explicit关键字

explicit关键字用于防止构造函数的隐式转换，避免意外的类型转换。

class MyString {
public:
    explicit MyString(int size) { /*...*/ }  // 禁止隐式转换
};

void func(const MyString&);
func(10);  // 错误：不能隐式转换
func(MyString(10));  // 正确：显式构造

三、析构函数详解

析构函数是另一个特殊成员函数，它在对象生命周期结束时自动调用，负责清理工作。

3.1 析构函数的特性

命名：类名前加~符号
无返回类型：与构造函数相同
无参数：不能重载，每个类只有一个析构函数
自动调用：当对象离开作用域或被delete时调用
虚析构函数：基类析构函数通常应为virtual

3.2 析构函数的定义与使用

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& connStr) {
        // 建立数据库连接
        connection = openDatabase(connStr);
    }
    
    ~DatabaseConnection() {
        if (connection != nullptr) {
            closeDatabase(connection);  // 确保连接被关闭
            connection = nullptr;
        }
    }
    
private:
    DatabaseHandle* connection;
};

3.3 虚析构函数的重要性

当类可能被继承时，基类析构函数必须声明为virtual，以确保通过基类指针删除派生类对象时，能够正确调用派生类的析构函数。

class Base {
public:
    virtual ~Base() { std::cout << "Base destructor\n"; }
};

class Derived : public Base {
public:
    ~Derived() override { std::cout << "Derived destructor\n"; }
};

Base* ptr = new Derived();
delete ptr;  // 正确调用Derived和Base的析构函数

如果不声明为virtual，则只会调用Base的析构函数，可能导致资源泄漏。

四、构造函数与析构函数的调用时机

4.1 构造函数的调用时机

构造函数在以下情况被调用：

显式创建对象：MyClass obj;
动态分配对象：new MyClass()
临时对象：func(MyClass())
成员对象：包含在另一个类中的对象
继承中的基类：派生类构造时先构造基类

4.2 析构函数的调用时机

析构函数在以下情况被调用：

局部对象离开作用域
delete动态分配的对象
临时对象生命周期结束
程序结束时全局/静态对象
抛出异常时栈展开

五、RAII原则

RAII（Resource Acquisition Is Initialization）是C++的核心编程理念，它将资源管理与对象生命周期绑定：

资源获取：在构造函数中获取资源（内存、文件句柄、锁等）
资源释放：在析构函数中释放资源
异常安全：即使发生异常，析构函数也会被调用，确保资源释放

class FileHandler {
public:
    explicit FileHandler(const std::string& filename) 
        : file(fopen(filename.c_str(), "r")) {
        if (!file) throw std::runtime_error("File open failed");
    }
    
    ~FileHandler() {
        if (file) fclose(file);
    }
    
    // 禁用拷贝（或实现深拷贝）
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
    
private:
    FILE* file;
};

六、三/五法则

随着C++11的引入，三法则扩展为五法则，指导我们何时需要自定义特殊成员函数：

五法则：如果类需要显式定义以下任一函数，则通常需要显式定义全部五个函数：

析构函数
拷贝构造函数
拷贝赋值运算符
移动构造函数（C++11）
移动赋值运算符（C++11）

class ResourceHolder {
public:
    // 构造函数
    ResourceHolder(size_t size) : data(new int[size]), size(size) {}
    
    // 1. 析构函数
    ~ResourceHolder() { delete[] data; }
    
    // 2. 拷贝构造函数
    ResourceHolder(const ResourceHolder& other) 
        : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + other.size, data);
    }
    
    // 3. 拷贝赋值运算符
    ResourceHolder& operator=(const ResourceHolder& other) {
        if (this != &other) {
            delete[] data;
            data = new int[other.size];
            size = other.size;
            std::copy(other.data, other.data + other.size, data);
        }
        return *this;
    }
    
    // 4. 移动构造函数
    ResourceHolder(ResourceHolder&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    
    // 5. 移动赋值运算符
    ResourceHolder& operator=(ResourceHolder&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    
private:
    int* data;
    size_t size;
};

七、常见陷阱与最佳实践

7.1 常见陷阱

忘记释放资源：析构函数中遗漏资源释放
虚析构函数缺失：多态基类未声明虚析构函数
异常抛出：构造函数中抛出异常可能导致资源泄漏
初始化顺序问题：成员初始化顺序与声明顺序不一致
自赋值问题：拷贝赋值运算符未处理自赋值情况

7.2 最佳实践

遵循RAII：将资源管理与对象生命周期绑定
使用智能指针：减少原始指针的使用
=default和=delete（C++11）：明确表达意图
noexcept移动操作：标记不会抛出异常的移动操作
防御性编程：检查资源是否成功获取

八、现代C++中的改进（C++11/14/17/20）

8.1 默认和删除函数

class ModernClass {
public:
    ModernClass() = default;  // 显式默认
    ~ModernClass() = default;
    ModernClass(const ModernClass&) = delete;  // 禁止拷贝
    ModernClass& operator=(const ModernClass&) = delete;
};

8.2 继承构造函数（C++11）

class Base {
public:
    Base(int value) { /*...*/ }
};

class Derived : public Base {
public:
    using Base::Base;  // 继承Base的构造函数
};

8.3 基于范围的for循环与构造函数

for (auto&& item : collection) {
    // 可能调用移动构造函数
}

结语

构造函数和析构函数是C++对象生命周期的基石，理解它们的原理和正确使用方法对于编写健壮、高效的C++代码至关重要。通过遵循RAII原则、五法则和现代C++的最佳实践，可以避免资源泄漏和其他常见问题，构建更加可靠的软件系统。

掌握这些概念不仅有助于日常编程，也是理解C++标准库和现代框架设计的基础。随着C++标准的演进，构造函数和析构函数的用法也在不断发展，值得持续关注和学习。