C++(构造和析构)

目录

1. 构造函数

1.1 概念

1.2 构造函数的分类

1.2.1 默认构造函数

1.2.2 带参数的构造函数

1.2.3 拷贝构造函数

1.2.4 移动构造函数

2. 析构函数

2.1 概念

3. 每期一问

3.1 上期答案

---

1. 构造函数

1.1 概念

在C++中，构造函数（Constructor）是一种特殊的成员函数，用于初始化对象的新实例。构造函数的名称与类的名称相同，并且没有返回类型（包括void）。当创建一个类的新对象时，构造函数被自动调用，以确保对象在被使用之前具有适当的初始状态。

构造函数的主要目的是：

1. 初始化对象的数据成员： 构造函数负责设置对象的初始状态，将数据成员初始化为适当的值。

2. 分配资源（如果需要）： 如果对象需要动态分配内存或者需要执行其他资源分配操作，构造函数可以在对象创建时进行。

3. 执行其他初始化操作： 构造函数可以执行其他与对象相关的初始化操作，如打开文件、建立网络连接等。

构造函数可以有多个重载版本，这意味着可以根据不同的参数列表来调用不同的构造函数。当没有定义构造函数时，编译器会提供一个默认构造函数，它会执行默认的初始化操作（如默认初始化或者零初始化）。需要注意的是：编译器提供的默认构造函数只会初始化非内置类型（如int，char等）。

示例：

class Example {
public:
	//构造函数的名称必须和类名相同，且没有返回值
	//构造函数我们使用全缺省参数
	//当我们不提供构造函数的时候，编译器会提供一个默认构造函数，自动调用非内置类型的
    //默认构造函数
	//注：编译器不对内置类型进行初始化操作
	Example(int year = 1, int month = 1, int day = 1)
	{
	    cout << "已调用Example" << endl;
		_year = year;
		_month = month;
		_day = day;
	}

	void prin()
	{
		 cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{

	Example E;
	E.prin();

}

执行结果如下：

1.2 构造函数的分类

构造函数是一种特殊的函数，它在创建对象时被自动调用。构造函数可以用来初始化对象的成员变量，确保对象在创建时拥有合适的状态。下面是构造函数的分类以及调用方式：

1.默认构造函数： 默认构造函数是没有参数的构造函数，如果没有定义任何构造函数，则编译器会自动生成一个默认构造函数。默认构造函数的调用方式是直接使用类名创建对象即可。

2.带参数的构造函数： 带参数的构造函数是可以接受参数的构造函数，可以通过它来初始化对象的成员变量。带参数的构造函数可以有多个不同的版本，每个版本可以接受不同类型和数量的参数。带参数的构造函数的调用方式是在创建对象时传入相应的参数。

3.拷贝构造函数： 拷贝构造函数是用于复制一个对象的构造函数，它接受一个同类型的对象作为参数，并且会创建一个新的对象，该对象的成员变量与参数对象相同。拷贝构造函数的调用方式是在创建新对象时，将现有对象作为参数传递给它。

4.移动构造函数： 移动构造函数是C++11新增的一种构造函数，它接受一个右值引用作为参数，并且将其内部状态移动到新创建的对象中。移动构造函数通常比拷贝构造函数更高效。移动构造函数的调用方式是在创建新对象时，将一个右值对象作为参数传递给它。

1.2.1 默认构造函数

综上所述，我们了解默认构造函数，那我们接下来就见见面吧。

class Example {
public:	
//首先在这里定义了一个默认构造函数
	Example()
	{
		//将_year，_month，_day都初始化为1
		cout << "已调用Example" << endl;
		_year = 1;
		_month = 1;
		_day = 1;
	}
	void prin()
	{
		 cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//创建实例
	Example E;
	//调用函数
	E.prin();

}

运行结果：

默认构造函数，我们无法指定初始值。那可不可以指定初始值呢，答案是可以的。

1.2.2 带参数的构造函数

class Example {
public:	
    Example(int year, int month, int day)
	{
		//将_year，_month，_day都初始化
		cout << "已调用Example" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	void prin()
	{
		 cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//创建实例
	//掉用方式可以直接在创建实例的时候传参，编译器会自动调用。
	Example E(2024,6,4);
	//调用函数
	E.prin();

}

运行结果：

那么，有没有更好的呢，如果我们将之前学习的全缺省参数结合起来，你就会得到一个可传参也可不传参的构造函数。注：刚开始其实已经提到过了。

class Example {
public:
	//全缺省的构造函数
	Example(int year = 1, int month = 1, int day = 1)
	{
		cout << "已调用Example" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	void prin()
	{
		 cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//创建实例
	//掉用方式可以直接在创建实例的时候传参，编译器会自动调用。
	Example E(2024,6,4);
	//调用函数
	E.prin();
	Example E1;
	E1.prin();
}

运行结果：

注：当我们提供构造函数的时候，编译器不会生成默认构造函数。

1.2.3 拷贝构造函数

#include <iostream>
using namespace std;

class MyClass {
   public:
      int x;
      MyClass(int val) : x(val) {}  // 普通构造函数
      MyClass(const MyClass &obj) {  // 拷贝构造函数
         x = obj.x;
         cout << "调用了拷贝构造函数，复制的值为：" << obj.x << endl;
      }
};

int main() {
   MyClass obj1(10);   // 调用普通构造函数
   MyClass obj2 = obj1; // 调用拷贝构造函数
   cout << "obj2 的值为：" << obj2.x << endl;
   return 0;
}

上述代码中，我们定义了一个 MyClass 类，并在其中定义了一个普通构造函数和一个拷贝构造函数。在 main() 函数中，我们首先使用普通构造函数创建了一个对象 obj1，然后使用拷贝构造函数将 obj1 的值复制给了 obj2。在这个过程中，程序会自动调用拷贝构造函数，并输出一条提示信息。

运行结果：

1.2.4 移动构造函数

移动构造函数是C++11中引入的一种特殊构造函数，用于在对象之间进行资源转移，提高程序的效率。移动构造函数可以将一个右值引用参数的资源所有权转移到一个新对象中，而不是像拷贝构造函数那样进行资源的拷贝。这在处理大量数据时尤为重要，因为资源拷贝会带来较大的开销。

class MyObject {
public:
    MyObject() { // 构造函数
        m_data = new int[1000];
        // 分配大量内存
    }
    MyObject(MyObject&& other) { // 移动构造函数
        m_data = other.m_data; // 转移资源所有权
        other.m_data = nullptr; // 清空原有资源指针
    }
    ~MyObject() { // 析构函数
        delete[] m_data;
        // 释放资源
    }
private:
    int* m_data;
};

int main() {
    MyObject obj1; // 构造对象1
    MyObject obj2(std::move(obj1)); // 移动构造对象2
    // obj1 现在已经失去了对 m_data 的所有权
    return 0;
}

在上面的代码中，我们定义了一个 MyObject 类，并实现了一个移动构造函数。在 main 函数中，我们首先通过默认的构造函数构造了一个对象 obj1，然后使用 std::move 将其转换为右值引用并传递给另一个对象 obj2 的移动构造函数中。在这个过程中，obj1 失去了对 m_data 指针所指向内存的所有权，而 obj2 获得了这个所有权。

2. 析构函数

2.1 概念

析构函数是用于在对象被删除之前的清理工作，在对象生命周期即将结束时被自动调用。(析构函数可以清理对象并且释放内存)
析构函数 ~加上类名() 进行操作，目的时清空数据，释放内存。
下面举一个示例：

#include <iostream>

class MyClass {
private:
	int* data;

public:
	MyClass() {
		data = new int[10];
		std::cout << "已调用Constructor" << std::endl;
	}

	~MyClass() {
		delete[] data;
		std::cout << "已调用Destructor" << std::endl;
	}
};

int main() {
	MyClass obj; // 创建一个 MyClass 对象

	// 在 main 函数结束时，obj 对象超出作用域，触发析构函数的调用
	return 0;
}

运行结果：

3. 每期一问

3.1 上期答案

struct Node* copyRandomList(struct Node* head) {
    if(!head)
    {
        return head;
    }
	struct Node* cur = head;
    //1.申请节点copy插入cur后面
    while(cur)
    {
        struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;
        struct Node* next = cur->next;
        cur->next = copy;
        copy->next = next;
        cur = next;
    }
    //2.copy中random的指针的值指向cur->next->random
    cur = head;
    while(cur)
    {
        struct Node* copy = cur->next;
        if(NULL == cur->random)
        {
            copy->random = NULL;
        }
        else
        {
            copy->random = cur->random->next;
        }
        cur = copy->next;
    }
    //3.分割拷贝链表，还原原链表
    struct Node* copyTail = NULL, *copyHead = NULL;
    cur = head;
    while(cur)
    {
        if(!copyHead && !copyTail)
        {
            copyHead = copyTail = cur->next;
        }
        else{
            copyTail->next = cur->next;
            copyTail = copyTail->next;
        }
        cur->next = copyTail->next;
        cur = cur->next;
    }
    copyTail->next = NULL;
    return copyHead;
}

本期问题：. - 力扣（LeetCode）

注：本期到这里就结束了，后面还会说到移动构造函数。