【C++】拷贝构造函数,析构函数详解!

在这里插入图片描述


个人主页 :阿然成长日记 点击可跳转
个人专栏: 数据结构与算法C语言进阶
不能则学,不知则问,耻于问人,决无长进

文章目录

  • 一、析构函数
    • 1.概念
    • 2.特点
    • 3.案例
  • 二、拷贝构造函数
    • 1.拷贝构造函数的引入
    • 2.格式
    • 2.概念
    • 3.特点
    • 4.解决引入问题
    • 5.总结

一、析构函数

1.概念

析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
析构函数是用于在对象被删除之前的清理工作,它在对象生命周期即将结束时会被自动调用。(析构函数可以清理对象并且释放内存)

2.特点

析构函数是特殊的成员函数,其特征如下:

  1. 析构函数名是在类名前加上字符 ~
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构
    函数不能重载
  4. 对象生命周期结束时,C++编译系统系统自动调用析构函数
  5. 关于编译器自动生成的析构函数,是否会完成一些事情呢?下面的程序我们会看到,编译器
    生成的默认析构函数,对自定类型成员调用它的析构函数

3.案例

class Time
{
public:
~Time()
{
cout << "~Time()" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}

上述代码定义了两个类Data和Time。其中Data类中存在一个自定义类型变量Time,主方法中只创建了Data对象。那么在main方法中根本没有直接创建Time类的对象,为什么最后会调用Time类的析构函数?

答:因为main方法中创建了Date对象d,而d中包含4个成员变量,其中_year, _month,_day三个是内置类型成员,销毁时不需要资源清理,最后系统直接将其内存回收即可;而_tTime类对象,所以在d销毁时,要将其内部包含的Time类的_t对象销毁,需要调用Time类的析构函数。但是main函数中不能直接调用Time类的析构函数,实际要释放的是Date类对象,所以编译器只会调用Date类的析构函 数,而Date没有显式提供,则编译器会给Date类生成一个默认的析构函数,目的是在其内部 调用Time类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁 ,main函数中并没有直接调用Time类析构函数,而是显式调用编译器为Date类生成的默认析构函数
注意:创建哪个类的对象则调用该类的析构函数,销毁那个类的对象则调用该类的析构函数

二、拷贝构造函数

1.拷贝构造函数的引入

如下代码:
创建Stack类和Date类。

class Date
{
public:
	void print(){}
private:
	int _year =1;
	int _month =1;
	int _day =1;
};
class Stack
{
	public:
		Stack(size_t capacity = 10)
		{
			_array = (DataType*)malloc(capacity * sizeof(DataType));
			if (nullptr == _array)
			{
				perror("malloc申请空间失败");
				return;
			}
			
			_size = 0;
			_capacity = capacity;
		}
		void Push(const DataType& data)
		{
			// CheckCapacity();
			_array[_size] = data;
			_size++;
		}
		~Stack()
		{
			if (_array)
			{
				free(_array);
				_array = nullptr;
				_capacity = 0;
				_size = 0;
			}
		}
	private:
		int* _array;
		size_t _size;
		size_t _capacity;
};

使用传值的方式进行调用。

void fun1(Date d)
{
	//...
}
void fun2(Stack s)
{
	//...
}

主函数

int main()
{
	Date d1(1999, 1, 1);
	fun1(d1);

	Stack s1;
	fun2(s1);
	return 0;
}

【C++】拷贝构造函数,析构函数详解!_第1张图片

可以发现运行报错!!!为什么呢?

在C语言中我们遇到这种情况是没有问题的,但是在C++中,由于引进了析构函数,也就是说每次对象试用结束,系统都会自动调用析构函数进行对象的清除工作,正因如此我们在传值的时候,会再次创建一个对象复制过去,当结束函数调用时,会自动调用析构函数对当前对象进行清除,【如果对象中都是变量的话是没有问题的,因为值传递的改变不影响外部的变量,它只是一份拷贝。但是,如果对象中有指针类型的变量,它们指向的是同一位置,第一次函数调用结束后,析构函数已经对指向的位置进行了清除,第二次外部对象结束时,在调用析构函数,就会造成二次析构】。上面例子中Date类中全是普通变量,不会出现问题,造成二次析构。
为了解决上面的问题我们引入了拷贝构造函数。(通过深拷贝解决问题)

2.格式

类名(const 类名 &参数)

2.概念

只能有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存 在的类类型对象创建新对象时由编译器自动调用。

3.特点

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,
    因为会引发无穷递归调用。

例如:

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
	_year = year;
	_month = month;
	_day = day;
}
下面是拷贝构造!!
Date(const Date& ddd) // 正确写法
Date(const Date ddd) // 错误写法:编译报错,会引发无穷递归
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
private:
	int _year;
	int _month;
	int _day;
};

主函数

int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}
  • Date(const Date d) // 错误写法:编译报错,会引发无穷递归; 因为【Date d】参数会继续生成一个拷贝构造,如此往复循环。
  • *Date(const Date& ddd) // 正确写法 使用传引用就可以解决这个问题。因为ddd就是对象d1的一个别名,this指针指向d2,ddd传给了this,就相当于把d1给了d2,(传递指针也可以,但是很难用),规定必须使用引用。

4.解决引入问题

学到这里我们就可以很好地解决之前抛出的问题了。使用拷贝构造,将原来对象玩玩整整的拷贝一份出来,尤其是内部指针所指向的空间,拷贝时也会去开辟一块新的空间。这样在函数调用函数结束时,系统自动调用其析构造函数时,就不会造成一个地方多次析构了。各玩各的。

5.总结

内置类型系统会默认生成拷贝构造进行值拷贝,对自定义类型调用它的拷贝构造。
并不是所有的对象都需要拷贝构造:

  • 类中如果没有涉及资源申请时(例如 new申请空间),拷贝构造函数是否写都可以;
  • 一旦涉及到资源申请时,则拷贝构造函数是一定要写的,否则就是浅拷贝。
  • 拷贝构造也是构造,是拷贝构造的一个重载。

你可能感兴趣的:(C++基础,开发语言,c++)