深淺復制是在C++編程中。對於類對象來說，內部有各種類型的成員變量，在復制過程中會出現問題。
在指針的情況下，淺拷貝只是添加了壹個指向現有內存的指針，而深拷貝添加了壹個指針並申請了壹個新內存，這樣添加的指針就指向了新內存。
char * _ ptr
int _ countRef
用_countRef監控這個空間，在壹直有指針指向這個空間的時候不釋放，等到引用計數為0的時候再釋放，這樣就避免了剛剛出現的問題。具體代碼如下:
# include & ltiostream & gt
使用命名空間std
類別字符串
{
公共:
String(const char* ptr = " ")
:_countRef(new int(1))
{
if (ptr == NULL)
{
_ptr =新字符；
* _ ptr = ' \ 0
}
其他
{
_ ptr = new char[strlen(ptr)+1]；
strcpy(_ptr，ptr)；
}
* _ count ref = 1；
}
字符串(常量字符串& amps)
:_ ptr(s . ptr)
，_countRef(法國_countRef)
{
++(* _ count ref)；
}
~字符串()
{
發布()；
}
無效釋放()
{
if ( - (*_countRef) == 0)
{
刪除[]_ ptr；
_ ptr = NULL
delete _ countRef
}
}
弦與弦。運算符=(常量字符串& amps)
{
if (_ptr！= s._ptr)
{
發布()；//檢查分配的對象並釋放它自己的指針。
_ ptr = s. _ ptr
_ countRef = s. _ countRef
++(* _ count ref)；
}
返回* this
}
私人:
char * _ ptr
int * _ countRef
};
寫入時復制需要時間來打開內存空間，因為它會釋放內存空間。所以，當我們不需要寫的時候，可以在不打開內存空間的情況下，通過淺拷貝來創建對象，只在需要寫的時候才打開內存空間。此方法是寫入時拷貝將寫入時拷貝添加到原始引用計數:
char運算符[](int index)
{
if((* _ count ref)& gt；1)//當引用計數大於1時，打開壹個新空間。
{
-(* _ count ref)；
_ count ref = new int(1)；
char * ptr = new char[strlen(_ ptr)+1]；
strcpy(ptr，_ ptr)；
_ ptr = ptr//讓指針指向新打開的空間。
}
return _ ptr[index]；
}
深度復制就是開辟壹個新的空間，讓新空間裏的內容和原空間裏的內容壹模壹樣，然後讓指針指向這個空間，這樣在解構的時候就不會多次釋放同壹個內存空間。
# include & ltiostream & gt
# include & lt字符串& gt
類別字符串
{
公共:
字符串(const char* pStr= " ")
{
if (pStr == NULL)
{
_pStr =新字符；
* _ pStr = ' \ 0
}
其他
{
_ pStr = new char[strlen(pStr)+1]；
strcpy(_pStr，pStr)；
}
}
字符串(常量字符串& amps)
:_ pStr(_ pStr = new char[strlen(s . _ pStr)+1])
{
strcpy(_pStr，s . _ pStr)；
}
弦與弦。運算符=(常量字符串& amps)
{
如果(這個！= & amps)
{
char * pTemp = new char[strlen(s . _ pStr)+1]；
strcpy(pTemp，s . _ pStr)；
刪除[]_ pStr；
_ pStr = pTemp
}
返回* this
}
~String() //析構函數
{
if (_pStr)
{
刪除[]_ pStr；
_ pStr = NULL
}
}
私人:
char * _ pStr
};
void FunTest()
{
string s 1 = " 1234 "；
字符串S2；
S2 = s 1；
字符串S3(S2)；
String s4 = " asahsg
}
int main()
{
FunTest()；
系統(“暫停”)；
返回0；
}
合理選擇合適的副本有利於提高代碼的效率。