020_拷贝构造函数的四种调用时机

/*
	copy构造函数的调用  时机1 时机2
*/

#if 1
class Test4
{
public:
	Test4()  //无参数构造函数
	{
		m_a = 0;
		m_b = 0;
		cout << "我是构造函数,自动被调用了" << endl;
	}

	Test4(int a)
	{
		m_a = a;
		m_b = 0;
	}

	Test4(int a, int b) //有参数构造函数   //3种方法
	{
		m_a = a;
		m_b = b;
		cout << "有参数构造函数" << endl;
	}

	//赋值构造函数 (copy构造函数)  作用完成对象的初始化
	Test4(const Test4& obj)
	{
		cout << "我也是构造函数,我是通过另一个对象obj来初始化我自己 " << endl;
		m_a = obj.m_a + 100;
		m_b = obj.m_b + 100;
	}


	~Test4()
	{
		cout << "我是析构函数，自动被调用了" << endl;
	}

public:
	void printT()
	{
		cout << "普通成员函数" << endl;
		cout << "m_a = " << m_a << ", m_b = " << m_b << endl;
	}

private:
	int m_a;
	int m_b;

};

void test()
{
	//赋值构造函数 用一个对象初始化另一个对象
	Test4 t1(10, 12);
	Test4 t0(0, 2);

	//赋值操作 和 初始化是两个不同的概念

	//赋值 = 操作  不会调用拷贝构造函数,编译器给我们提供的浅copy
	t0 = t1;		//用t1 给 t0赋值    

	//第一种 调用拷贝构造函数的时机
	Test4 t2 = t1;	//用t1来初始化t2,调用t2这个对象的拷贝构造函数
	t2.printT();

	//第二种 调用拷贝构造函数的时机
	Test4 t3(t1);	//用t1来初始化t2
	t3.printT();
}

#endif

/*
	赋值构造函数的调用  时机3
	*/
#if 1
class Location
{
public:
	//构造函数
	Location(int xx = 0, int yy = 0)
	{
		X = xx;
		Y = yy;
		cout << "Constructor Object." << endl;
	}
	//拷贝构造函数  完成对象的初始化
	Location(const Location &obj)
	{
		X = obj.X;
		Y = obj.Y;
		cout << "copy 构造函数." << endl;
	}

	~Location()
	{
		cout << X << "," << Y << " Object destroyed." << endl;

	}
	int GetX()
	{
		return X;
	}
	int GetY()
	{
		return Y;
	}
private:
	int X, Y;
};

//第三种 调用拷贝构造函数的时机
void f(Location p)	//参数是一个元素
{
	cout << p.GetX() << endl;
}

void test()
{
	Location a(1, 2);
	Location b = a;		//第一种 调用拷贝构造函数的时机
	/*
		实参b去初始化形参p,c++编译器会调用形参 p 这个对象的copy构造函数，
		由于p是局部变量，函数f()运行完毕，p对象的生命周期结束,会调用
		p对象的析构函数。

		先创建的对象后释放
	*/
	//b实参去初始化形参p,会调用copy构造函数 
	cout << "-------1------" << endl;
	f(b);			//第3种时机
	cout << "-------2------" << endl;
	cout << "b对象已经初始化完毕" << endl;

}
#endif

/*
	赋值构造函数的调用  时机4
*/
#if 1
class Location
{
public:
	//构造函数
	Location(int xx = 0, int yy = 0)
	{
		X = xx;
		Y = yy;
		cout << "Constructor Object." << endl;
	}
	//拷贝构造函数  完成对象的初始化
	Location(const Location &obj)
	{
		X = obj.X;
		Y = obj.Y;
		cout << "copy Constructor Object." << endl;
	}

	~Location()
	{
		cout << X << "," << Y << " Object destroyed." << endl;

	}
	int  GetX() { return X; }		int GetY() { return Y; }
private:
	int X, Y;
};

//第4种 调用拷贝构造函数的时机
Location g()
{
	Location A(11, 22);//执行对象A的构造函数
	return A;
	/*
	return A;
	这条语句  首先会创建一个匿名对象，用对象A初始化匿名对象，执行匿名对象的copy构造函数，
	然后对象A的生命周期结束了，会执行对象A的析构函数。g()返回一个匿名对象.
	*/
}

//测试匿名对象的生命周期
void objplay2()
{
	g();//g()返回一个匿名对象，如果匿名对象没人接，则会执行匿名对象的析构函数。
}

运行结果（测试匿名对象的生命周期）

/*
g()函数 返回一个元素
结论 1:函数的返回值是一个元素(复杂类型的),返回一个新的匿名对象(所以会调用匿名对象
的 copy构造函数)。
结论 2:有关匿名对象的去和留
如果用匿名对象 初始化 另一个同类型的对象,匿名对象转化为有名对象,匿名对象不会被析构掉
如果用匿名对象 赋值给 另一个同类型的对象,匿名对象被析构
*/


void objplay3()
{
	//用匿名对象初始化m，此时c++编译器直接把匿名对象转成m(扶正),从匿名转成有名对象了m
	Location m = g();
	printf("匿名对象,被扶正,不会被析构掉\n");
	cout << m.GetX() << endl;
}

运行结果（函数返回的匿名对象的去初始化另一个对象）

void objplay4()
{
	Location m2(1, 2);
	m2 = g();//用匿名对象 赋值给 m2
	printf("因为用 匿名对象 赋值 给m2, 匿名对象被析构\n");
	cout << m2.GetX() << endl;
}

运行结果（函数返回的匿名对象的去赋值另一个对象）
、

void objplay5()
{
	//用匿名对象 赋值给 m2
	Location m1(1, 2);
	cout << "------1-----" << endl;
	m1 = Location(33, 44);  //赋值操作   Location(33, 44)会产生匿名对象,匿名对象被析构
	cout << "------2-----" << endl;
	Location m2 = Location(55, 66);//初始化操作 Location(55, 66)会产生匿名对象,匿名对象转正，不会被析构
	cout << "------3-----" << endl;
}

运行结果：

void objplay6()
{
	Location(77, 88);  //直接调用构造函数，会产生匿名对象，临时匿名对象的生命周期  
	cout << "------1-----" << endl;
}

void test()
{
	//objplay2();
	//objplay3();
	//objplay4();
	//objplay5();
	objplay6();

}
#endif