目录

1--深拷贝和浅拷贝的基础概念

2--浅拷贝的代码实例

3--深拷贝代码实例

4--参考

---

1--深拷贝和浅拷贝的基础概念

① 浅拷贝：简单的赋值拷贝操作；

② 深拷贝：在堆区重新申请空间，进行拷贝操作；

2--浅拷贝的代码实例

# include <iostream>

class Person{

public:
    // 有参构造函数
    Person(int age, int height){
        Age = age;
        Height = new int(height); // 存放在堆区
        std::cout << "有参构造函数的调用" << std::endl;
    }

    // 模仿编译器默认实现的浅拷贝构造函数
    Person(const Person &p){
        Age = p.Age;
        Height = p.Height; // 编译器默认实现浅拷贝
        std::cout << "拷贝构造函数的调用" << std::endl;
    }
    
    // 析构函数
    ~Person(){
        if(Height != NULL){ // 手动释放堆区的数据
            delete Height;
            Height = NULL; 
        }       
        std::cout << "析构函数的调用" << std::endl;
    }

    int Age;
    int *Height;
};

int main(){
    Person p1(23, 180);
    std::cout << "p1.Age = " << p1.Age << " p1.Height = " << *p1.Height << std::endl; // 23, 180
    Person p2(p1);
    std::cout << "p2.Age = " << p2.Age << " p1.Height = " << *p2.Height << std::endl; // 23, 180
    return 0;
}

        编译器默认实现的浅拷贝构造函数如下：

    // 模仿编译器默认实现的浅拷贝构造函数
    Person(const Person &p){
        Age = p.Age;
        Height = p.Height; // 编译器默认实现浅拷贝
        std::cout << "拷贝构造函数的调用" << std::endl;
    }

        在创建对象p1时，有参构造函数在堆区申请了内存空间来存储指针 Height 指向的数据；

        在创建对象p2时，使用编译器默认的浅拷贝构造函数，这时p2对象的 Height 也会指向与p1相同的堆区空间；

        但在使用析构函数销毁堆区的数据时，会出现重复销毁的问题，即 p1 和 p2 会重复销毁堆区的同一块内存数据，从而出现 bug 。

3--深拷贝代码实例

        人为定义深拷贝构造函数，可以避免上面浅拷贝带来的堆区数据重复被销毁的问题；

# include <iostream>

class Person{

public:
    // 有参构造函数
    Person(int age, int height){
        Age = age;
        Height = new int(height); // 存放在堆区
        std::cout << "有参构造函数的调用" << std::endl;
    }

    // 人为实现拷贝构造函数，避免浅拷贝
    Person(const Person &p){
        Age = p.Age;
        // Height = p.Height; // 编译器默认实现浅拷贝
        Height = new int (*p.Height);  // 人为实现深拷贝
        std::cout << "拷贝构造函数的调用" << std::endl;
    }
    
    // 析构函数
    ~Person(){
        if(Height != NULL){ // 手动释放堆区的数据
            delete Height;
            Height = NULL; 
        }       
        std::cout << "析构函数的调用" << std::endl;
    }

    int Age;
    int *Height;
};

int main(){
    Person p1(23, 180);
    std::cout << "p1.Age = " << p1.Age << " p1.Height = " << *p1.Height << std::endl; // 23, 180
    Person p2(p1);
    std::cout << "p2.Age = " << p2.Age << " p1.Height = " << *p2.Height << std::endl; // 23, 180
    return 0;
}

        人为实现的深拷贝构造函数如下：

    // 人为实现拷贝构造函数，避免浅拷贝
    Person(const Person &p){
        Age = p.Age;
        // Height = p.Height; // 编译器默认实现浅拷贝
        Height = new int (*p.Height);  // 人为实现深拷贝
        std::cout << "拷贝构造函数的调用" << std::endl;
    }
    

        与编译器默认实现的浅拷贝构造函数不同，深拷贝在堆区重新申请空间来进行拷贝操作，这样不同对象指向的堆区空间不同，在利用析构函数销毁对象时也不会出现重复销毁的问题；

Height = p.Height; // 编译器默认实现浅拷贝
Height = new int (*p.Height);  // 人为实现深拷贝

4--参考

深拷贝和浅拷贝代码讲解