C++教程:C++拷貝構造函數

2020-05-23 14:25:55

字體：大中小

來源：轉載

供稿：網友

我們在程序中常常需要把一些數據復制一份出來備作它用。對于只有基本類型變量的程序來說，這是輕而易舉就能做到的——新建一個臨時變量，用一句賦值語句就能完成。但如果它是一個有著許許多多成員數據的對象，這就會非常麻煩。最要命的是，那些成員數據還是私有的，根本無法直接訪問或修改。那么這時候，我們怎么“克隆”出一個和原來的對象相同的新對象呢？

拷貝構造函數

我們知道，構造函數是可以帶上參數的，這些參數可以是整型、字符型等等，那么它可不可以是一個對象類型呢？我們把一個原來的對象丟給構造函數，然后讓它給我們造一個相同的對象，是否可以呢？下面我們就來試試看：（程序15.4.1）
//node.h
#include <iostream>
using namespace std;
class Node//定義一個鏈表結點類
{
public:
Node();//構造函數的聲明
Node(int i,char c='0');//構造函數重載1
Node(int i,char c,Node *p,Node *n);//構造函數重載2
Node(Node &n);//結點拷貝構造函數，&表示引用
int readi() const;//讀取idata
char readc() const;//讀取cdata
Node * readp() const;//讀取上一個結點的位置
Node * readn() const;//讀取下一個結點的位置
bool set(int i);//重載，通過該函數修改idata
bool set(char c);//重載，通過該函數修改cdata
bool setp(Node *p);//通過該函數設置前驅結點
bool setn(Node *n);//通過該函數設置后繼結點
private:
int idata;//存儲數據保密
char cdata;//存儲數據保密
Node *prior;//前驅結點的存儲位置保密
Node *next;//后繼結點的存儲位置保密
};
//未定義的函數與程序15.2.2相同
Node::Node(Node &n)
{
idata=n.idata;//可以讀出同類對象的私有成員數據
cdata=n.cdata;
prior=n.prior;
next=n.next;
}
//linklist.h
#include "node.h"//需要使用鏈表結點類
#include <iostream>
using namespace std;
class Linklist
{
public:
Linklist(int i,char c);//鏈表類構造函數
Linklist(Linklist &l);//鏈表拷貝構造函數，&表示引用
bool Locate(int i);//根據整數查找結點
bool Locate(char c);//根據字符查找結點
bool Insert(int i=0,char c='0');//在當前結點之后插入結點
bool Delete();//刪除當前結點
void Show();//顯示鏈表所有數據
void Destroy();//清除整個鏈表
private:
Node head;//頭結點
Node * pcurrent;//當前結點指針
};
//未定義的函數與程序15.3相同
Linklist::Linklist(Linklist &l):head(l.head)//調用結點的拷貝構造函數來初始化head
{
cout<<"Linklist cloner running..." <<endl;
pcurrent=l.pcurrent;//指針數據可以直接賦值
}
//main.cpp
#include "Linklist.h"
#include <iostream>
using namespace std;
int main()
{
int tempi;
char tempc;
cout <<"請輸入一個整數和一個字符：" <<endl;
cin >>tempi >>tempc;
Linklist a(tempi,tempc);
a.Locate(tempi);
a.Insert(1,'C');
a.Insert(2,'B');
a.Insert(3,'F');
cout <<"After Insert" <<endl;
a.Show();
a.Locate('B');
a.Delete();
cout <<"After Delete" <<endl;
a.Show();
Linklist b(a);//創建一個鏈表b，并且將鏈表a復制到鏈表b
cout <<"This is Linklist b" <<endl;
b.Show();//顯示b鏈表中的內容
a.Destroy();
cout <<"After Destroy" <<endl;
a.Show();
return 0;
}

運行結果：
請輸入一個整數和一個字符：
4 G
Node constructor is running...
Linklist constructor is running...
Node constructor is running...
Node constructor is running...
Node constructor is running...
After Insert
4 G
3 F
2 B
1 C
After Delete
4 G
3 F
1 C
Linklist cloner running...
This is Linklist b
4 G
3 F
1 C
After Destroy
4 G
根據程序運行的結果，我們發現輸出鏈表b的內容的確和鏈表a一樣了，并且我們可以得到三個結論：
（1）拷貝構造函數可以讀出相同類對象的私有成員數據；
（2）拷貝構造函數的實質是把參數的成員數據一一復制到新的對象中；
（3）拷貝構造函數也是構造函數的一種重載。

默認拷貝構造函數

我們已經知道構造函數有默認構造函數，其實拷貝構造函數也有默認的拷貝構造函數。所謂默認拷貝構造函數是指，用戶沒有自己定義拷貝構造函數時，系統自動給出的一個拷貝構造函數。默認拷貝構造函數的功能是將對象的成員數據一一賦值給新創建的對象的成員數據，如果某些成員數據本身就是對象，則自動調用它們的拷貝構造函數或默認拷貝構造函數。

拷貝構造函數存在的意義

既然上面說到，默認拷貝構造函數已經能夠滿足我們大多數的需要，那么自定義的拷貝構造函數是否就可以不用存在了呢？我們修改一下程序15.4.1的main.cpp文件，看看拷貝構造函數到底有什么意義：
#include "Linklist.h"
#include <iostream>
using namespace std;
int main()
{
int tempi;
char tempc;
cout <<"請輸入一個整數和一個字符：" <<endl;
cin >>tempi >>tempc;
Linklist a(tempi,tempc);
a.Locate(tempi);
a.Insert(1,'C');
a.Insert(2,'B');
a.Insert(3,'F');
cout <<"After Insert" <<endl;
a.Show();
a.Locate('B');
a.Delete();
cout <<"After Delete" <<endl;
a.Show();
Linklist b(a);
cout <<"This is Linklist B" <<endl;
b.Show();
a.Destroy();
cout <<"After Destroy" <<endl;
a.Show();
cout <<"This is Linklist b" <<endl;
b.Show();//關鍵是在這里加了一條語句，讓它顯示b鏈表中的內容
return 0;
}
運行結果：

為什么顯示鏈表b的內容，卻導致了嚴重的錯誤呢？

這時我們就要來研究一下這個鏈表的結構了。在這個鏈表中，成員數據只有頭結點head和當前指針pcurrent，所有的結點都是通過new語句動態生成的。而程序15.4.1中的拷貝構造函數僅僅是簡單地將頭結點head和當前指針pcurrent復制了出來，所以一旦運行a.Destroy()之后，鏈表a頭結點之后的結點已經全部都刪除了，而鏈表b的頭結點還傻傻地指向原來a鏈表的結點。如果這時再訪問鏈表b，肯定就要出問題了。如下所示：

程序15.4.1中的拷貝構造函數僅僅是把成員數據拷貝了過來，卻沒有把動態申請的資源拷貝過來，我們把這種拷貝稱為淺拷貝。相對地，如果拷貝構造函數不僅把成員數據拷貝過來，連動態申請的資源也拷貝過來，我們則稱之為深拷貝。

下面我們來看如何實現深拷貝：（程序15.4.2）
//node.h同程序15.4.1
//linklist.h
#include "node.h"//需要使用鏈表結點類
#include <iostream>
using namespace std;
class Linklist
{
public:
Linklist(int i,char c);//鏈表類構造函數
Linklist(Linklist &l);//鏈表深拷貝構造函數
bool Locate(int i);//根據整數查找結點
bool Locate(char c);//根據字符查找結點
bool Insert(int i=0,char c='0');//在當前結點之后插入結點
bool Delete();//刪除當前結點
void Show();//顯示鏈表所有數據
void Destroy();//清除整個鏈表
private:
Node head;//頭結點
Node * pcurrent;//當前結點指針
};
//未定義的函數與程序15.3相同
Linklist::Linklist(Linklist &l):head(l.head)
{
cout<<"Linklist Deep cloner running..." <<endl;
pcurrent=&head;
Node * ptemp1=l.head.readn();//該指針用于指向原鏈表中被復制的結點
while(ptemp1!=NULL)
{
Node * ptemp2=new Node(ptemp1->readi(),ptemp1->readc(),pcurrent,NULL);//新建結點，并復制idata和cdata，思考為何這里不能直接用Node的拷貝構造函數？
pcurrent->setn(ptemp2);
pcurrent=pcurrent->readn();//指向表尾結點
ptemp1=ptemp1->readn();//指向下一個被復制結點
}
}
//main.cpp
#include "Linklist.h"
#include <iostream>
using namespace std;
int main()
{
int tempi;
char tempc;
cout <<"請輸入一個整數和一個字符：" <<endl;
cin >>tempi >>tempc;
Linklist a(tempi,tempc);
a.Locate(tempi);
a.Insert(1,'C');
a.Insert(2,'B');
a.Insert(3,'F');
cout <<"After Insert" <<endl;
a.Show();
a.Locate('B');
a.Delete();
cout <<"After Delete" <<endl;
a.Show();
Linklist b(a);//創建一個鏈表b，并且將鏈表a復制到鏈表b
cout <<"This is Linklist b" <<endl;
b.Show();
a.Destroy();
cout <<"After Destroy" <<endl;
a.Show();
cout <<"This is Linklist b" <<endl;
b.Show();//鏈表a被Destroy之后察看鏈表b的內容
return 0;
}

運行結果：
請輸入一個整數和一個字符：
4 G
Node constructor is running...
Linklist constructor is running...
Node constructor is running...
Node constructor is running...
Node constructor is running...
After Insert
4 G
3 F
2 B
1 C
After Delete
4 G
3 F
1 C
Linklist Deep cloner running...
Node constructor is running...
Node constructor is running...
This is Linklist b
4 G
3 F
1 C
After Destroy
4 G
This is Linklist b
4 G
3 F
1 C
我們看到，現在即使運行a.Destroy()之后，鏈表b里面的數據仍然能夠正常顯示。這是因為深拷貝構造函數是真正意義上的復制了鏈表a，并且使得鏈表a和鏈表b各自獨立，互不干擾。這才是自定義拷貝構造函數存在的重要意義。

上一篇：C++教程:C++析構函數詳解

下一篇：C++構造函數—構造函數的聲明與定義、帶參數的構造函數