1－什么時(shí)候會(huì)用到拷貝構(gòu)造函數(shù)？
           當(dāng)任何你想復(fù)印東西的時(shí)候，而不管東西被復(fù)印成什么樣子。即任何你想利用一個(gè)已有的類實(shí)例給另一個(gè)類實(shí)例賦值時(shí)，這種賦值可能是顯式的，也可能是隱式的
顯式：classa_1=class_2;
隱式：函數(shù)的形參有用到類對(duì)象卻沒有用引用或傳址技術(shù)時(shí)
               函數(shù)的返回值是一個(gè)對(duì)象也沒有應(yīng)用傳址技術(shù)時(shí)
2－什么時(shí)候有必要用拷貝構(gòu)造函數(shù)？
上述3種情況，如果沒有涉及到深拷貝問(wèn)題，就沒有必要自己來(lái)編寫拷貝構(gòu)造函數(shù)，編譯器有默認(rèn)的可以很完美的完成任務(wù)
還一種情況就是變態(tài)的拷貝：在拷內(nèi)過(guò)程中進(jìn)行縮放，放大等處理，不過(guò)沒什么用

//關(guān)于深拷貝以下是引用：traceback:http://www./blog/user1/bachelor/archives/2006/375.html

關(guān)于深拷貝
如果一個(gè)類中含有指針成員變量，則在利用一個(gè)已存在對(duì)象構(gòu)造新的對(duì)象時(shí)，就會(huì)面臨兩種選擇：深拷貝和淺拷貝。
       淺拷貝只是將對(duì)象間對(duì)應(yīng)的指針成員變量進(jìn)行簡(jiǎn)單的拷貝，即拷貝結(jié)束后新舊對(duì)象的指針指向相同的資源（指針的值是相同的）；這種拷貝會(huì)導(dǎo)致對(duì)象的成員不可用，如下例：
        class Person
        {
           public :
           //....
           char * home;//the person's home
           void SetHome(char * str)
           {home = str;}
           ~Person()
            {
              //...
              delete [] home;
            }
        }
       //....
       char * place = new char [20];
       strcpy(place,"China");
       Person *A = new Person();
       A->SetHome(place);
   
       Person * B= Person(A);
       delete A;
      //....
      此時(shí)對(duì)象A 和對(duì)象B的成員home值相同,如果A對(duì)象 destroy，則對(duì)象B的成員home指向的地址變?yōu)椴豢捎茫▽?duì)象A撤銷時(shí)將home指向的資源釋放了）。
       深拷貝是相對(duì)于淺拷貝而言的，為了避免上述情況的發(fā)生，將上例中的代碼改造：對(duì)象拷貝時(shí)將指針指向的內(nèi)容拷貝，代碼如下：
      class Person
        {
           public :
           //....
           char * home;//the person's home
           void SetHome(char * str)
           {home = str;}
       
           Person & Person(const Person & per)
           {
                //...
                if(* this == per)//copy itself
        return *this;
                home = new char[strlen(per.home) +1];//alloc new memory
       strcpy(home,per.home);
       return * this;
           }
           ~Person()
            {
              //...
              delete [] home;
            }
        }
     深拷貝之后，新舊對(duì)象的home成員指向的內(nèi)容的值相同，而其自身的值不同。這樣就可避免出現(xiàn)其中之一
     destroy 之后，另一對(duì)象的home成員不可用。
     但是，此種開辟新的內(nèi)存區(qū)域然后賦值拷貝的方法在面臨指針成員指向的數(shù)據(jù)量很大時(shí)出現(xiàn)效率低下的問(wèn)題，因此又有下面的處理方法：為指針保留引用計(jì)數(shù)（reference counting）。
     當(dāng)類每次拷貝這個(gè)指針時(shí)，就增加它的計(jì)數(shù)；對(duì)象destroy時(shí)檢察指針的引用計(jì)數(shù)，如果為0就刪除其指向的資源，否則計(jì)數(shù)減小。如果指針?biāo)笖?shù)據(jù)相對(duì)恒定是，指針引用計(jì)數(shù)尤為有效。而且在數(shù)據(jù)量龐大的時(shí)候，可以有較高的執(zhí)行效率。
      類示例代碼如下：

//一個(gè)引用計(jì)數(shù)器很容易作為一個(gè)類來(lái)完成
//用于帶一個(gè)引用計(jì)數(shù)值得void指針的類
class VoidRefPtr
{
public:
     //constructor allocates memory for data
     VoidRefPtr(void * pData,int nSize)
     {
      ptr = malloc(nSize);
      memcpy(ptr,pData,nSize);
      nCount = 1;
     }

     //increment the reference count
     VoidRefPtr * Ref()
     {
      nCount ++;
      return this;
     }

     //decrement the count and delete if zero
     void Derf()
     {
      if(!--nCount)
       delete this;
     }

     ~VoidRefPtr()
     {
      delete ptr
     }

     void * ptr()
     {
      return ptr
     }
private:
     void * ptr;//the data
     unsigned int nCount;//the reference count

};

//這個(gè)類包含了一個(gè)實(shí)際的指針和用于對(duì)引用計(jì)數(shù)器自加自減的成員函數(shù)
//當(dāng)引用計(jì)數(shù)器減到零時(shí)，對(duì)象撤銷自身。
class RefcountCharPtr
{
public:
RefcountCharPtr(const char * pData ="")
{
     //constructor creates a ref pointer
     pRef = new VoidRefPtr((void *)pData,strlen(pData)+1);
}

RefcountCharPtr(const RefcountCharPtr &a)
{
     //copy constructor increments ref count
     pRef = a.pRef->Ref();
}

~RefcountCharPtr()
{
     //destructor decrements ref count
     pRef ->Derf();
}

const RefcountCharPtr & operator = (const RefcountCharPtr & a)
{
     //asignment
     //decrement ref count of existing pointer
     pRef->Derf();
     //increment that of assigned pointer
     pRef = a.pRef->Ref();
     return * this;
}

RefcountCharPtr & operator =(const char * pData)
{
     //char string assignment
     //decrement ref count of existing pointer
     pRef->Derf();
     //make new pointer
     pRef = new VoidRefPtr((void *)pData,strlen(pData)+1);
     return *this;
}

//type conversion to a char string
operator const char * ()
{
     return (char * )pRef->ptr();
}

protected:
private:
VoidRefPtr * pRef;
};
     一個(gè)同學(xué)給出了一個(gè)類似的實(shí)現(xiàn)：
      class RefData
{
public:
     RefData(char *s)
     {
      data = new String(s);
     }
int refCount;
String *data;
};

class MyString
{
public:
     MyString(const char *s = "");
//...
//...
private:
     RefData * value; // 私有指針變量
};

MyString::MyString(const char *s = ""):value(new RefData(s))
{
}

MyString & MyString::operator=(const MyString & str)
{
if (value == str.value) //如果是自己復(fù)制給自己
     return *this;
if (--(value->refCount) == 0)
     delete value;
value = s.value; // 只拷貝指針
++(value->refCount);
return *this;
}

char & MyString::operator[](int dex) //改變值的時(shí)候
{
if (value->refCount >1)
{
     --value->refCount;
     value = new RefData(value->data)
}
return value->data[index];
}

//測(cè)試示例
int main()
{
MyString s1 ="hello";
char *p = &s1[1];
MyString s2 = s1;
*p = 'x';
}

     雖然引用計(jì)數(shù)的處理方法貌似不錯(cuò)，但是其亦存在其弊端：在多線程的條件下，其執(zhí)行效率尤為低下。具體參見（Herb Shutter的在C++ Report雜志中的Guru專欄以及整理后出版的《More Exceptional C++》中專門的討論）。
    
     最近在看設(shè)計(jì)模式的一些東東，偶然又發(fā)現(xiàn)了下面的一段：
     下面是一些可以使用Proxy模式的常見情況：
     ...
     4)智能指引（smart reference）--取代了簡(jiǎn)單的指針，它在訪問(wèn)對(duì)象時(shí)執(zhí)行一些附加操作。它的典型用途包括：
      對(duì)指向?qū)嶋H對(duì)象的引用計(jì)數(shù)，這樣當(dāng)該對(duì)象沒有引用時(shí)，可以自動(dòng)釋放它（也稱為 smartpointers[Ede92]）.
      當(dāng)?shù)谝淮我靡粋€(gè)持久對(duì)象時(shí)，將它裝入內(nèi)存。
      在訪問(wèn)一個(gè)實(shí)際對(duì)象前，檢察是否已經(jīng)鎖定了它，以確保其他對(duì)象不能改變它。
      以上的敘述的用途好像有些像引用計(jì)數(shù)，但是具體如何，現(xiàn)在偶還不是很清楚，準(zhǔn)備將兩者放在一起，看其聯(lián)系和區(qū)別究竟如何。