【C++笔记---3】(C++拷贝构造函数与赋值运算符重载函数)

拷贝构造函数

拷贝构造函数是为同一类中之前创建的对象来初始化新创建的对象，即已存在的类类型对象创建新对象时由编译器自动调用。
通常用于：①初始化新创建同类型的对象。②将对象复制并作为参数传递给函数。③将对象复制并作为函数返回值
敲黑板-1

//不加&不行，无限递归
//不加const虽然行，加上是为了提高安全性并封锁引用对象对真实对象的修改
Test(const Test &t) 
{
	m_data = t.m_data;
	cout << "copy" << endl;
}

敲黑板-2

class A
{
public:
	A(const char* tr = "world")
	{
		str = (char*)malloc(strlen(tr) + 1);
		//str = (char*)malloc(sizeof(tr));   不能用sizeof的原因是无论字符串有多少字符，申请空间大小永远是固定值
		strcpy(str, tr);
	}
	~A()
	{
		cout << "A析构" << endl;
		free(str);
	}
private:
	char* str;
};
void main()
{
	A s1("helloa");
	A s2(s1);   //程序会出现崩溃  因为不定义拷贝构造函数，编译器进行浅拷贝，在类成员中有指针的情况下要深拷贝即自定义拷贝构造函数
}	

赋值运算符重载函数

赋值运算符重载是运算符重载函数中的一种，函数名为关键字operator后面接 = ，返回值类型为operator操作符(参数列表)。
敲黑板-3

Test& operator= (const Test &t)//返回是Test而不是void，是因为要连续赋值。加&是因为减少空间使用，提高效率
{
		cout << "赋值" << endl;
		m_data = t.m_data;
		return *this;  //意为返回当前对象，注意：如果返回对象不受作用域的影响，就可以引用返回；如果出了作用域就会被释放，就不能用
}	

敲黑板-4

Test operator= (const Test &t) //加不加& 效率不一样
{   if (this ！= &t)
		m_data = t.m_data;//判断是否自己给自己赋值
	return *this；
}
//t2.operator=(t1); == > operator=(&t2, t1);

加菜加菜！！！

加深理解！！！
第一步

Test fun(Test x)
{
	int value = x.GetData();
	Test tmp(value);
	return tmp; //借助临时变量返回value，先拷贝给临时变量value，临时变量是在函数释放后释放
}
void main()
{
	Test t1(10);
	Test t2 = t1;  //==>Test t2(t1);  | Test(&t2 ,t1) 原型为：Test(Test *const this,const Test &t)
	fun(t2);  //调用时，拷贝构造函数t2初始化fun中的Test
}

运行结果：
构造 地址：010FFEAC // （t1构造）
拷贝 地址：010FFEA0 // （t2拷贝）
拷贝 地址：010FFDAC//（调用函数是t2初始化test x）
构造 地址：010FFD7C//（tmp构造）
拷贝 地址：010FFDC8//（tmp返回给value，临时变量拷贝）
析构 地址：010FFD7C //（tmp析构）
析构 地址：010FFDAC//（x析构）
析构 地址：010FFDC8//（出函数作用域临时变量析构）
析构 地址：010FFEA0//（t2析构）
析构 地址：010FFEAC//（t1析构）

第二步

Test fun(Test &x)   //与第一步不同，此处加了引用
{
	int value = x.GetData();
	Test tmp(value);
	return tmp;
}
void main()
{
	Test t1(10);
	Test t2 = t1;
	fun(t2);  
}

运行结果：
构造 地址：010FFB34 // （t1构造）
拷贝 地址：010FFB28 // （t2拷贝）
构造 地址：010FFA14//（tmp构造）
拷贝 地址：010FFA5C//（tmp返回给value，临时变量时拷贝）
析构 地址：010FFA14// （tmp析构）
析构 地址：010FFA5C//（出函数作用域临时变量析构）
析构 地址：010FFB28//（t2析构）
析构 地址：010FFB34//（t1析构）

第三步

Test fun(Test &x)
{
	int value = x.GetData();
	return Test(value);  // 与第二步不同，这里运用了创建临时对象语法
}
void main()
{
	Test t1(10);
	Test t2 = t1;
	fun(t2);  
}

运行结果
构造 地址：00F3FD64//（t1构造）
拷贝 地址：00F3FD58//（t2拷贝）
构造 地址：00F3FC8C//（Test(value）构造）
析构 地址：00F3FC8C//（函数出作用域，变量析构）
析构 地址：00F3FD58//（t2析构）
析构 地址：00F3FD64//（t1析构）

第四步

Test fun(const Test &x)
{
	int value = x.GetData();
	return Test(value);
}
void main()
{
	Test t1(10);
	Test t2 = fun(t1);  //编译器将无名临时对象认为t2
}

运行结果：
构造 地址：0093F804//（t1构造）
构造 地址：0093F7F8//（t2构造）
析构 地址：0093F7F8//（t2析构）
析构 地址：0093F804//（t1析构）