• 【C++】：拷贝构造函数和赋值运算符重载

    目录

    一，拷贝构造函数

    1. 什么是拷贝构造函数

    拷贝构造函数是特殊的构造函数。是用一个已经存在的对象，赋值拷贝给另一个新创建的已经存在的对象。

    本质：用同类型的对象拷贝初始化。

    2. 拷贝构造函数的特性

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

    2.1 拷贝构造函数是构造函数的一个重载形式。

    2.2 拷贝构造函数的函数名域类名相同，参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为在语法上引发无穷递归调用。

    注意：

    • Date d2(d1); 这句代码也等价于Date d2 = d1;也是拷贝构造的写法。
    #include 
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	//拷贝构造函数
	//参数只有一个，必须是类类型对象的引用。
    //Date d2(d1); 
	Date(Date& d)   //传引用，正确写法
	//Date(Date d)  //传值，错误写法
{
    //用来检测是否调用该拷贝构造函数
	cout << "Date(Date& d)" << endl;

	//d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};

int main()
{
	Date d1(2024,4,21);
	d1.Print();

	//d2对象不在按指定年月日初始化，而是想和d1对象初始化一样
	//拷贝构造：用同类型的对象拷贝初始化
	
	Date d2(d1);//这句代码也等价于Date d2 = d1;也是拷贝构造的写法
	d2.Print();

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    在这里插入图片描述

    如果是传值的方式，如上述代码中的错误写法，程序会直接报错。

    在这里插入图片描述

    这是为什么呢？
    这是因为自定义类型传值传参要调用拷贝构造，而内置类型就是直接拷贝。

    通过下面的代码来侧面说明：

    定义一个 func 函数，把类对象 d1 传值过去，运行的结果是调用func之前会先调用拷贝构造函数。

    class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	Date(Date& d)  
{
    //用来检测是否调用该拷贝构造函数
	cout << "Date(Date& d)" << endl;

	//d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
	_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(2024, 4, 12);
	
	//调用func之前会先进入拷贝构造函数
	func(d1);

	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    在这里插入图片描述

    所以在 2.2 的代码中，如果进行传值调用，则在语法逻辑上会出现如下的无穷递归：

    在这里插入图片描述

    那如何让它不调用拷贝构造呢？

    方式1：传地址（相当于变为内置类型）

    class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	Date(Date& d)  
{
    //用来检测是否调用该拷贝构造函数
	cout << "Date(Date& d)" << endl;

	//d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
	_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(2024, 4, 12);
	func(&d1);

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    在这里插入图片描述

    方式2：传引用（一般都是传引用）。

    class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	Date(Date& d)  
{
    //用来检测是否调用该拷贝构造函数
	cout << "Date(Date& d)" << endl;

	//d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
	_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是d1的别名
{
	d.Print();
}

int main()
{
	Date d1(2024, 4, 12);
	
	//调用func之前会先进入拷贝构造函数
	func(d1);

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    在这里插入图片描述

    那有些人会想，拷贝构造函数能不能用指针呢？这能不能避免无穷递归？

    答案：可以的。可以完成拷贝，但是此时这个函数就不是拷贝构造函数了，而是一个普通的构造函数。

    class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//用指针就不会形成无穷递归，但此时它就是一个普通构造了，不是拷贝构造。
	//感觉怪怪的，所以一般用引用
	Date(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;   // 日
};

int main()
{
	Date d2(2024, 4, 21);
	Date d3(&d2);
	d3.Print();

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    在这里插入图片描述

    说明：

    • 虽然传地址可以避免无穷递归，并且可以完成拷贝，但是这样怪怪的。在C++中，一般是传引用。并且传引用可以减少拷贝，提高了效率。

    在拷贝函数中还有一点就是：在传引用时一般要加 const 修饰。

    在显式写拷贝构造函数时，参数写反了……(这就有点尴尬了)
    在这里插入图片描述

    运行结果是：拷贝一堆随机值。
    在这里插入图片描述

    加上 const 之后：

    在这里插入图片描述

    2.3.若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

    注意：

    • 在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
    class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		
		//检测是否调用了这个拷贝构造函数
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};

int main()
{
	Date d1(2024, 4, 23);

	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
		Date d2(d1);
		d2.Print();

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    在这里插入图片描述

    2.4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

    typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	//注意：如果没有显示写析构函数，编译器也会自动生成。
	//自动生成的析构对内置类型不做处理，自定义类型才会去调用它的析构
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(1);
	st1.Push(1);
	
	Stack st2 = st1;

	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    运行结果：完成了拷贝，但程序崩溃！
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/445beda92a034ed38ddb19f0c614a25c.png

    原因：

    • 当栈调用默认生成的拷贝构造函数时，这种函数进行的是浅拷贝(值拷贝) 本质是按字节进行拷贝的。这可能会导致当两个对象指向同一块空间时，如_array，当st1 和st2生命周期结束时，两个对象会分别析构，就相当于释放了两次。 常见的数据结构，栈，队列，链表，树等都有这个问题。

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/d9db431da4294841ad110e97d10588ec.png

    解决方案：
    深拷贝：当有指针指向资源时，会开辟建立一块和要拷贝的一模一样的空间，形状，再进行拷贝。

    
//实现栈的深拷贝
//Stack st2 = st1;  //st是st1的别名
Stack(const Stack& st)
{
	_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
	if (NULL == _array)
	{
		perror("malloc申请空间失败!!!");
		return;
	}

	//开辟好空间后再把值拷贝进去
	memcpy(_array, st._array, sizeof(DataType) * st._size);

	_size = st._size;
	_capacity = st._capacity;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这里插入图片描述

    把上面栈的深拷贝的代码插入 2.4 的类中，调试结果是：
    在这里插入图片描述

    3. 实践总结

    1.如果没有管理资源，一般情况下不需要写拷贝构造，用编译器默认生成的拷贝构造就可以。如 Date类；

    2.如果都是自定义类型成员，内置类型成员没有指向资源，用编译器默认生成的拷贝构造就可以。如 MyQueue ；
    （小技巧：一般情况下，不需要写析构的，就不需要写拷贝构造。）

    3.如果内部有指针或者有一些值指向资源，需要显式写析构函数释放，通常就需要显式写拷贝构造完成深拷贝。如各种数据类型栈，队列，链表，树等。

    二，赋值运算符重载

    2.1 运算符重载

    C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

    函数名字为：关键字operator后面接需要重载的运算符符号。

    函数原型：返回值类型 operator操作符(参数列表)

    注意：

    • 不能通过连接其他符号来创建新的操作符：比如operator@ ;
    • 重载操作符必须有一个类类型参数 ；
    • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义 (这条仅供参考)；
    • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；
    • . * (调用成员函数的指针) ， :: (域作用限定符) ， sizeof (计算变量所占内存的大小) ，?: （三目运算符）， . (结构体变量引用符)，注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

    简单介绍一下 . * 运算符的用法：

    class OB
{
public:
	void func()
	{
		cout << "void func()" << endl;
	}
};

//重新定义成员函数指针类型
//注意：typedef void(*)()  PtrFunc; 是错误写法
typedef  void (OB::* PtrFunc)();

int main()
{
	//成员函数要加&才能取到函数指针
	PtrFunc fp = &OB::func; //定义成员函数指针fp 指向函数func

	OB tmp;//定义OB类对象tmp

	(tmp.*fp)(); //调用成员函数的指针

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    运算符重载的使用：

    class Date
{
public:
	Date(int year , int month , int day )
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//d3.operator== (d4)
	//d3传给了隐含的this指针，d是d4的别名
	 bool operator== (const Date & d)
	 {
		 return _year == d._year
			 && _month == d._month
			 && _day == d._day;

	 }

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};

//但是如果全局重载（没有private时)和成员函数同时存在，编译不会报错，
//调用时会默认调成员函数，相当于全局重载没有任何意义了。
int main()
{
	Date d3(2024, 4, 12);
	Date d4(2024, 4, 15);

	//显式调用(一般不这样写)
	//cout << d3.operator== (d4) << endl;

	//转换调用 等价于d3.operator== (d4) 汇编代码
	//注意：如果是两个操作数，从左到右的参数是对应的，不能颠倒位置
	cout << (d3 == d4) << endl;

	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    2.2 赋值运算符重载

    2.2.1 赋值运算符重载格式

    • 参数类型：const 类名 &，传递引用可以减少拷贝，提高传参效率；
    • 返回值类型：类名 &，返回引用可以减少拷贝，提高返回的效率，有返回值目的是为了支持连续赋值；
    • 检测是否自己给自己赋值；
    • 返回*this ：要复合连续赋值的含义.
    class Date
{
public:
	Date(int year = 2024, int month = 4, int day = 21)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//拷贝构造
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//d1 = d3
	//void operator= (const Date& d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}

	//有时候会带返回值:目的是为了连续拷贝
	//d1 = d2 = d3; 
	//比如这里，d是d3的别名，从右往左，先d2 = d3,返回值是d2
	Date& operator= (const Date& d)
	{
	    //检测是否自己给自己赋值
	     if(this != &d)
	  {
			_year = d._year;
			_month = d._month;
			_day = d._day;
	  }
        
      //这里的d2的地址是this ，*this就是d2。
      //这里的*this才是对象本身，对象在main的作用域
      //里创建的，因此出main作用域才会析构销毁，
      //出了当前函数不会析构。所以可以用引用返回。
		return *this;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};

int main()
{
	Date d1(2024, 4, 12);

	//拷贝构造
	//一个已经存在的对象，拷贝给另一个要创建初始化的对象
	Date d2 = d1;

	Date d3(2024, 5, 1);

	//赋值拷贝/赋值重载
	//一个已经存在的对象，拷贝赋值给另一个已经存在的对象
	//d1 = d3;

	//连续赋值
	d1 = d2 = d3;

	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79

    传值返回和传引用返回的区别：

    class Date
{
public:
 Date(int year, int minute, int day)
   {
      cout << "Date(int,int,int):" << this << endl;
   }
   
 Date(const Date& d)
   {
      cout << "Date(const Date& d):" << this << endl;
   }
   
 ~Date()
   {
      cout << "~Date():" << this << endl;
   }
private:
	 int _year;
	 int _month;
	 int _day;
};

Date Test(Date d)
  {
	 Date temp(d);
	 
	 return temp;
  }
  
int main()
  {
	 Date d1(2022,1,13);
	 Test(d1);
	 
	 return 0;
  }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    在这里插入图片描述

    总结一下：

    • 如果返回对象是一个局部对象或者临时对象，出了当前函数作用域就析构销毁了，就不能用引用返回。用引用返回是存在风险的，因为引用对象在当前函数栈帧已经被销毁了。所以虽然引用返回可以减少一次拷贝，但是出了函数作用域，返回对象还在，才能用引用返回。

    在这里插入图片描述

    2.2.2 赋值运算符只能重载成类的成员函数不能重载成全局函数

    2.2.3 和拷贝构造类似，用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

    注意：

    • 内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
  • 相关阅读:
    git的基本使用1
    antd vue 自定义侧边栏svg图标、并改变图标颜色
    synchronized 与 spring事务 @Transactional 的介绍使用
    Linux 启动管理
    Spring Boot 笔记
    《C和指针》笔记30：函数声明数组参数、数组初始化方式和字符数组的初始化
    javascript算法排序之冒泡排序
    Opencv源码解析（2）算法
    Crazy Binary String
    ARM 37 个通用寄存器详解
  • 原文地址：https://blog.csdn.net/2301_77900444/article/details/138163350