1.c++編譯器會自動呼叫建構函式

//建構函式(與類名相同)
//解構函式：沒有引數也沒有任何返回型別，被自動呼叫
#include<iostream>
using namespace std;
class Test
{
public:
	Test();//無參建構函式
	~Test();//解構函式:先建立的物件後釋放
	void print()
	{
		cout << a << endl;
		cout << p << endl;
	}
private:
	int a;
	char *p;
};

Test::Test()//完成對屬性的初始化工作
{
	a = 10;
	p = (char*)malloc(sizeof(100));
	strcpy(p, "Rita");
	cout<< "我是建構函式" << endl;
}

Test::~Test()
{
	if (p != NULL)
	{
		free(p);
	}
	cout << "我是解構函式，我被呼叫了" << endl;
}
//給物件搭建一個平臺，研究物件的行為
void objplay()
{
	//先建立的物件後釋放
	Test t1;
	t1.print();
	printf("分隔符\n");
	Test t2;
	t2.print();
}
int main()
{
	objplay();
	system("pause");
	return 0;
}
 

分析：先呼叫t1的無參建構函式，再呼叫print(),再呼叫t2的無參建構函式，再呼叫print(),最後先呼叫t2的解構函式，因為分配的記憶體在棧裡，先入棧的後出棧，所以先定義的後釋放，後呼叫解構函式。

2.拷貝建構函式的呼叫（三種方法）

#include<iostream>
using namespace std;
//類的建構函式的分類：無參建構函式。有參建構函式。拷貝建構函式
class Test2
{
public:
	Test2()//無參建構函式
	{
		m_a = 0;
		m_b = 0;
		cout << "無參建構函式" << endl;
	}
	Test2(int a)
	{
		m_a = a;
		m_b = 0;
	}
	Test2(int a, int b)
	{
		m_a = a; m_b = b;
		cout << "有參建構函式"<< endl;
	}
	//copy建構函式
	Test2(const Test2& obj)
	{
		cout << "我也是建構函式"<< endl;
	}
public:
	void print()
	{
		cout << "普通成員函式"<< endl;
	}
private:
	int m_a;
	char m_b;
};

int main04()//呼叫無參建構函式
{
	Test2 t1;
	system("pause");
	return 0;
}
int main()//呼叫有參建構函式
{
	//1.括號法
	Test2 t1(1, 2);//呼叫引數建構函式，c++編譯器自動呼叫
	t1.print();
	//2.=號法
	Test2 t2 = (1, 2, 3, 4, 5);//= c++對等號符功能增強,c++編譯器自動的呼叫建構函式
	Test2 t3 = 5;
	//3.直接呼叫建構函式，手動的呼叫建構函式
	Test2 t4 = Test2(1, 2);//匿名物件的去和留，後面會說
	t1 = t4;//賦值操作：把t4copy給t1，物件的初始化和物件的賦值是兩個不同的概念

	system("pause");
	return 0;
}
 

3.拷貝建構函式的呼叫

#include<iostream>
using namespace std;
//建構函式的呼叫
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)
	{
		m_a = a; m_b = b;
		cout << "有參建構函式" << endl;
	}
	//copy建構函式
	Test4(const Test4& obj)
	{
		cout << "我也是建構函式" << endl;
		m_a = obj.m_a + 100;//雖然是拷貝建構函式，也不是完全拷貝，可以根據自己的意願拷貝（+100）
		m_b = obj.m_b + 100;
	}
public:
	void print()
	{
		cout << "普通成員函式" << endl;
		cout << m_a << m_b << endl;
	}
private:
	int m_a;
	int m_b;
};

int main06()
{
	Test4 t1(1, 2);
	Test4 t0(1, 2);
	t0 = t1;//不會呼叫拷貝建構函式
	//第一種呼叫方法
	Test4 t2 = t1;//用t1初始化t2，此時會呼叫拷貝建構函式
	t2.print();

	system("pause");
	return 0;
}
//第二種呼叫時機
int main()
{
	Test4 t1(1, 2);
	Test4 t0(1, 2);
	Test4 t2(t1);// t1初始化t2，此時會呼叫拷貝建構函式
	t2.print();

	system("pause");
	return 0;
}
 

4.形參是一個元素，b實參去初始化形參p,會呼叫copy建構函式

#include<iostream>
using namespace std;
class Location
{
public:
	Location(int xx = 0,int yy=0)
	{
		X = xx;
		Y = yy;
		cout << "Constructor Object\n" << endl;
	}
	//copy建構函式完成物件的初始化
	Location(const Location& obj)
	{
		X = obj.X;
		Y = obj.Y;
	}
	~Location()
	{
		cout << "Destroyed\n" << endl;
	}
	int getX()
	{
		return X;
	}
	int getY()
	{
		return Y;
	}
private:
	int X;
	int Y;
};
//形參是一個元素(不是指標也不是引用)，當呼叫此函式時，c++編譯器會自動呼叫copy建構函式，用實參初始化形參
void f(Location p)
{
	cout << p.getX() << endl;
}
void playobj()
{
	Location a(1, 2);
	Location b = a;
	cout << "物件初始化完畢" << endl;
	f(b);
}
int main()
{
	playobj();
	system("pause");
	return 0;
}

5.關於匿名物件的去和留（匿名物件是否會被析構）

#include<iostream>
using namespace std;
class Location
{
public:
	Location(int xx = 0, int yy = 0)
	{
		X = xx;
		Y = yy;
		cout << "Constructor Object\n" << endl;
	}
	//copy建構函式完成物件的初始化
	Location(const Location& obj)
	{
		X = obj.X;
		Y = obj.Y;
	}
	~Location()
	{
		cout << "Destroyed\n" << endl;
	}
	int getX()
	{
		return X;
	}
	int getY()
	{
		return Y;
	}
private:
	int X;
	int Y;
};
//g()函式 返回一個元素
//結論1.函式的返回值是一個元素（複雜資料型別），返回的是一個新的匿名物件
//如果用匿名物件初始化另一個同類型物件，匿名物件轉化成有名物件，不會被析構
//如果匿名物件賦值給另一個同類型物件，匿名物件被析構
Location g()
{
	Location A(1, 2);
	return A;//返回一個新的物件，沒有名字
}
void objPlay1()
{
	g();
}
void objPlay2()
{
	//用匿名物件初始化m，此時c++編譯器直接把匿名物件扶正,不會被析構
	Location m = g();
	cout << m.getX() << endl;
}
void objPlay3()
{
	//用匿名物件賦值給m2之後，匿名物件被析構
	Location m2(1, 2);
	m2 = g();//這不是初始化，這是賦值
	cout << m2.getX() << endl;
}
int main()
{
	//objPlay1();//執行結果1.Constructor Object2.Destroyed3.Destroyed
	//objPlay2();//執行結果1.Constructor Object2.Destroyed(析構A)3. 1  4.Destroyed（析構m）
	objPlay3();//執行結果1.Constructor Object（建立m2）2.Constructor Object（建立A）3.Destroyed（析構A）4.Destroyed（析構匿名物件）5.  1   6..Destroyed（析構m2）
	system("pause");
	return 0;
}