//要寫一個賦值運算子函式，即過載賦值運算子，有兩種形式：類成員函式和友元函式；我們這裡用類成員函式的形式
#pragma once

class CMyString
{
public:
	//CMyString(void);//這個建構函式和CMyString(char* pdata = NULL)一定程度上重定義了，當定義
	                  //CMyString型別物件時,若都不傳參，即用CMyString A;不知道呼叫哪一個了；
	                  //但CMyString A(NULL)就可以，但還是有警告多次定義建構函式！但當把=NULL去掉就
	                  //不會重定義了，因為去掉後，該建構函式需要傳參才會被呼叫。
	~CMyString(void);
	//CMyString(char* pdata):m_pdata(pdata){}//這裡宣告和定義一起了（引數初始化列表）
	CMyString(char* pdata = NULL);//這裡是預設m_pdata為NULL，即CMyString A;那A.m_pdata = NULL;
	CMyString(const CMyString& str);//拷貝建構函式，加const是為了不改變引數的狀態
	                                //加&是為了避免呼叫拷貝建構函式時，由形參到實參呼叫拷貝建構函式
	                                //從而變成死迴圈！所以C++標準不允許拷貝建構函式傳值引數
	CMyString& operator =(const CMyString& str);//過載賦值運算子函式，引數為引用，避免從形參到實參呼叫
	                                            //一次拷貝建構函式，這是無謂消耗，避免
	                                            //只有返回一個引用才能連續賦值
public:
	char* m_pdata;

};     
 

#include "StdAfx.h"
#include "CMyString.h"

//CMyString::CMyString(void)
//{
//}

CMyString::~CMyString(void)
{
}
CMyString::CMyString(const CMyString& str)
{
	this->m_pdata = str.m_pdata;
}
CMyString::CMyString(char* pdata)//這裡不能加=NULL，否則會報重定義的錯誤
{
	this->m_pdata = pdata;
}
//CMyString& CMyString::operator =(const CMyString& str)//初級程式設計師做法，考慮點為：
//{                                              //1，判斷傳入的例項和當前例項是不是同一個例項，若是，直接返回  
//	                                           //2，是否釋放例項自身的記憶體，若忘記，會出現記憶體洩露
//	                                           //3，傳參是否為常量引用，為了高效，避免無謂消耗 
//	                                           //4，返回值是否為該型別的引用，為了可以連續賦值
//	if (this == &str)//若不判斷，那麼在釋放記憶體後，傳入引數也被釋放了，再也找不到賦值內容了。                         
//	{
//		return *this;  
//	}
//	else                                           
//    {
//		delete[] m_pdata;//釋放該例項的空間
//		m_pdata = NULL;//避免野指標
//		m_pdata = new char[strlen(str.m_pdata) + 1];
//		strcpy(m_pdata, str.m_pdata);
//		return *this;
//    }
//	                                         
//}                                              
//為什麼說是初級程式設計師呢？
//因為沒有考慮異常安全性原則，我們在分配記憶體之前就釋放了例項的記憶體，那麼若new char不成功，丟擲異常
//那麼m_pdata將是一個空指標，賦值沒成功不止，還把原來的自己丟了。
//該進！！！！！
//第一種是：讓一個區域性指標指向m_pdata，再new一個空間，若成再釋放這個區域性變數指向的空間
//主要看第二種：
CMyString& CMyString::operator =(const CMyString& str)
{
	if (this != &str)
	{
		CMyString str_temp(str);
		char* ptemp = str_temp.m_pdata;
		str_temp.m_pdata = m_pdata;
		m_pdata = ptemp;//就是把區域性變數m_pdata指向位置和該例項m_pdata指向位置互換
	}
	return *this;
}
//這好在哪呢？
//1，先建立一個臨時例項，若不成功，丟擲異常，不影響原來的自己，保證了異常安全性。
//2，若建立成功，str_temp是區域性變數，作用域在if中，出了if就自動呼叫解構函式，而我們
//把str_temp.m_pdata和原來自己的m_pdata互換了，這時候析構的就是原來自己的空間了。
 

#include "stdafx.h"
#include <iostream>
#include <string>
#include <sstream>
#include "CMyString.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	//CMyString A(NULL);
	char *a = new char[10];
	string temp = "hello!!";
	stringstream ss;
	ss << temp;
	ss >> a;
	CMyString A(a);
	//測試用例1
	CMyString B = A;
	printf("%s\n", B);
	//測試用例2
	CMyString C;
	C = B = A;
	//cout << C.m_pdata;//m_pdata改成public可以
	printf("%s\n", C);
	//測試用例3
	B = B;
	printf("%s", B);
	system("pause");
	return 0;
}
//輸出結果為：hello!!
//            hello!!
//            hello!!請按任意鍵繼續...