深拷贝和浅拷贝

最新推荐文章于 2024-09-18 10:53:45 发布
最新推荐文章于 2024-09-18 10:53:45 发布
阅读量137 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45726776/article/details/119577311
版权

一、数据类型

数据分为基本数据类型(String, Number, Boolean, Null, Undefined，Symbol)和对象数据类型。

1、基本数据类型的特点：直接存储在栈(stack)中的数据

2、引用数据类型的特点：存储的是该对象在栈中引用，真实的数据存放在堆内存里

引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。
在这里插入图片描述
*

二、浅拷贝与深拷贝

深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。

深拷贝和浅拷贝的示意图大致如下：
示意图
浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

三、赋值和浅拷贝的区别

当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。

浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

public class Student {
    private String name;
    private int age;
    private int grade;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
}

下面用的“=”赋值

public class Studenttest {
    public static void main(String[] args) {
        int age = 10;
        int age1 = 20;
        String name = "aaa";
        String name1 = "bbb";

        Student student = new Student();
        student.setAge(age);
        student.setName(name);

        Student student1 = student;
        student.setAge(age1);
        student.setName(name1);

        System.out.println(student);
        System.out.println(student1);

    }
}
----Output----
Student{name='bbb', age=20, grade=0}
Student{name='bbb', age=20, grade=0}

上面代码直接使用了 “=” 对对象进行拷贝，发现，无论是基本类型还是引用类型的数据，只要其中一个对象的值被改变，另一个对象的数据也随之改变。

浅拷贝：

public class School implements Cloneable {
    String name;

    public School(String name) {
        this.name = name;
    }

	...
        
    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                '}';
    }
}


public class Student implements Cloneable{
    private String name;
    private int age;
    private int grade;
    private School school;

    public School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        this.school = school;
    }

    public Student(String name, int age, School school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                ", school=" + school +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
    @Override
    protected Student clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
       this.school.clone();
        return student;
    }
}


public class Tester {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student("李四",10, new School("重大"));
        Student student1 = (Student) student.clone();
        student.setAge(20);
        student.setName("张三");
        student.getSchool().setName("城科");
        System.out.println(student);
        System.out.println(student1);
    }
    }
}

----Output----
Student{name='张三', age=20, grade=0, school=School{name='城科'}}
Student{name='李四', age=10, grade=0, school=School{name='城科'}}

以上就是一个实现浅拷贝的例子，首先，需要拷贝的类要实现Cloneable接口（此接口是个标识性接口，接口内无任何方法），重写clone方法，在拷贝对象的时候，使用Student student = (Student) student.clone()，这样就实现了浅拷贝。从测试类的输出可以看出来，修改原对象的基本数据类型的成员变量和引用数据name时，拷贝对象并没有收到影响，而修改原对象原数据包含子对象School的属性时，拷贝类型也受到了影响。

深拷贝：

@Override
    protected School clone() throws CloneNotSupportedException {
        School school= (School) super.clone();
        return school;
    }


public class Student implements Cloneable{
    private String name;
    private int age;
    private int grade;
    private School school;

    public School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        this.school = school;
    }

    public Student(String name, int age, School school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                ", school=" + school +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
    @Override
    protected Student clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
        student.school = (School) this.school.clone();
        return student;
    }
}


public class Tester {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student("李四",10, new School("重大"));
        Student student1 = (Student) student.clone();
        student.setAge(20);
        student.setName("张三");
        student.getSchool().setName("城科");
        System.out.println(student);
        System.out.println(student1);
    }
}
----Output----
Student{name='张三', age=20, grade=0, school=School{name='城科'}}
Student{name='李四', age=10, grade=0, school=School{name='重大'}}

深拷贝从测试类的输出可以看出来，修改原对象的基本数据类型的成员变量时，拷贝对象并没有收到影响，而修改原对象引用类型成员变量School的属性时，拷贝类型也不受到了影响。

–和原数据是否指向同一对象第一层数据为基本数据类型原数据包含子对象
赋值是改变会使原数据一同改变改变会使原数据一同改变
浅拷贝否改变会不使原数据一同改变改变会使原数据一同改变
深拷贝否改变不会使原数据一同改变改变不会使原数据一同改变
知̊魚̊
关注
java，深拷贝和浅拷贝
水w的博客
09-16 1247
深拷贝和浅拷贝
“浅拷贝”与“深拷贝”
热门推荐
一叶扁舟
07-05 2万+
        C++中对象的复制就如同“克隆”，用一个已有的对象快速地复制出多个完全相同的对象。一般而言，以下三种情况都会使用到对象的复制：（1）建立一个新对象，并用另一个同类的已有对象对新对象进行初始化，例如：class Rect{private: int width; int height;};Rect rect1;Rect rect2(rect1
浅拷贝、深拷贝
xinxin920606的博客
11-29 786
深拷贝和浅拷贝 都是对象的拷贝，都会生成一个看起来相同的对象，他们本质的区别是拷贝出来的对象的地址是否和原对象一样，也就是地址的复制还是值的复制的区别。 深拷贝和浅拷贝需要注意的地方就是可变元素的拷贝： 在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象里的可变元素的地址是相同的，也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可...
JavaScript深拷贝和浅拷贝概念与用法实例分析
01-19
js中的浅拷贝和深拷贝，只是针对复杂数据类型(Objcet，Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础上再生成一份的作用。但是根据新生成的对象能否影响到原对象可以分为浅拷贝和深拷贝。 ...
Python中的深拷贝和浅拷贝详解
12-25
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝) 【变量-对象-引用】 在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象，type对象 Python...
Python 深拷贝和浅拷贝详解
03-09
对于不可变类型（如整数、字符串、元组），浅拷贝和深拷贝没有实质区别，因为这些类型不可变，所以拷贝后的新对象和原对象是等价的，但不一定是同一对象（即`is`操作符可能返回`False`）。 总之，深拷贝和浅拷贝的...
深拷贝、浅拷贝
lydms的博客
05-12 7257
深拷贝、浅拷贝
深拷贝+浅拷贝
weixin_30830327的博客
04-29 88
implements cloneable ,（实现此接口表示该java类支持克隆，如果没有实现此接口就 调用了clone方法，则会报出来clonenotsupportedexception异常） 覆写object类中的clone（），并将可见性从protect改为public 浅拷贝和深拷贝出来新类 ...
深拷贝|浅拷贝
伏颜的博客
09-18 6032
深拷贝-浅拷贝
深拷贝
weixin_49920110的博客
05-23 164
深拷贝 ** 深拷贝和浅拷贝的区别** 1.浅拷贝： 将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用 2.深拷贝： 创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用” 为什么要使用深拷贝？ 我们希望在改变新的数组（对象）的时候，不改变原数组（对象） 怎么检验深拷贝成功 改变任意一个新对象/数组中的属性/元素, 都不改变原对象/数组 深拷贝数组 1 .直接遍历 var array = [1, 2, 3, 4]; functio
深拷贝和浅拷贝cpp
最新发布
05-10
<think>嗯，用户想了解C++中的深拷贝和浅拷贝的区别以及实现方法。首先，我需要回忆一下这两个概念的基本定义。浅拷贝应该是指简单的复制指针，导致两个对象指向同一块内存，而深拷贝则是复制指针所指向的数据本身，这样两个对象就独立了。 根据用户提供的引用内容，引用[1]里提到浅拷贝只拷贝指针，深拷贝会拷贝内容，默认的拷贝构造函数是浅拷贝，需要自己实现深拷贝。引用[2]和[3]给出了具体的代码示例，展示了如何通过自定义拷贝构造函数来实现深拷贝，比如在Person类中为Name或m_height重新分配内存并复制数据。引用[4]中的Array类也演示了类似的深拷贝实现，即在拷贝构造函数中新建内存空间并复制数据。 接下来，我需要将这些信息组织成一个清晰的回答。首先解释两者的区别，用比喻的话，浅拷贝像快捷方式，深拷贝像复制文件，这样用户容易理解。然后，说明默认拷贝构造函数的问题，比如会导致重复释放内存，出现错误。接着，用用户提供的代码例子来说明如何手动实现深拷贝，比如在拷贝构造函数中分配新内存，并复制数据。可能还需要提到析构函数的重要性，确保深拷贝的对象能正确释放内存。 用户可能还关心什么时候需要深拷贝，应该是在类中有指针成员指向动态分配的内存时。这时候必须自己实现深拷贝，否则会出现问题。同时，需要注意在实现深拷贝时，除了拷贝构造函数，可能还需要重载赋值运算符，但用户的问题可能没有提到，所以可能暂时不需要展开，但如果有相关问题可以提到。 最后，生成的相关问题需要围绕实现深拷贝的方法、常见错误场景以及如何避免等问题。这样用户如果有进一步的问题，可以继续查阅相关内容。确保回答中正确引用提供的资料，比如引用[1]、[3]中的例子来说明浅拷贝的问题和深拷贝的实现步骤。</think>### C++深拷贝与浅拷贝的区别及实现方式 #### 一、核心概念 1. **浅拷贝** - 仅复制对象的指针成员变量，拷贝后新旧对象的指针**指向同一块内存地址**，例如： ```cpp //示例代码片段 m_height = p.m_height; //浅拷贝直接复制指针[^3] ``` - 类似文件快捷方式，多个指针共享同一资源，可能导致**重复释放内存**的崩溃问题[^1] 2. **深拷贝** - 为指针成员**创建独立的内存空间**，完全复制原对象的数据内容： ```cpp m_height = new int(*p.m_height); //新建堆空间并复制数据[^3] ``` - 类似完整文件复制，新旧对象完全独立，避免资源冲突[^1] #### 二、实现方式对比 | 特征 | 浅拷贝 | 深拷贝 | |--------------|---------------------------|---------------------------| | 内存分配 | 共享原对象内存 | 新建独立内存空间 | | 实现复杂度 | 编译器默认提供 | 需手动实现拷贝构造函数 | | 资源管理风险 | 易出现重复释放 | 内存管理安全 | | 典型应用场景 | 无指针成员的简单对象 | 包含指针/动态资源的对象 | #### 三、关键实现步骤（以类`person`为例） 1. **定义深拷贝构造函数** ```cpp person(const person& p) { m_age = p.m_age; m_height = new int(*p.m_height); //关键：新建堆内存并复制数据 } ``` 2. **配套析构函数** ```cpp ~person() { delete m_height; //确保正确释放深拷贝分配的内存 m_height = nullptr; } ``` 3. **错误示例（浅拷贝陷阱）** 若直接使用默认拷贝构造函数： ```cpp person p2(p1); //此时p2.m_height与p1.m_height指向同一地址 ``` 析构时会导致**重复释放同一内存地址**，引发程序崩溃[^1] #### 四、应用场景分析 - **必须使用深拷贝**：类包含指针成员且指向动态分配内存时（如字符串、数组等） - **可使用浅拷贝**：仅包含基本数据类型或没有资源所有权的指针时 - **典型案例**：自定义容器类（如动态数组`Array`类[^4]）、包含文件句柄的类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值