C++：构造函数，析构函数详解

什么是构造函数？

构造函数是在实例化对象时自动调用的一种函数，用于初始化对象的数据成员和其他相关资源。在C++中，构造函数的名称必须与类的名称相同。

C++支持默认构造函数和带参数的构造函数。默认构造函数是没有参数的构造函数，它可以在对象创建时被调用，用于初始化默认值。带参数的构造函数允许像函数一样传递参数列表，用于根据传递的参数初始化对象的数据成员和其他资源。

构造函数的声明方式如下：

class ClassName {
public:
  ClassName(); // 默认构造函数
  ClassName(参数类型 参数1, 参数类型 参数2); // 带参数的构造函数
};

构造函数在以下情况下会被自动调用：
- 创建一个对象时
- 在数组中创建对象时
- 当一个对象是类的成员时

下面是一个示例，展示了如何定义一个简单的类和构造函数：

class Box {
  public:
    Box(); // 默认构造函数
    Box(double l, double w, double h); // 带参数的构造函数
  private:
    double length;
    double width;
    double height;
};

Box::Box() {
  length = 0;
  width = 0;
  height = 0;
}

Box::Box(double l, double w, double h) {
  length = l;
  width = w;
  height = h;
}

什么是析构函数？

析构函数是在对象被销毁时自动调用的一种函数，用于释放对象已分配的资源。与构造函数一样，析构函数的名称必须与类的名称相同，并在名称前加上一个波浪号(~)。

析构函数的声明方式如下：

class ClassName {
public:
  // 构造函数声明

  ~ClassName(); // 析构函数
};

析构函数将释放在构造函数中分配的内存，它在以下情况下自动调用：
- 当对象离开其作用域时
- 当对象通过delete运算符被释放时
- 当对象是类的成员时，且该类的成员被销毁时

下面是一个示例，展示了如何定义一个析构函数来释放所分配的内存：

class MyString {
  public:
    MyString(); // 默认构造函数
    MyString(const char* str); // 带参数的构造函数
    ~MyString(); // 析构函数
  private:
    char* str_ptr;
};

MyString::MyString() {
  str_ptr = new char[1];
  *str_ptr = '\0';
}

MyString::MyString(const char* str) {
  int len = strlen(str);
  str_ptr = new char[len + 1];
  strcpy(str_ptr, str);
}

MyString::~MyString() {
  delete[] str_ptr;
}

总结

在C++中，构造函数和析构函数是用于初始化和清理对象所需的资源的重要函数。构造函数在实例化对象时自动调用，而析构函数则在对象被销毁时自动调用。这两个函数都可带参数，因此可以对对象的数据成员进行初始化，并对其进行清理。通过正确实现这些函数，可以确保C++类正确地工作，并生成可靠的代码。

示例1

下面是一个利用构造函数初始化对象的示例代码：

#include <iostream>
using namespace std;

class Person {
public:
    Person(); // 默认构造函数
    Person(string n, int a, string s); // 带参数的构造函数
    void showInfo();
private:
    string name;
    int age;
    string sex;
};

Person::Person() {
    name = "";
    age = 0;
    sex = "";
}

Person::Person(string n, int a, string s) {
    name = n;
    age = a;
    sex = s;
}

void Person::showInfo() {
    cout << "Name: " << name << endl;
    cout << "Age: " << age << endl;
    cout << "Sex: " << sex << endl;
}

int main() {
    Person p1; // 调用默认构造函数
    p1.showInfo(); // 输出：Name:  Age: 0 Sex:

    Person p2("Tom", 20, "Male"); // 调用带参数的构造函数
    p2.showInfo(); // 输出：Name: Tom Age: 20 Sex: Male

    return 0;
}

示例2

下面是一个利用析构函数释放对象资源的示例代码：

#include <iostream>
#include <string.h>
using namespace std;

class MyString {
public:
    MyString(); // 默认构造函数
    MyString(const char* str); // 带参数的构造函数
    ~MyString(); // 析构函数
    void printStr();
private:
    char* str_ptr;
};

MyString::MyString() {
    str_ptr = new char[1];
    *str_ptr = '\0';
}

MyString::MyString(const char* str) {
    int len = strlen(str);
    str_ptr = new char[len + 1];
    strcpy(str_ptr, str);
}

MyString::~MyString() {
    delete[] str_ptr;
}

void MyString::printStr() {
    cout << "String: " << str_ptr << endl;
}

int main() {
    MyString s1; // 调用默认构造函数
    s1.printStr(); // 输出：String: 

    MyString s2("Hello, World!"); // 调用带参数的构造函数
    s2.printStr(); // 输出：String: Hello, World!

    return 0;
}