C++拷贝构造的详细阐述

一、拷贝构造的定义

拷贝构造是一种特殊的构造函数，它是用来初始化同一类中的另一个对象的；其实就是将一个对象中的数据，拷贝到另一个对象中。

class Point{
    public:
        Point(int a,int b) {
            x = a;
            y = b;
        }
        // 拷贝构造函数
        Point(const Point &p) {
            x = p.x;
            y = p.y;
        }
        int x;
        int y;
};

二、拷贝构造的默认实现

如果不显示定义拷贝构造函数，编译器会默认提供一个拷贝构造函数，其实现方式是逐个成员进行复制。

class Point{
    public:
        Point(int a,int b) {
            x = a;
            y = b;
        }
        // 拷贝构造函数（默认实现）
        Point(const Point &p) {
            x = p.x;
            y = p.y;
        }
        int x;
        int y;
};

三、防止拷贝的实现方式

有时候，我们需要限制对象的拷贝行为，可以采用以下两种方式。

1. 声明拷贝构造函数为私有（禁用拷贝）

将拷贝构造函数声明为私有的可以禁用对象的拷贝行为，防止对象被复制。

class SingleObject{
    public:
        static SingleObject* getInstance() {
            if (m_instance == nullptr) {
                m_instance = new SingleObject();
            }
            return m_instance;
        }
    private:
        // 禁止拷贝行为
        SingleObject(const SingleObject&);
        SingleObject();
        static SingleObject* m_instance;
};    

2. 将拷贝构造函数定义为delete

C++11标准提供了delete关键字，用于防止使用某个函数或者操作符，可以将其置为删除状态。

class SingleObject{
    public:
        static SingleObject* getInstance() {
            if (m_instance == nullptr) {
                m_instance = new SingleObject();
            }
            return m_instance;
        }
        // 禁止拷贝行为
        SingleObject(const SingleObject&) = delete;
        SingleObject& operator=(const SingleObject&) = delete;
    private:
        SingleObject();
        static SingleObject* m_instance;
};

四、拷贝构造的调用时机

拷贝构造函数在以下几种情况下会被调用。

1. 用一个对象去初始化另一个同类对象

class Point{
    public:
        Point(int a,int b) {
            x = a;
            y = b;
        }
        // 拷贝构造函数
        Point(const Point &p) {
            x = p.x;
            y = p.y;
        }
        int x;
        int y;
};
Point p1(1,2);
Point p2 = p1;  // 通过p1去初始化p2，会调用拷贝构造函数

2. 函数传参时，按值传递

class Point{
    public:
        Point(int a,int b) {
            x = a;
            y = b;
        }
        // 拷贝构造函数
        Point(const Point &p) {
            x = p.x;
            y = p.y;
        }
        int x;
        int y;
};
void print(Point p) {}  // 按值传递的方式调用函数
Point p(1,2);
print(p);  // 调用函数时按值传递，会调用拷贝构造函数

3. 函数返回对象时，按值返回

class Point{
    public:
        Point(int a,int b) {
            x = a;
            y = b;
        }
        // 拷贝构造函数
        Point(const Point &p) {
            x = p.x;
            y = p.y;
        }
        int x;
        int y;
};
Point getPoint() {
    Point p(1,2);
    return p;  // 返回对象时按值返回，会调用拷贝构造函数
}

五、深拷贝和浅拷贝

当类中有指针类型成员时，拷贝构造将会带来深拷贝和浅拷贝的问题。

1. 深拷贝

拷贝构造时，为指针成员重新申请内存，并将原来内存中的数据复制到新内存中，这样两个指针成员指向的内存是不同的。

class String{
public:
    String() {
        m_data = new char[1];
        *m_data = '\0';
    }
    String(const char* data) {
        m_data = new char[strlen(data) + 1];
        strcpy(m_data, data);
    }
    String(const String& other) {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }
private:
    char* m_data;
};

2. 浅拷贝

拷贝构造时，直接将指针成员的值复制到新对象中，这样两个指针成员指向的内存是相同的，会带来指针重复删除的问题。

class String{
public:
    String() {
        m_data = new char[1];
        *m_data = '\0';
    }
    String(const char* data) {
        m_data = new char[strlen(data) + 1];
        strcpy(m_data, data);
    }
    String(const String& other) {
        m_data = other.m_data;  // 浅拷贝
    }
    ~String() {
        delete[] m_data;  // 重复删除指针会导致错误
    }
private:
    char* m_data;
};

六、拷贝赋值运算符重载

拷贝赋值运算符（=）和拷贝构造函数的作用很相似，都是进行对象的拷贝，但两者的调用时机不同。拷贝构造在对象创建时被调用，拷贝赋值在对象创建后被调用。

class String{
public:
    String() {
        m_data = new char[1];
        *m_data = '\0';
    }
    String(const char* data) {
        m_data = new char[strlen(data) + 1];
        strcpy(m_data, data);
    }
    String(const String& other) {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }
    // 拷贝赋值运算符重载
    String& operator=(const String& other) {
        if (this != &other) {  // 防止自我赋值
            delete[] m_data;
            m_data = new char[strlen(other.m_data) + 1];
            strcpy(m_data, other.m_data);
        }
        return *this;
    }
private:
    char* m_data;
};

七、小结

拷贝构造是一种特殊的构造函数，其作用是用于初始化同一类中的另一个对象。对于指针类型成员，需要注意深拷贝和浅拷贝的问题，避免指针重复删除。