C++:类的默认成员函数------拷贝构造函数&&赋值运算符重载

最新推荐文章于 2024-06-13 19:20:52 发布

sunny-ll

最新推荐文章于 2024-06-13 19:20:52 发布

阅读量1k

点赞数 22

分类专栏： C++ 文章标签： c++ 开发语言 1024程序员节 linux java 数据结构

本文链接：https://blog.csdn.net/weixin_45031801/article/details/133993523

版权

C++ 专栏收录该内容

58 篇文章 166 订阅

订阅专栏

🍎 解释特性2：拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用

🍐解释特性3：若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝

一、前言

在我们前面学习的类中，我们会定义成员变量和成员函数，这些我们自己定义的函数都是普通的成员函数，但是如若我们定义的类里什么也没有呢？是真的里面啥也没吗？如下：
class Date {};
如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成6个默认成员函数。

【默认成员函数概念】：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

⭐其中上次的博客已经详细的讲解了构造函数&&析构函数的使用方法，所以本次博客将继续深度的讲解拷贝构造和赋值运算符的重载问题。⭐

二、拷贝构造函数

💦拷贝构造函数概念

我们在创建对象时，可否创建一个与另一个对象一摸一样的新对象呢？
int main()
{
	Date d1(2022, 5, 18);
    // 将 d1 的 数据拷贝给 d2 让 d2 进行初始化
	Date d2(d1);
	return 0;
}
能否让d2的值跟d1一样呢？也就是说我拿d1去初始化d2，此时调用的函数就是拷贝构造函数。
🔑拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用

💦拷贝构造函数特性

拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

如下即为拷贝构造函数：
Date(Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

🍎 解释特性2：拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用

为什么传值传参会引发无穷递归呢？
我们先举一个普通的func函数作为例子：
//传值传参
void Func(Date d)
{}
int main()
{
	Date d1(2022, 5, 18);
	Func(d1);
	return 0;
}
此函数调用传参是传值传参。在C语言中，把实参传给形参是把实参的值拷贝给形参，而我的实参d1是自定义类型的，需要调用拷贝构造，传值传参是要调用拷贝构造的，但是我如果不想调用拷贝构造呢？就需要引用传参，因为此时d就是d1的别名
void Func(Date& d) {}
此时再回到我们刚才的例子：如若我不传引用传参，就会疯狂的调用拷贝构造：
Date(Date d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
为了避免出现无限递归调用拷贝构造，所以要加上引用，加上引用后，d就是d1的别名，不存在拷贝构造了。同类型的传值传参是要调用拷贝构造的
Date(const Date& d) {} 
//最好加上const，对d形成保护

🍐解释特性3：若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝

看如下代码：
class Date
{
public:
//构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//拷贝构造函数
    /*
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
    */
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Func(Date& d)
{
	d.Print();
}
int main()
{
	Date d1(2023, 10, 23);
	Date d2(d1);
	Func(d1);
	d2.Print();
}
运行效果图展示：

为什么我这里没有写拷贝构造函数，它也会自动完成拷贝构造呢？由此我们要深思，拷贝构造与构造和析构是不一样的，构造和析构都是针对自定义类型才会处理而内置类型不会处理，而默认拷贝构造针对内置类型的成员会完成值拷贝，浅拷贝，也就是像把d1的内置类型成员按字节拷贝给d2。

由此得知，对于日期类这种内置类型的成员是不需要我们写拷贝构造的，那是不是所有的类都不需要我们写拷贝构造呢？来看下面的例子：

🔑 栈类（需要深拷贝的类）
class Stack
{
public:
	//构造函数
	Stack(int capacity = 10)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
//不写拷贝构造，编译器调用默认拷贝构造
	/*
	Stack(const Stack& st)
	{
		_a = st._a;
		_top = st._top;
		_capacity = st._capacity;
	}
	*/
	//析构函数
	~Stack()
	{
		cout << "~Stack():" << this << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st1(10);
	Stack st2(st1);
}
运行结果出现报错：

我们通过调试看到运行崩溃了，可见栈的拷贝构造函数不能像日期类一样不写而让编译器去调用默认拷贝构造（就是按照日期类的模式写了拷贝构造也会出错），因为此时的st1（指针）和st2（指针）指向的就是同一块空间，通过调试可以看出：

st1和st2指向同一块空间会引发一个巨大的问题：析构函数那出错，因为我st2会先析构，析构完后我st1再析构，不过我st1指向的空间已经被st2析构过了，因为它俩指向同一块空间，同一块空间我释放两次就会有问题。出了析构存在问题，增删查改那也会有问题，这个后续会谈到。
其实刚才写的栈的拷贝构造就是浅拷贝，真正栈的拷贝构造应该用深拷贝来完成，此部分内容我等后续会专门出一篇博文详解，这里大家先简单接触下。
综上，我们可以得知，浅拷贝针对日期类这种是没有问题的，而类的成员若是指向一块空间的话就不能用浅拷贝了。

🔑 字符串类（需要深拷贝的类）
class MyString {
public:
	// 默认构造函数
	MyString(const char* str = "winter") 
	{
		_str = (char*)malloc(sizeof(char)*(strlen(str) + 1));
		if (_str == nullptr)
		{
			perror("malloc fail!");
			exit(-1);
		}
		strcpy(_str, str);
	}

	// 析构函数
	~MyString() 
	{
		cout << "~String()" << endl;
		free(_str);
	}

	void MyPrintf()
	{
		cout << _str << endl;
		//printf("%s\n", _str);
	}

private:
	char* _str;
};

int main() 
{
	MyString s1("hello C++");
	MyString s2(s1);
	s1.MyPrintf();
	cout << endl;
	s2.MyPrintf();
	cout << endl;
}
如图：指向了同一块空间

那么会引发什么问题呢？会导致 _str 指向的空间被释放两次，引发程序崩溃。

加入深入拷贝构造函数：
class MyString {
public:
	// 默认构造函数
	MyString(const char* str = "winter") 
	{
		_str = (char*)malloc(sizeof(char)*(strlen(str) + 1));
		if (_str == nullptr)
		{
			perror("malloc fail!");
			exit(-1);
		}
		strcpy(_str, str);
	}

	// 析构函数
	~MyString() 
	{
		cout << "~String()" << endl;
		free(_str);
	}

	 //拷贝构造函数
	MyString(const MyString& s) 
	{

		// 给新对象申请一段和原对象一样大小的空间
		_str = (char*)malloc(sizeof(char) * (strlen(s._str) + 1));
		if (_str == nullptr)
		{
			perror("malloc fail!");
			exit(-1);
		}

		// 把原对象的数据一一拷贝给新对象
		strcpy(_str, s._str);
	}
	void MyPrintf()
	{
		cout << _str << endl;
		//printf("%s\n", _str);
	}

private:
	char* _str;
};

int main() 
{
	MyString s1("hello C++");
	MyString s2(s1);
	s1.MyPrintf();
	cout << endl;
	s2.MyPrintf();
	cout << endl;
}

⭐总结：

1️⃣：你可以观察在当前这这个类中是否存在显式的析构函数，若是存在的话，表示当前这个类涉及资源管理了【资源管理指得就是去堆中申请空间了】，此时你一定要自己去是实现拷贝构造以达到一个深拷贝；若是不涉及资源管理的话，直接使用编译器自动生成的进行浅拷贝就可以了

2️⃣： 像Date日期类这种只存在【年】、【月】、【日】这种内置类型的浅拷贝就可以了；像是复杂一些的，例如：链表、二叉树、哈希表这些都会涉及资源的管理，就要考虑到深拷贝了

🍓产生拷贝构造的三种形式

深刻理解了拷贝构造之后，我们再来看看产生拷贝构造的三种形式

1.当用类的对象去初始化同类的另一个对象时

Date d1;
Date d2(d1);
Date d3 = d2;	//也会调用拷贝构造

在实例化对象d2和d3的时候都去调用了拷贝构造，最后它们初始化后的结果都是一样的

2.当函数的形参是类的对象，调用函数进行形参和实参结合时

void func(Date d)	//形参是类的对象
{
	d.Print();
}

int main(void)
{
	Date d1;
	func(d1);	//传参引发拷贝构造
	
	return 0;
}

函数func()的形参是类的对象，此时在外界调用这个函数并传入对应的参数时，就会引发拷贝构造，

3.当函数的返回值是对象，函数执行完成返回调用者时

Date func2()
{
	Date d(2023, 3, 24);
	return d;
}

int main(void)
{
	Date d1 = func2();
	d1.Print();

	return 0;
}

可以看到，这一种方式也会引发拷贝构造，当函数内部返回一个Date类的对象时，此时外界再使用Date类型的对象去接收时，就会引发拷贝构造。