【C++】构造与析构函数(超详细解析，小白必看系列）

1 构造函数

1.1构造函数引出

class Date
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Init(2022, 7, 5);
    d1.Print();
    return 0;
}

 对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

 1.2 构造函数特性

构造函数在C++中具有以下几个重要特性：

1. 名称与类名相同：构造函数的名称必须与类名完全相同，并且不能有返回值类型（包括void）。
2. 自动调用：构造函数在对象实例化时自动调用，不需要手动调用。
3. 初始化成员变量：构造函数的主要作用是初始化对象的成员变量。
4. 重载：一个类可以有多个构造函数，只要它们的参数列表不同（即构造函数可以被重载）。
5. 无返回值：构造函数不能有返回值类型。
6. 初始化列表：构造函数可以使用初始化列表来初始化成员变量，特别是当成员变量是常量或引用类型时。

#include <iostream>
using namespace std;

class Point {
public:
    // 默认构造函数
    Point() {
        x = 0;
        y = 0;
        cout << "Default constructor called" << endl;
    }

    // 带参数的构造函数
    Point(int xVal, int yVal) {
        x = xVal;
        y = yVal;
        cout << "Parameterized constructor called" << endl;
    }

    void print() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }

private:
    int x, y;
};

int main() {
    Point p1; // 调用默认构造函数
    Point p2(10, 20); // 调用带参数的构造函数

    p1.print();
    p2.print();

    return 0;
}

在这个例子中，Point类有两个构造函数：一个是默认构造函数，另一个是带参数的构造函数。创建对象p1时调用了默认构造函数，而创建对象p2时调用了带参数的构造函数。

        7.继承中的调用顺序：在继承中，基类的构造函数会在派生类的构造函数之前被调用。

在继承中，基类的构造函数会在派生类的构造函数之前被调用。可以通过初始化列表显式调用基类的构造函数：

class Base {
public:
    Base() {
        cout << "Base constructor called" << endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        cout << "Derived constructor called" << endl;
    }
};

int main() {
    Derived d; // 调用顺序：Base constructor called -> Derived constructor called
    return 0;
}

在这个例子中，创建Derived对象时，首先调用基类Base的构造函数，然后调用派生类Derived的构造函数。

        8.默认构造函数: 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Date {
public:
    /*
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }
    */
    void Print() {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() {
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
    // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    Date d1;
    return 0;
}

解释

• 默认构造函数的生成：

  • 当Date类中没有显式定义任何构造函数时，编译器会自动生成一个无参的默认构造函数。因此，Date d1;可以正常编译和运行。

• 显式定义构造函数：

  • 如果你显式定义了一个带参数的构造函数（如代码中的注释部分），编译器将不再生成无参的默认构造函数。
  • 这意味着，如果你尝试创建一个没有参数的对象（如Date d1;），编译器会报错，因为没有可用的无参构造函数。

        9.默认构造函数类型: 在C++中，默认构造函数可以分为以下几种类型：

• 无参构造函数：没有参数的构造函数。
• 全缺省构造函数：所有参数都有默认值的构造函数。
• 编译器生成的默认构造函数：当类中没有显式定义任何构造函数时，编译器自动生成的无参构造函数。

这些构造函数都可以被称为默认构造函数，并且一个类只能有一个默认构造函数。

示例代码

#include <iostream>
using namespace std;

class Example {
public:
    // 无参构造函数
    //Example() {
    //    cout << "Default constructor called" << endl;
    //}

    // 全缺省构造函数
    Example(int val = 0) {
        value = val;
        cout << "Defaulted parameter constructor called" << endl;
    }

    void print() {
        cout << "Value: " << value << endl;
    }

private:
    int value;
};

int main() {
    //Example e1; // 调用无参构造函数
    Example e2(10); // 调用带参数的构造函数

    e1.print();
    e2.print();

    return 0;
}

在这个例子中，Example类有两个构造函数：一个是无参构造函数，另一个是全缺省构造函数。无论是无参构造函数还是全缺省构造函数，都可以被称为默认构造函数。

注意事项

• 只能有一个默认构造函数：一个类中只能有一个默认构造函数。如果你定义了多个构造函数，其中一个是无参构造函数，另一个是全缺省构造函数，编译器会报错。
• 编译器生成的默认构造函数：如果你没有显式定义任何构造函数，编译器会自动生成一个无参的默认构造函数。

2 析构函数

2.1 析构函数概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

2.2 析构函数特性

析构函数（destructor）是C++中的一种特殊成员函数，用于在对象的生命周期结束时执行清理工作。以下是析构函数的一些关键概念：

1. 名称与类名相同：析构函数的名称与类名相同，但在前面加上波浪符号（~），例如~ClassName()。
2. 无参数和无返回值：析构函数不能有参数，也没有返回值类型（包括void）。
3. 自动调用：当对象的生命周期结束时，例如对象所在的作用域结束或对象被显式删除时，析构函数会被自动调用。
4. 唯一性：每个类只能有一个析构函数，不能重载。
5. 清理资源：析构函数通常用于释放对象在其生命周期内分配的资源，例如动态分配的内存、打开的文件句柄等。

示例代码

#include <iostream>
using namespace std;

class Example {
public:
    // 构造函数
    Example() {
        cout << "Constructor called" << endl;
        data = new int[10]; // 动态分配内存
    }

    // 析构函数
    ~Example() {
        cout << "Destructor called" << endl;
        delete[] data; // 释放动态分配的内存
    }

private:
    int* data;
};

int main() {
    Example ex; // 创建对象，调用构造函数
    // 对象生命周期结束时，自动调用析构函数
    return 0;
}

在这个例子中，Example类有一个构造函数和一个析构函数。构造函数在对象创建时被调用，用于动态分配内存。析构函数在对象生命周期结束时被调用，用于释放动态分配的内存。

析构函数的作用

• 释放资源：析构函数主要用于释放对象在其生命周期内分配的资源，例如动态内存、文件句柄等。
• 清理操作：可以在析构函数中执行一些清理操作，例如关闭文件、断开网络连接等。

注意事项

• 显式调用：虽然析构函数通常是自动调用的，但在某些情况下也可以显式调用析构函数，例如obj.~ClassName()，但这种做法很少见且不推荐。
• 虚析构函数：在使用继承时，如果基类的析构函数是虚函数（virtual），可以确保派生类对象被正确销毁。