C++複製建構函式

標籤（空格分隔）： C++

我們經常會需要用一個也已經存在的物件，去初始化新的物件，這時就需要一種特殊的建構函式——複製建構函式；
預設的複製建構函式可以實現對應資料成員一一複製；

複製建構函式定義

複製建構函式是一種特殊的建構函式，其形參為本類的物件引用。作用是用一個已存在的物件去初始化同類型的新物件。

class 類名 {
public :
    類名（形參）；//建構函式
    類名（const 類名 &物件名）；//複製建構函式
    // ...
};

類名::類（ const 類名 &物件名）//複製建構函式的實現
{ 函式體 }
 

隱含的複製建構函式

• 如果程式設計師沒有為類宣告拷貝初始化建構函式，則編譯器自己生成一個隱含的複製建構函式。
• 這個建構函式執行的功能是：用作為初始值的物件的每個資料成員的值，初始化將要建立的物件的對應資料成員。

“=delete”

如果不希望物件被複制構造
▫ C++98做法：將複製建構函式宣告為private，並且不提供函式的實現。
▫ C++11做法：用“=delete”指示編譯器不生成預設複製建構函式。
例：

class Point { //Point 類的定義
public:
    Point(int xx=0, int yy=0) { x = xx; y = yy; } //建構函式，內聯
 

    Point(const Point& p) =delete; //指示編譯器不生成預設複製建構函式
private:
    int x, y; //私有資料
};

複製建構函式被呼叫的三種情況

• 定義一個物件時，以本類另一個物件作為初始值，發生複製構造；
• 如果函式的形參是類的物件，呼叫函式時，將使用實參物件初始化形參物件，發生複製構造；
• 如果函式的返回值是類的物件，函式執行完成返回主調函式時，將使用return語句中的物件初始化一個臨時無名物件，傳遞給主調函式，此時發生複製構造。

定義一個物件時，以本類另一個物件作為初始值，發生複製構造

class Point{
    public
 
:
        Point(int a, int b){x=a; y=b;} // 建構函式 
        Point(const Point & p); // 複製建構函式
        void setX(int a){ x = a; } 
        void setY(int b){ y = b; }
        int getX(){ return x; }
        int getY(){ return y; }
    private:
        int x,y;
};

// 複製建構函式的實現 
Point::Point(const Point &p){
    x = p.x;
    y = p.y;
}

// 主函式
int main(int argc, char** argv) {
    Point point1(2,3);
    cout << point1.getX() << endl;
    Point point2(point1);
    cout << point2.getX() << endl;
    return 0;
}

物件以值傳遞的方式傳入函式引數

class Point{
    public:
        Point(int a, int b){x=a; y=b;} // 建構函式 
        Point(const Point & p); //複製建構函式
        void setX(int a){ x = a; } 
        void setY(int b){ y = b; }
        int getX(){ return x; }
        int getY(){ return y; }
    private:
        int x,y;
};

// 複製建構函式的實現 
Point::Point(const Point &p){
    x = p.x;
    y = p.y;
}

// 形參為Point類物件void
void function1(Point p){
    cout << p.getY() << endl;
}

// 主函式 
int main(int argc, char** argv) {
    Point point1(2,3);
    function1(point1);
    return 0;
}

物件以值傳遞的方式從函式返回

class Point{
    public:
        Point(int a, int b){x=a; y=b;} // 建構函式 
        Point(const Point & p); //複製建構函式
        void setX(int a){ x = a; } 
        void setY(int b){ y = b; }
        int getX(){ return x; }
        int getY(){ return y; }
    private:
        int x,y;
};

// 複製建構函式的實現 
Point::Point(const Point &p){
    x = p.x;
    y = p.y;
}

//返回值為Point類物件
Point function2(){
    Point a(4, 5);
    return a;
} 

// 主函式 
int main(int argc, char** argv) {
    Point c = function2();
    cout << c.getY() << endl;
    return 0;
}

淺拷貝和深拷貝

預設拷貝建構函式

很多時候在我們都不知道拷貝建構函式的情況下，傳遞物件給函式引數或者函式返回物件都能很好的進行，這是因為編譯器會給我們自動產生一個拷貝建構函式，這就是“預設拷貝建構函式”，這個建構函式很簡單，僅僅使用“老物件”的資料成員的值對“新物件”的資料成員一一進行賦值，它一般具有以下形式：

Point(const Point & p){
    x = p.x;
    y = p.y;
}

當然，以上程式碼不用我們編寫，編譯器會為我們自動生成。

但是問題來了，請看下面問題：

class Point{
    public:
        Point(int a, int b); // 建構函式 
        ~Point(); // 解構函式 
        Point(const Point & p); //複製建構函式
        static int showCount(); // 顯示count數 
    private:
        int x,y;
        static int count;
};

// 建構函式 
Point::Point(int a, int b){
    x = a;
    y = b;
    count++;
}

// 解構函式
Point::~Point(){
    count--;
} 

// 複製建構函式的實現 
Point::Point(const Point &p){
    x = p.x;
    y = p.y;
}

// 顯示count數 
int Point::showCount(){
    return count; 
} 

// 初始化計數器 
int Point::count = 0;

// 主函式 
int main(int argc, char** argv) {
    Point point1(2,3);
    cout << "count=" << Point::showCount() << endl;
    Point point2(point1);
    cout << "count=" << Point::showCount() << endl;

    return 0;
}

這段程式碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函式中，首先建立物件point1，輸出此時的物件個數，然後使用rect1複製出物件point2，再輸出此時的物件個數，按照理解，此時應該有兩個物件存在，但實際程式執行時，輸出的都是1，反應出只有1個物件。此外，在銷燬物件時，由於會呼叫銷燬兩個物件，類的解構函式會呼叫兩次，此時的計數器將變為負數。

問題來了：拷貝建構函式沒有處理靜態資料成員

重新編寫程式碼如下：

class Point{
    public:
        Point(int a, int b); // 建構函式 
        ~Point(); // 解構函式 
        Point(const Point & p); //複製建構函式
        static int showCount(); // 顯示count數 
    private:
        int x,y;
        static int count;
};

// 建構函式 
Point::Point(int a, int b){
    x = a;
    y = b;
    count++;
}

// 解構函式
Point::~Point(){
    count--;
} 

// 複製建構函式的實現 
Point::Point(const Point &p){
    x = p.x;
    y = p.y;
    count++;
}

// 顯示count數 
int Point::showCount(){
    return count; 
} 

// 初始化計數器 
int Point::count = 0;

// 主函式 
int main(int argc, char** argv) {
    Point point1(2,3);
    cout << "count=" << Point::showCount() << endl;
    Point point2(point1);
    cout << "count=" << Point::showCount() << endl;

    return 0;
}

問題解決

淺拷貝

所謂淺拷貝，指的是在物件複製時，只對物件中的資料成員進行簡單的賦值，預設拷貝建構函式執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦物件存在了動態成員，那麼淺拷貝就會出問題了，讓我們考慮如下一段程式碼：

class Point{
    public:
        Point(int a, int b); // 建構函式 
        ~Point(); // 解構函式 
    private:
        int x,y;
        int* p;
};

// 建構函式 
Point::Point(int a, int b){
    x = a;
    y = b;
    p = new int(100);
}

// 解構函式
Point::~Point(){
    if(p != NULL){
        delete p;
    }
} 

// 主函式 
int main(int argc, char** argv) {
    Point point1(2,3);
    Point point2(point1);

    return 0;
}

在這段程式碼執行結束之前，會出現一個執行錯誤。原因就在於在進行物件複製時，對於動態分配的內容沒有進行正確的操作。我們來分析一下：

在執行定義point1物件後，由於在建構函式中有一個動態分配的語句，因此執行後的記憶體情況大致如下：

在使用point1複製point2時，由於執行的是淺拷貝，只是將成員的值進行賦值，這時 point1.p = point2.p，也即這兩個指標指向了堆裡的同一個空間，如下圖所示：

當然，這不是我們所期望的結果，在銷燬物件時，兩個物件的解構函式將對同一個記憶體空間釋放兩次，這就是錯誤出現的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。

深拷貝

在“深拷貝”的情況下，對於物件中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：

class Point{
    public:
        Point(int a, int b); // 建構函式 
        ~Point(); // 解構函式 
        Point(const Point & p); //複製建構函式
    private:
        int x,y;
        int* p;
};

// 建構函式 
Point::Point(int a, int b){
    x = a;
    y = b;
    p = new int(100);
}

// 解構函式
Point::~Point(){
    if(p != NULL){
        delete p;
    }
} 

// 複製建構函式的實現 
Point::Point(const Point &q){
    x = q.x;
    y = q.y;
    p = new int;    // 為新物件重新動態分配空間  
    *p = *(q.p); 
}


// 主函式 
int main(int argc, char** argv) {
    Point point1(2,3);
    Point point2(point1);

    return 0;
}

此時，在完成物件的複製後，記憶體的一個大致情況如下：

此時point1的p和point22的p各自指向一段記憶體空間，但它們指向的空間具有相同的內容，這就是所謂的“深拷貝”。