C++拷贝构造函数的调用时机

c++中为我们提供了拷贝构造函数这一概念，这些天复习C++知识点，稍做总结。以下列出了拷贝构造函数的4种调用时机。

1.使用一个对象t1 给另一个对象t2 初始化时  Test2 t1(1, 2);    Test2 t2 = t1;

2.或者使用 括号的方法 Test2 t3(t1);

#include "iostream"

using namespace std;

class Test2
{
private:
	int m_a;
	int m_b;
public:
	Test2()       //无参构造函数
	{
		cout << "无参构造函数" << endl;
	}
	Test2(int a)
	{
		m_a = a;        //一个参数
		cout << "一个参数的有参构造函数" << endl;
	}
	Test2(int a, int b)          //有参构造函数   两个参数
	{
		m_a = a;
		m_b = b;
		cout << "两个参数的有参构造函数" << endl;
	}
	~Test2()                      //析构函数
	{
		cout << "析构函数" << endl;
	}
	Test2(const Test2 &obj)
	{
		cout << "我也是构造函数，拷贝" << endl;
		m_a = obj.m_a + 100;
		m_b = obj.m_b  + 100;
	}

	void printF()
	{
		cout << "m_a = " << m_a << endl;
		cout << "m_b = " << m_b << endl;

	}
};

void main31()
{
	//第一种调用方法
	Test2 t1(1, 2);
	Test2 t2 = t1;              //用t1对象 初始化  t2对象     调用拷贝构造函数
	t2.printF();

	//第二种调用方法
	Test2 t3(t1);
	t3.printF();

	//Test2 t0(3, 4);
	//t1 = t0;                          //这样写是用t0对象  给t1对象  赋值  和初始化是两个概念  赋值不会调用拷贝构造函数
	//t1.printF();

	system("pause");
}

3.用实参c  初始化形参p  这种情况会调用拷贝构造函数Location c(2, 3);   Print(c);  

#include "iostream"
using namespace std;

class Location
{
private:
	int m_a;
	int m_b;
public:
	int GetA()
	{
		return m_a;
	}
	Location(int a, int b)             //构造函数
	{
		m_a = a;
		m_b = b;
		cout << "我是构造函数" << endl;
	}
	~Location()                          //析构函数
	{ 
		cout << "我是析构函数" << endl;
	}
	Location(const Location &obj)
	{
		cout << "我是拷贝构造函数，我也是一种构造函数" << endl;
	}
};

void Print(Location p)
{
	cout << p.GetA() << endl;
}


void main()
{
	Location a(1, 2);        //初始化 对象a  调用构造函数
	//Location b = a;           //用a对象初始化b对象    调用拷贝构造函数

	Location c(2, 3);
	Print(c);                        //用实参c  初始化形参p  这种情况会调用拷贝构造函数

	system("pause");
}

4.当函数返回匿名对象时调用匿名对象的拷贝构造函数。

#include "iostream"
using namespace std;

class Location
{
private:
	int m_a;
	int m_b;
public:
	int GetA()
	{
		return m_a;
	}
	Location(int a, int b)             //构造函数
	{
		m_a = a;
		m_b = b;
		cout << "我是构造函数" << endl;
	}
	~Location()                          //析构函数
	{
		cout << "我是析构函数" << endl;
	}
	Location(const Location &obj)
	{
		cout << "我是拷贝构造函数，我也是一种构造函数" << endl;
	}
};

Location g()
{
	Location A(1, 2);
	return A;                   //调用时机4    函数g() 返回一个匿名对象, 此时调用拷贝构造函数
}                                   
                                    //因为A是局部变量，返回局部变量将产生问题，所以返回匿名对象
                                    //析构函数调用两次，一次析构A，一次析构匿名对象。
void objplay()
{
	g();                          //因为匿名对象在这里没有被使用所以立即释放。
}
void objplay1()
{
	Location B = g();         //用匿名对象初始化B  匿名对象直接转正  不会被析构
}
void objplay2()
{
	Location C(4, 5);         
	C = g();                 //用匿名对象给对象C赋值   这种情况匿名对象会被析构，
}                                //注意赋值和初始化的区别

void main()
{
	objplay();
	system("pause");
}