拷貝建構函式呼叫時機：

1、物件需要通過另外一個物件進行初始

     T t1(10, 20);T t2(0, 0);T t3 = t1; // 拷貝建構函式呼叫的時機一：T t4(t2);  // 拷貝建構函式呼叫的時機 二：

2、實參傳遞給形參時呼叫賦值建構函式 拷貝建構函式呼叫的時機三：

class T
{
public:
	T(int m, int n)
	{
		cout << "gouzao" << endl;
		a = m;
		b = n;
		c = 'q';
	}
	T(const T& obj)
	{
		cout << "fuzhi" << endl;
		a = obj.a + 10;
		b = obj.b - 5;
		c = obj.c;

	}
	~T()
	{
		cout << "xigou" << endl;
	}

	int a;
	int  b;
	char c;
	int get_A()
	{
		return  a;
	} 
	int get_B()
	{
		return  b;
	}
	
};
void f(T t)
{
	t.a = 100;
	t.b = 102;

}

{f(t1)};

3 返回匿名物件時，物件以值傳遞的方式從函式返回

T  go()//
{
T A(100,102);

return A;  //返回匿名物件
}

//匿名物件的去和留
//如果用匿名物件初始化一個同類型的物件，匿名物件轉化為有名物件 T m1=go();該物件的生命週期結束時才析構
//如果用匿名物件賦值 給另一個同類型的物件，匿名物件立即被析構  T m2(10,9);m2=go()

二：

淺拷貝與深拷貝 解析：

#define  _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<string>

using

class Name

{

public:

Name(const char*myp)

{

len = strlen(myp);

p = (char*)malloc(len+1);

strcpy(p,myp);

}

~Name()

{

if (p != NULL)

free(p);

p = NULL;

len = 0;

}

private:

char* p;

int len;

};

void mainplay()

{

Name obj1("abcdef");

Name obj2 = obj1;//問題：在執行這句話時，當函式體結束時，要析構物件(且析構兩次)，同一個記憶體地址被同時ｆｒｅｅ兩次，所以會出錯

//用obj1來初始化obj2,要執行拷貝建構函式

//由於自己沒有定義拷貝建構函式，所以編譯器會自動呼叫預設的拷貝建構函式，編譯器提供的預設的拷貝建構函式是淺拷貝

//淺拷貝是指：只賦值了指標的值，而指標所指向的記憶體空間的內容沒有被賦值，淺拷貝的結果是obj1和obj2同時指向了同一個記憶體空間

編譯器提供的預設的拷貝建構函式，就是把指標的值（即obj的屬性值 char* p,int len）賦值給obj2,而並沒有開闢一個新的記憶體空間，把記憶體空間的內容(abcdefg)賦值給obj2.所以導致同一個記憶體空間被同時析構兩次時出錯,

解決方案：  深拷貝建構函式，自己寫拷貝建構函式，在開闢一個新的 記憶體空間，然後把空間中內容拷貝到新的記憶體空間

Name(const Name&obj)

{

len = strlen(obj.p);

p = (char*)malloc(len + 1);

strcpy(p,obj.p);

}

Name obj3("obj3");

obj3 = obj1;

Obj1和obj3指向了統一記憶體空間，使程式崩潰。

解決等號運算子與淺拷貝帶來的問題方法就是：過載等號運算子，在函式中重新開闢一段記憶體空間為obj3物件所用，但是由於之前obj3已經開闢了記憶體空間，為了防止記憶體洩漏，，需要先對記憶體空間進行釋放，然後再重新建新的記憶體空間。

Name& operator=(Name&obj)

{

if (p != NULL)

{

delete[] p;

p = NULL;

len = 0;

}

p = (char*)malloc(strlen(obj.p)+1);

if (p != NULL)

strcpy(p,obj.p);

len = obj.len;

return *this;

}

void main()

{mainplay();

cout << "successful" << endl;

}

拷貝建構函式的幾個細節

1. 拷貝建構函式裡能呼叫private成員變數嗎?
解答：這個問題是在網上見的，當時一下子有點暈。其時從名子我們就知道拷貝建構函式其時就是一個特殊的建構函式，操作的還是自己類的成員變數，所以不受private的限制。

2. 以下函式哪個是拷貝建構函式,為什麼?

1. X::X(const X&);      
2. X::X(X);      
3. X::X(X&, int a=1);      
4. X::X(X&, int a=1, int b=2);  

解答：對於一個類X, 如果一個建構函式的第一個引數是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且沒有其他引數或其他引數都有預設值,那麼這個函式是拷貝建構函式.

1. X::X(const X&);  //是拷貝建構函式    
2. X::X(X&, int=1); //是拷貝建構函式   
3. X::X(X&, int a=1, int b=2); //當然也是拷貝建構函式

3. 一個類中可以存在多於一個的拷貝建構函式嗎?
解答：類中可以存在超過一個拷貝建構函式。

1. class X {   
2. public:         
3.   X(const X&);      // const 的拷貝構造
4.   X(X&);            // 非const的拷貝構造
5. };  

注意,如果一個類中只存在一個引數為 X& 的拷貝建構函式,那麼就不能使用const X或volatile X的物件實行拷貝初始化.

1. class X {      
2. public:  
3.   X();      
4.   X(X&);  
5. };      
6. const X cx;      
7. X x = cx;    // error

如果一個類中沒有定義拷貝建構函式,那麼編譯器會自動產生一個預設的拷貝建構函式。
這個預設的引數可能為 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪一個。