[C++]构造与毁灭：深入探讨C++中四种构造函数与析构函数

旧城等待， 2024-04-24 20:32 1阅读 0赞

>  *  个人主页：[北·海][Link 1]
>  *  🎐CSDN新晋作者
>  *  🎉欢迎 👍点赞✍评论⭐收藏
>  *  ✨收录专栏：[C/C++][C_C]
>  *  🤝希望作者的文章能对你有所帮助，有不足的地方请在评论区留言指正，大家一起学习交流！🤗

--------------------

**目录**

构造函数有什么作用?

构造函数有什么特点

构造函数的种类

一.默认构造函数

1.什么是默认构造函数

2.默认构造函数的应用

使用情况一:类内初始值

使用情况二:创建对象数组

使用情况三:在派生类中

自定义的默认构造函数

二.自定义的重载构造函数

1.构造函数的作用

三.拷贝构造函数

1.浅拷贝

2.深拷贝

3.什么时候用到深拷贝/浅拷贝

4.什么时候会调用拷贝构造函数

四.赋值构造函数

1.赋值构造函数可以怎么样定义

2.赋值构造函数在什么时候会调用?

2.赋值构造函数与拷贝构造函数的区别

五.析构函数

1.析构函数的基本概念

2.容易将调用析构函数与delete释放内存混淆

--------------------

>  **概要:**
> 
> "构造与毁灭，是C++中对象生命周期的两个重要阶段。构造函数用于初始化对象的状态和数据成员，为对象提供合适的初始值；而析构函数则在对象销毁时执行清理工作，释放资源，确保对象的安全结束。通过合理设计构造函数和析构函数，我们能够在对象的创建和销毁过程中维护良好的程序行为和资源管理。

--------------------

> ## 构造函数有什么作用? ##
> 
> 在创建一个新的对象时，自动调用的函数，用来进行“初始化”工作：对这个对象内部的数据成员进行初始化
> 
> ## 构造函数有什么特点 ##
> 
> 1.  自动调用（在创建新对象时，自动调用）
> 2.  构造函数的函数名，和类名相同
> 3.  构造函数没有返回类型
> 4.  可以有多个构造函数（即函数重载形式）
> 
> ## **构造函数的种类** ##
> 
> 1. 默认构造函数
> 
> 2. 自定义的构造函数
> 
> 3.拷贝构造函数
> 
> 4.赋值构造函数

--------------------

## 一.默认构造函数 ##

> ### 1.什么是默认构造函数 ###
> 
> 1.没有参数的构造函数成为默认构造函数
> 
> 2.没有手动定义默认构造函数时，编译器自动为这个类定义一个构造函数。
> 
> 3. 如果数据成员使用了“类内初始值”，就使用这个值来初始化数据成员。否则，就使用默认初始化（实际上，不做任何初始化）只有C++11可以使用类内初始值】
> 
> ### 2.默认构造函数的应用 ###
> 
> #### 使用情况一:类内初始值 ####
> 
> ![98395ad23f4449e6ac2ed835c9b54cb3.png][]
> 
> 以上是当全部成员变量有"类内初始值"时,可以使用默认构造函数
> 
> #### 使用情况二:创建对象数组 ####
> 
> ![be77630fdf804a309d6da2a620d6ddce.png][]
> 
> 由此报错可以看出,对象数组的创建,必须使用默认的构造函数,在上面87行写了自定义的构造函数之后,程序就不会默认生成默认构造函数了,要想在有自定义构造函数的情况下,创建对象数组,就必须再重载一个不含参数的默认构造函数
> 
> #### 使用情况三:在派生类中 ####
> 
> 当派生类没有显式定义构造函数时，它将继承基类的默认构造函数。这使得在创建派生类对象时，基类的成员变量可以正确地初始化。
> 
>     #include <iostream>
>     using namespace std;
>     
>     // 基类
>     class Base {
>     public:
>         int baseValue;
>     
>         // 默认构造函数
>         Base() {
>             baseValue = 0;
>             cout << "Base 默认构造函数被调用" << endl;
>         }
>     };
>     
>     // 派生类
>     class Derived : public Base {
>     public:
>         int derivedValue;
>     
>         void printValues() {
>             cout << "Base 值: " << baseValue << endl;
>             cout << "Derived 值: " << derivedValue << endl;
>         }
>     };
>     
>     int main() {
>         Derived derivedObj;
>         derivedObj.derivedValue = 10;
>         derivedObj.printValues();
>         return 0;
>     }
>     
>     
>     输出:
>     Base 默认构造函数被调用
>     Base 值: 0
>     Derived 值: 10
> 
> 可以看到，派生类的对象 `derivedObj` 在创建时成功继承了基类 `Base` 的默认构造函数，并正确地初始化了基类的成员变量 `baseValue`。这证实了在派生类中没有显式定义构造函数时，它将继承基类的默认构造函数，并能够正确初始化基类的成员变量。
> 
> 注意：
> 
> **只要手动定义了任何一个构造函数，编译器就不会生成“默认构造函数”**
> 
> **一般情况下，都应该定义自己的构造函数，不要使用“默认构造函数”**
> 
> **【仅当数据成员全部使用了“类内初始值”，才宜使用“合成的默认构造函数”】**
> 
> #### 自定义的默认构造函数 ####
> 
> 如果既有类内初始值,在默认构造函数里面又有初始化,则以默认构造函数里的为准
> 
> ![6412e3b2f0554c01ab9ca4f609083497.png][]
> 
> 说明：如果某数据成员使用类内初始值，同时又在构造函数中进行了初始化，那么以构造函数中的初始化为准。相当于构造函数中的初始化，会覆盖对应的类内初始值。

--------------------

## 二.自定义的重载构造函数 ##

> #### 1.构造函数的作用 ####
> 
> 1.  初始化对象：自定义构造函数允许你在创建对象时对其进行初始化。您可以通过构造函数的参数传递初始值，或在构造函数中执行特定的初始化操作，确保对象在创建时处于正确的状态。
> 2.  参数化构造：自定义构造函数可以接受参数，从而使对象的创建更加灵活和可定制化。通过不同的构造函数形式，可以为不同的使用场景提供不同的对象初始化方式。
> 3.  代码可读性和维护性：通过显式定义构造函数，可以提高代码的可读性和维护性。构造函数明确地指示了对象的创建方式和初始化过程，使代码更加清晰易懂，并且便于后续修改维护。
> 
>     // 定义一个“人类”
>     class Human {
>     public:  
>     	Human();
>     	Human(int age, int salary);//自定义构造函数
>     
>     	string getName();
>     	int getAge();
>     	int getSalary();
>     
>     private:
>     	string name = "Unknown";
>     	int age = 28;
>     	int salary;
>     };
>     
>     Human::Human() {
>     	name = "无名氏";
>     	age = 18;
>     	salary = 30000;
>     }
>     
>     Human::Human(int age, int salary) {
>     	cout << "调用自定义的构造函数" << endl; 
>     	this->age = age;      //this是一个特殊的指针，指向这个对象本身
>     	this->salary = salary;
>     	name = "无名";
>     }
>     
>     
>     
>     string Human::getName() {
>     	return name;
>     }
>     
>     int Human::getAge() {
>     	return age;
>     }
>     
>     int Human::getSalary() {
>     	return salary;
>     }
>     
>     
>     int main(void) {
>     	Human  h1(25, 35000);  // 使用自定义的默认构造函数
>     
>     	cout << "姓名：" << h1.getName() << endl;
>     	cout << "年龄: " << h1.getAge() << endl;    
>     	cout << "薪资：" << h1.getSalary() << endl; 
>     
>     	system("pause");
>     	return 0;
>     }
> 
> 由此可以看出,自定义构造函数,只是比默认构造函数多了形参,由于创建的对象都形形色色,所以大多数情况下都会用自定义构造函数,在定义对象时,将参数传递进去给对象赋值

--------------------

## 三.拷贝构造函数 ##

> #### 1.浅拷贝 ####
> 
> 浅拷贝是指在对象拷贝过程中，仅简单地复制对象的成员变量值，而不复制成员变量所指向的动态分配的内存。这意味着原对象和拷贝对象将共享同一块内存区域，对其中一个对象的修改会影响到另一个对象。
> 
> 在进行浅拷贝时，通常会使用默认的拷贝构造函数或赋值运算符重载来完成。这些默认的复制操作只会简单地逐个拷贝对象的成员变量的值。
> 
>     class Human {
>     private:
>     	int Age=30;
>     	string Name ="LiHua";
>     public:
>     	Human(int age,string name);
>     	int getAge();
>     	string getName();
>     
>     	void print();
>     };
>     
>     
>     int Human::getAge() {
>     	return this->Age;
>     }
>     
>     string Human::getName() {
>     	return this->Name;
>     }
>     
>     void Human::print() {
>     	cout << "姓名 : " << this->getName() << endl;
>     	cout << "年龄 : " << this->getAge() << endl;
>     }
>     Human::Human(int age,string name) {
>     	this->Age = age;
>     	this->Name = name;
>     }
>     int main() {
>     
>     	Human h1(19,"Lihua");
>     	Human h2 = h1;//给对象赋值方法一
>     	Human h3(h2);//给对象赋值方法二
>     
>     	h1.print();
>     	h2.print();
>     	h3.print();
>     }
> 
> ![5d677b47270243ec9cb4664fce38fd09.png][]
> 
> 由此可以得出:给对象的赋值方法有两种,这两种方法都会调用拷贝构造函数,由于三个变量用的一块内存,所以说,改其中一个对象的值,其他三个的值都会被改变
> 
> ![0f9e81f32cf44c3a85101ee234fd6e3a.png][]
> 
> ![39245102644243d0942909a601124c98.png][]
> 
> 上面两张图片中输出的地址是一个地址,改变一个对象的值,另一个对象的值也会改变,这就验证了,浅拷贝的结果是两个对象共用了一个地址
> 
> 说明 : 默认的拷贝构造函数的缺点: 使用“浅拷贝”
> 
> #### 2.深拷贝 ####
> 
> 根据上面浅拷贝中的例子,其中有个地址,如果h1想要改addr,但是h2却不想改他的addr,这种情况就需要用到深拷贝了,深拷贝就必须得写自定义的拷贝构造函数,例子如下:
> 
>     class Human {
>     private:
>     	int Age=30;
>     	string Name ="LiHua";
>         char* addr;
>     public:
>     	Human(int age,string name);
>     	Human(const Human& the);
>         ~Human();//析构函数
>     
>     	int getAge();
>     	string getName();
>     
>     	void setAge(int age);
>     	void setName(string name);
>     	void setAddr(const char* addr);
>     	
>     	void print();
>     
>     };
>     int Human::getAge() {
>     	return this->Age;
>     }
>     
>     string Human::getName() {
>     	return this->Name;
>     }
>     
>     Human::~Human(){
>     
>     delete addr;
>     }
>     
>     void Human::print() {
>     	cout << "姓名 : " << this->getName() << endl;
>     	cout << "年龄 : " << this->getAge() << endl;
>     	cout << "地址 : " << this->addr << endl;
>     	printf("该对象的addr地址 : %p\n", this->addr);
>     }
>     Human::Human(int age,string name) {
>     	this->Age = age;
>     	this->Name = name;
>     	addr = new char[64];
>     	strcpy(addr, "China");
>     }
>     void Human::setName(string name) {
>     	this->Name = name;
>     }
>     void Human::setAge(int age) {
>     	this->Age = age;
>     }
>     void Human::setAddr(const char* addr) {
>     	if (!addr) {
>     		return;
>     	}
>     	strcpy(this->addr, addr);
>     }
>     Human::Human(const Human& the) {
>     	this->Age = the.Age;
>     	this->Name = the.Name;
>     	//给拷贝对象的addr重新分配内存,存储该地址
>     	this->addr = new char[64];
>     	strcpy(this->addr, the.addr);
>     }
>     int main() {
>     
>     	Human h1(19,"Lihua");
>     	Human h2(h1);//给对象赋值方法一
>     	//Human h3=h1;//给对象赋值方法二
>     
>     	h1.print();
>     	h2.print();
>     	//addr是char*类型
>     	h2.setAddr("美国");
>     	cout << "------------------------" << endl;
>     	h1.print();
>     	h2.print();
>     }
> 
> ![6269a501b80f41d2832c76ca645a88e6.png][]
> 
> 可以看到,此时通过深拷贝,两个对象的addr地址已经改变了
> 
> #### 3.什么时候用到深拷贝/浅拷贝 ####
> 
> 1.  对象拥有动态分配的资源：如果对象包含了动态分配的内存（如使用 `new` 或 `malloc` 创建的内存），在进行拷贝时需要进行深拷贝。这是因为默认的浅拷贝（shallow copy）只会复制指针，而不会为新对象分配独立的内存空间，这可能会导致多个对象指向同一内存，造成资源释放问题或不可预测的行为。
> 2.  修改的独立性要求：如果你需要在拷贝对象后对其进行修改，而不希望修改影响到原始对象，那么深拷贝是必需的。深拷贝会创建一个完全独立的副本，修改副本不会影响原始对象。
> 3.  对象包含指向其他对象的引用：当一个对象包含指向其他对象的引用或指针时，进行拷贝时可能需要进行深拷贝。这样可以确保每个对象都有自己的引用，而不是共享同一个引用。
> 
> 需要注意的是，并非所有情况都需要进行深拷贝。有时候浅拷贝已经足够满足需求，尤其是当拷贝的对象是只读的或者没有包含指向动态分配资源的指针时。
> 
> 在 C++ 中，可以通过自定义拷贝构造函数和赋值运算符重载来实现深拷贝
> 
> #### 4.什么时候会调用拷贝构造函数 ####
> 
> 1.调用函数时,实参是对象,形参不是引用类型
> 
> 2.函数的返回类型是类.而且不是引用类型
> 
> 3.对象数组的初始化列表中,使用对象

--------------------

## 四.赋值构造函数 ##

> #### 1.赋值构造函数可以怎么样定义 ####
> 
> 使用重载运算符 " = "进行实现
> 
>     class Human {
>     private:
>     	int age;
>     	string name;
>     	char* addr;
>     
>     public:
>     	//通过重载 " = "实现
>     	Human& operator=(const Human& other);
>     	
>     	Human(int age, string name,const char*addr);
>     	Human(){}
>     	~Human() {
>     		cout << "调用析构函数" << endl;
>     		delete addr;
>     	}
>     
>     	void print() {
>     		cout << "age :" << age << endl;
>     		cout << "name : " << name << endl;
>     		cout << "addr : " << addr << endl;
>     	}
>     };
>     
>     Human& Human::operator=(const Human& other) {
>     	if (this == &other) {
>     		return *this;
>     	}
>     
>     	addr = new char[64];
>     	strcpy(addr, other.addr);
>     
>     	age = other.age;
>     	name = other.name;
>     
>     	return *this;
>     }
>     Human::Human(int age, string name, const char* addr) :age(age), name(name) {
>     	this->addr = new char[64];
>     	strcpy(this->addr, addr);
>     }
>     
>     int main() {
>     	Human h1(23, "LiHua", "Chinese"),h2;
>     	h2 = h1;
>     	h1.print();
>     	cout << "************" << endl;
>     	h2.print();
>     
>     }
> 
> ![82cd3b97b6884e2da74384ee4b8d0110.png][]
> 
> #### 2.赋值构造函数在什么时候会调用? ####
> 
> 当用一个对象给另一个对象进行赋值时候会被调用,定义加赋值的话调用拷贝构造函数,例如:
> 
>     int main(){
>     
>     Test p1(20);
>     Test p2 = p1;
>     此时会调用拷贝构造函数
>     }
> 
>     class Test{
>     
>     .....
>     public:
>     
>     Test(int n){
>     this.age  =20;
>     }
>     Test test(Test & man){
>     //内联函数
>     return man;//返回对象
>     }
>     
>     };
>     
>     int main(){
>     
>     Test p1(20),p2;
>     p2 = p1;//此时会调用赋值构造函数
>     
>     Test p3 = h1;//此时创建对象p3同时初始化,会调用的是拷贝构造函数 
>     
>     p2 = test(p1);//此时会调用赋值构造函数
>     
>     Test p4  =test(p1);//此时会调用拷贝构造函数
>     
>     }
> 
> #### 2.赋值构造函数与拷贝构造函数的区别 ####
> 
> 1.  触发时机：拷贝构造函数在创建一个新对象并初始化时被调用，而赋值构造函数在已存在的对象进行赋值操作时被调用。
> 2.  参数类型：拷贝构造函数使用被拷贝对象的引用作为参数，通常是常量引用，用于初始化新对象；而赋值构造函数使用所需赋值的对象的引用作为参数，用于将已存在的对象赋值给另一个已存在的对象。
> 3.  功能：拷贝构造函数的主要目的是创建一个新对象，并将其初始化为与被拷贝对象相同的值。它通常用于深拷贝，确保新对象与原对象是独立的。赋值构造函数的主要目的是将一个已经存在的对象的值赋给另一个已经存在的对象。
> 4.  默认实现：如果没有显式定义拷贝构造函数和赋值构造函数，C++ 编译器会为类生成默认的拷贝构造函数和默认的赋值构造函数。默认的拷贝构造函数会执行浅拷贝，简单地将成员变量的值复制给新对象。默认的赋值构造函数也执行浅拷贝，将每个成员变量的值从一个对象复制到另一个对象。
> 
> 需要明确的是，拷贝构造函数和赋值构造函数在语法上是不同的，它们具有不同的函数形参和使用方式。在设计类时，根据对象的需求，需要选择正确的构造函数来满足对象的初始化和赋值操作。

--------------------

## 五.析构函数 ##

> ### 1.析构函数的基本概念 ###
> 
> 作用：
> 
> 对象销毁前，做清理工作。
> 
> 具体的清理工作，一般和构造函数对应
> 
> 比如：如果在构造函数中，使用new分配了内存，就需在析构函数中用delete释放。
> 
> 如果构造函数中没有申请资源（主要是内存资源），
> 
> 那么很少使用析构函数。
> 
> 函数名：
> 
> ~类型
> 
> 没有返回值，没有参数，最多只能有一个析构函数
> 
> 访问权限：
> 
> 一般都使用public
> 
> 使用方法：
> 
> 不能主动调用。
> 
> 对象销毁时，自动调用。
> 
> 如果不定义，编译器会自动生成一个析构函数（什么也不做）
> 
> ### 2.容易将调用析构函数与delete释放内存混淆 ###
> 
> 在我接触析构函数的时候,一直懂得就是在对象被销毁的时候才会调用析构函数,但是每次在类的成员函数中遇到new出来的空间时,就会以为将delete写在该成员函数中,然后delete执行了就会去调用析构函数,这个从逻辑上都是说不过去的
> 
> 现在懂得概念很明确,只有在对象销毁的时候调用,在类的成员函数或者构造函数中遇到new出来的空间时候,就应该给析构函数里面写delete释放该空间,等到对象被销毁的时候,就会去调用析构函数,就会执行delete语句将内存释放
> 
> 现在来看这么一个简单的例子,输出的顺序,就明白,只有对象被销毁的时候才会调用析构函数,遇见了new,就应该在析构函数里面写delete
> 
>     class Human {
>     private:
>     	int age;
>     	string name;
>     	char* addr;
>     
>     public:
>     	Human() {
>     		cout << "调用构造函数" << endl;
>     		addr = new char[64];
>     	}
>     
>     	~Human() {
>     		cout << "调用析构函数" << endl;
>     
>     		delete[]this->addr;
>     	}
>     
>     	void print() {
>     		cout << "调用print函数" << endl;
>     		strcpy(addr, "China");
>     		cout << addr << endl;
>     	}
>     };
>     
>     int main() {
>     	Human p1;
>     	p1.print();
>     }
> 
> ![ed198bcfb373480f85fa9df9d645b8a0.png][]

--------------------

> **总结:**
> 
> "在C++中，构造函数和析构函数是类的特殊成员函数，它们扮演着至关重要的角色。通过构造函数，我们可以初始化对象的状态，确保对象在被创建时处于合适的状态。而析构函数则负责在对象生命周期结束时进行善后工作，释放动态分配的资源，保证对象的安全销毁。深入理解和合理设计构造函数和析构函数，可以帮助我们编写更可靠、高效的C++程序，有效地管理资源，避免内存泄漏和访问冲突。构造与毁灭是C++编程中的关键概念，它们共同构成了面向对象编程中的基石，为我们提供了强大而灵活的工具，让我们能够更好地利用和管理对象的生命周期。"

--------------------

## ![84720e16fdaf417aa90d69b72b603adc.png][] ##

[Link 1]: https://blog.csdn.net/weixin_73865721?spm=1010.2135.3001.5343
[C_C]: https://blog.csdn.net/weixin_73865721?type=blog
[98395ad23f4449e6ac2ed835c9b54cb3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/544a746f6d2d4ef9b9c2ed6751b5806e.png
[be77630fdf804a309d6da2a620d6ddce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/ee64ef2cf8a843ff9c63bcad5733d4d5.png
[6412e3b2f0554c01ab9ca4f609083497.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/e2b56549c8304551921e112e0895bb96.png
[5d677b47270243ec9cb4664fce38fd09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/d8488a4b5caf4de780b80e21f05c5371.png
[0f9e81f32cf44c3a85101ee234fd6e3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/d53b64c7e2f445e19b335a451a2a0f25.png
[39245102644243d0942909a601124c98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/e69837e3ea22404abccc1292d28672e3.png
[6269a501b80f41d2832c76ca645a88e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/a2e8eb4b36134c17a30637b919f4aab9.png
[82cd3b97b6884e2da74384ee4b8d0110.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/d67efde19fb041e2807a3b755b6b3c1f.png
[ed198bcfb373480f85fa9df9d645b8a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/115c20ed153b4ff88ccaff6fc1182031.png
[84720e16fdaf417aa90d69b72b603adc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/f2359231792b46a2a09cd3510c354d52.png