您的位置:

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;
};

七、小结

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