精华内容
下载资源
问答
  • 1、浅拷贝 2、深拷贝 二、实现方式 1、浅拷贝的实现方式 1.1 Object.assign(target,source)方法 1.2 Array.prototype.concat()方法 1.3 Array.prototype.slice(start,end)方法 2、深拷贝的实现方式 2.1 JSON.parse...
  • C++之深拷贝和浅拷贝

    2015-09-09 19:06:07
    通过简短的代码图片来说明C++中深拷贝和浅拷贝区别和概念。
  • Java深入理解深拷贝和浅拷贝区别

    万次阅读 多人点赞 2019-02-13 23:31:47
    一、拷贝的引入 (1)、引用拷贝 创建一个指向对象的引用变量的拷贝。 Teacher teacher = new Teacher("Taylor",26); Teacher otherteacher = teacher; System.out.println(teacher); System.out.println...

    欢迎大家关注我的公众号【老周聊架构】,Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

    一、拷贝的引入

    (1)、引用拷贝

    创建一个指向对象的引用变量的拷贝。

    public class QuoteCopy {
        public static void main(String[] args) {
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = teacher;
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    
    class Teacher {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        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;
        }
    }
    

    输出结果:

    com.test.Teacher@28a418fc
    com.test.Teacher@28a418fc
    

    结果分析:由输出结果可以看出,它们的地址值是相同的,那么它们肯定是同一个对象。teacherotherTeacher只是引用而已,他们都指向了一个相同的对象Teacher(“riemann”,28)。 这就叫做引用拷贝

    在这里插入图片描述

    (2)、对象拷贝

    创建对象本身的一个副本。

    public class ObjectCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = (Teacher) teacher.clone();
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        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 Object clone() throws CloneNotSupportedException {
            Object object = super.clone();
            return object;
        }
    }
    

    输出结果:

    com.test.Teacher@28a418fc
    com.test.Teacher@5305068a
    

    结果分析:由输出结果可以看出,它们的地址是不同的,也就是说创建了新的对象, 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。

    在这里插入图片描述

    注:深拷贝和浅拷贝都是对象拷贝

    二、浅拷贝

    (1)、定义

    被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝,但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

    简而言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象。

    (2)、浅拷贝实例

    public class ShallowCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
    
            Student student2 = (Student) student1.clone();
            System.out.println("-------------拷贝后-------------");
            System.out.println(student2.getName());
            System.out.println(student2.getAge());
            System.out.println(student2.getTeacher().getName());
            System.out.println(student2.getTeacher().getAge());
    
            System.out.println("-------------修改老师的信息后-------------");
            // 修改老师的信息
            teacher.setName("jack");
            System.out.println("student1的teacher为: " + student1.getTeacher().getName());
            System.out.println("student2的teacher为: " + student2.getTeacher().getName());
    
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        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;
        }
    }
    
    class Student implements Cloneable {
        private String name;
        private int age;
        private Teacher teacher;
    
        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 Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        public Object clone() throws CloneNotSupportedException {
            Object object = super.clone();
            return object;
        }
    }
    

    输出结果:

    -------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为: jack
    student2的teacher为: jack
    

    结果分析: 两个引用student1student2指向不同的两个对象,但是两个引用student1student2中的两个teacher引用指向的是同一个对象,所以说明是浅拷贝

    在这里插入图片描述

    三、深拷贝

    (1)、定义

    深拷贝是一个整个独立的对象拷贝,深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

    简而言之,深拷贝把要复制的对象所引用的对象都复制了一遍。

    (2)、深拷贝实例

    public class DeepCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
    
            Student student2 = (Student) student1.clone();
            System.out.println("-------------拷贝后-------------");
            System.out.println(student2.getName());
            System.out.println(student2.getAge());
            System.out.println(student2.getTeacher().getName());
            System.out.println(student2.getTeacher().getAge());
    
            System.out.println("-------------修改老师的信息后-------------");
            // 修改老师的信息
            teacher.setName("jack");
            System.out.println("student1的teacher为: " + student1.getTeacher().getName());
            System.out.println("student2的teacher为: " + student2.getTeacher().getName());
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        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 Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    class Student implements Cloneable {
        private String name;
        private int age;
        private Teacher teacher;
    
        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 Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        public Object clone() throws CloneNotSupportedException {
            // 浅复制时:
            // Object object = super.clone();
            // return object;
    
            // 改为深复制:
            Student student = (Student) super.clone();
            // 本来是浅复制,现在将Teacher对象复制一份并重新set进来
            student.setTeacher((Teacher) student.getTeacher().clone());
            return student;
    
        }
    }
    

    输出结果:

    -------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为: jack
    student2的teacher为: riemann
    

    结果分析:
    两个引用student1student2指向不同的两个对象,两个引用student1student2中的两个teacher引用指向的是两个对象,但对teacher对象的修改只能影响student1对象,所以说是深拷贝

    在这里插入图片描述

    展开全文
  • 深拷贝和浅拷贝区别是什么?

    万次阅读 多人点赞 2019-06-18 15:44:47
    深拷贝和浅拷贝区别是什么? 复制一个 Java 对象 浅拷贝:复制基本类型的属性;引用类型的属性复制,复制栈中的变量 变量指向堆内存中的对象的指针,不复制堆内存中的对象。 深拷贝:复制基本类型的属性;...

    深拷贝和浅拷贝区别是什么?

    复制一个 Java 对象
    浅拷贝:复制基本类型的属性;引用类型的属性复制,复制栈中的变量 和 变量指向堆内存中的对象的指针,不复制堆内存中的对象。

    深拷贝:复制基本类型的属性;引用类型的属性复制,复制栈中的变量 和 变量指向堆内存中的对象的指针和堆内存中的对象。

     

    如何实现对象克隆? 

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • 主要介绍了Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍,需要的朋友可以参考下
  • 本文实例讲述了JavaScript深拷贝和浅拷贝概念与用法。分享给大家供大家参考,具体如下: js中的浅拷贝和深拷贝,只是针对复杂数据类型(Objcet,Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础...
  • 直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变,被赋值的变量也会做相同的改变。其实就是对‘对象’的引用 示例: >>> list_demo = [2, 4, 6] >>> a = list_demo >>> print(a) [2, 4, 6] >>> id(list_demo) ...
  • 主要介绍了java中的深拷贝和浅拷贝(clone()方法的重写、使用序列化实现真正的深拷贝),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 对于基本类型,深拷贝和浅拷贝都是一样的,都是对原始数据的复制,修改原始数据,不会对复制数据产生影响。 两者的区别,在于对引用属性的复制。 浅拷贝 浅拷贝复制引用属性时,仅仅复制指针值,没有复制指向的对象...

    本文针对java语言。
    当复制一个java对象时,由于对其属性复制后产生的效果不同,而产生了深拷贝与浅拷贝。
    对于基本类型,深拷贝和浅拷贝都是一样的,都是对原始数据的复制,修改原始数据,不会对复制数据产生影响。
    两者的区别,在于对引用属性的复制。
    浅拷贝
    浅拷贝复制引用属性时,仅仅复制指针值,没有复制指向的对象。
    在这里插入图片描述

    深拷贝
    深拷贝完整复制一份该属性指向的对象,如下图:
    在这里插入图片描述
    这样两个对象修改时,互相不产生影响。

    Object.clone()方法属于浅拷贝还是深拷贝?
    Object.clone()方法属于浅拷贝。如果想使用深拷贝,必须在类里面重写clone()方法。
    要想调用类的clone()方法,类必须实现Cloneable接口,该接口是个空接口,如果不实现该接口,调用clone()方法会抛出异常CloneNotSupportedException。

    public class Teacher implements Cloneable{
    	protected Object clone()throws CloneNotSupportedException{
    		return super.clone();
    	}
    }
    

    深拷贝时,我们重写clone()方法,然后在clone()方法里面对引用属性重新赋值。

    展开全文
  • 深拷贝和浅拷贝区别

    千次阅读 2020-08-27 11:19:12
    深拷贝和浅拷贝 值类型 vs 引用类型 赋值 vs 浅拷贝 vs 深拷贝 对象赋值 浅拷贝 深拷贝 浅拷贝代码实现 深拷贝代码实现 深度遍历式拷贝 利用反序列化实现深拷贝 深拷贝和浅拷贝 浅拷贝(shallowCopy)...

    目录

    深拷贝和浅拷贝

    值类型 vs 引用类型

    赋值 vs 浅拷贝 vs 深拷贝

    对象赋值

    浅拷贝

    深拷贝

    浅拷贝代码实现

    深拷贝代码实现

    深度遍历式拷贝

    利用反序列化实现深拷贝


     

    深拷贝和浅拷贝

    浅拷贝(shallowCopy)只是增加了一个指针指向已存在的内存地址,

    深拷贝(deepCopy)是增加了一个指针并且申请了一个新的内存,使这个增加的指针指向这个新的内存,

    使用深拷贝的情况下,释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。

    浅复制:仅仅是指向被复制的内存地址,如果原地址发生改变,那么浅复制出来的对象也会相应的改变。

    深复制:在计算机中开辟一块新的内存地址用于存放复制的对象。

    值类型 vs 引用类型

    这两个概念的准确区分,对于深、浅拷贝问题的理解非常重要。

    正如Java圣经《Java编程思想》第二章的标题所言,在Java中一切都可以视为对象!

    所以来到Java的世界,我们要习惯用引用去操作对象。在Java中,像数组、类Class、枚举EnumInteger包装类等等,就是典型的引用类型,所以操作时采用的也是引用传递的方式;

    但是Java的语言级基础数据类型,诸如int这些基本类型,操作时一般采取的则是值传递的方式,所以有时候也称它为值类型。

    为了便于下文的讲述和举例,我们这里先定义两个类:StudentMajor,分别表示「学生」以及「所学的专业」,二者是包含关系:

    // 学生的所学专业
    public class Major {
        private String majorName; // 专业名称
        private long majorId;     // 专业代号
        
        // ... 其他省略 ...
    }
    
    // 学生
    public class Student {
        private String name;  // 姓名
        private int age;      // 年龄
        private Major major;  // 所学专业
        
        // ... 其他省略 ...
    }
    


    赋值 vs 浅拷贝 vs 深拷贝

    对象赋值

    赋值是日常编程过程中最常见的操作,最简单的比如:

    Student codeSheep = new Student();
    Student codePig = codeSheep;
    

    严格来说,这种不能算是对象拷贝,因为拷贝的仅仅只是引用关系,并没有生成新的实际对象:

    浅拷贝

    浅拷贝属于对象克隆方式的一种,重要的特性体现在这个 「浅」 字上。只是增加了一个指针指向已存在的内存地址。

    比如我们试图通过studen1实例,拷贝得到student2,如果是浅拷贝这种方式,大致模型可以示意成如下所示的样子:

    很明显,值类型的字段会复制一份,而引用类型的字段拷贝的仅仅是引用地址,而该引用地址指向的实际对象空间其实只有一份。原来的引用只要改变了引用类型的实例数据,那么浅拷贝出来的引用也会随之发生改变。此时,这两个实例对象student1和student2不是同一个对象。

    一图胜前言,我想上面这个图已经表现得很清楚了。

    深拷贝

    深拷贝相较于上面所示的浅拷贝,除了值类型字段会复制一份,引用类型字段所指向的对象,会在内存中也创建一个副本

    增加了一个指针并且申请了一个新的内存,使这个增加的指针指向这个新的内存,就像这个样子:

    原理很清楚明了,下面来看看具体的代码实现吧。


    浅拷贝代码实现

    还以上文的例子来讲,我想通过student1拷贝得到student2,浅拷贝的典型实现方式是:让被复制对象的类实现Cloneable接口,并重写clone()方法即可。

    以上面的Student类拷贝为例:

    public class Student implements Cloneable {
    
        private String name;  // 姓名
        private int age;      // 年龄
        private Major major;  // 所学专业
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
        
        // ... 其他省略 ...
    
    }
    

    然后我们写个测试代码,一试便知:

    public class Test {
    
        public static void main(String[] args) throws CloneNotSupportedException {
    
            Major m = new Major("计算机科学与技术",666666);
            Student student1 = new Student( "CodeSheep", 18, m );
            
            // 由 student1 拷贝得到 student2
            Student student2 = (Student) student1.clone();
    
            System.out.println( student1 == student2 );
            System.out.println( student1 );
            System.out.println( student2 );
            System.out.println( "\n" );
    
            // 修改student1的值类型字段
            student1.setAge( 35 );
            
            // 修改student1的引用类型字段
            m.setMajorName( "电子信息工程" );
            m.setMajorId( 888888 );
    
            System.out.println( student1 );
            System.out.println( student2 );
    
        }
    }
    

    运行得到如下结果:

    从结果可以看出:

    • student1==student2打印false,说明clone()方法的确克隆出了一个新对象

    • 修改值类型字段并不影响克隆出来的新对象,符合预期;

    • 而修改了student1内部的引用对象,克隆对象student2也受到了波及,说明内部还是关联在一起的


    深拷贝代码实现

    深度遍历式拷贝

    虽然clone()方法可以完成对象的拷贝工作,但是注意:clone()方法默认是浅拷贝行为,就像上面的例子一样。若想实现深拷贝需覆写 clone()方法实现引用对象的深度遍历式拷贝,进行地毯式搜索。

    所以对于上面的例子,如果想实现深拷贝,首先需要对更深一层次的引用类Major做改造,让其也实现Cloneable接口并重写clone()方法:

    public class Major implements Cloneable {
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
        
        // ... 其他省略 ...
    }
    

    其次我们还需要在顶层的调用类中重写clone方法,来调用引用类型字段的clone()方法实现深度拷贝,对应到本文那就是Student类:

    public class Student implements Cloneable {
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            Student student = (Student) super.clone();
            student.major = (Major) major.clone(); // 重要!!!
            return student;
        }
        
        // ... 其他省略 ...
    }
    

    这时候上面的测试用例不变,运行可得结果:

    很明显,这时候student1student2两个对象就完全独立了,不受互相的干扰。

    利用反序列化实现深拷贝

    记得在前文《序列化/反序列化,我忍你很久了》中就已经详细梳理和总结了「序列化和反序列化」这个知识点了。

    利用反序列化技术,我们也可以从一个对象深拷贝出另一个复制对象,而且这货在解决多层套娃式的深拷贝问题时效果出奇的好。

    所以我们这里改造一下Student类,让其clone()方法通过序列化和反序列化的方式来生成一个原对象的深拷贝副本:

    public class Student implements Serializable {
    
        private String name;  // 姓名
        private int age;      // 年龄
        private Major major;  // 所学专业
    
        public Student clone() {
            try {
                // 将对象本身序列化到字节流
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                ObjectOutputStream objectOutputStream =
                        new ObjectOutputStream( byteArrayOutputStream );
                objectOutputStream.writeObject( this );
    
                // 再将字节流通过反序列化方式得到对象副本
                ObjectInputStream objectInputStream =
                        new ObjectInputStream( new ByteArrayInputStream( byteArrayOutputStream.toByteArray() ) );
                return (Student) objectInputStream.readObject();
    
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
        
        // ... 其他省略 ...
    }
    

    当然这种情况下要求被引用的子类(比如这里的Major类)也必须是可以序列化的,即实现了Serializable接口:

    public class Major implements Serializable {
      
      // ... 其他省略 ...
        
    }
    

    这时候测试用例完全不变,直接运行,也可以得到如下结果:

    很明显,这时候student1student2两个对象也是完全独立的,不受互相的干扰,深拷贝完成。

     

    展开全文
  • C/C++ 浅拷贝和深拷贝的实例详解 深拷贝是指拷贝对象的具体内容,而内存地址是自主分配的,拷贝结束之后,两个对象虽然存的值是相同的,但是内存地址不一样,两个对象也互不影响,互不干涉。 浅拷贝就是对内存地址...
  • 深拷贝和浅拷贝区别 JavaScript中有两种类型的对象拷贝:浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。 最根本的区别在于是否是真正获取了一个对象的复制实体,而不是引用。 浅拷贝 —-只是拷贝了基本类型的数据...
  • 浅拷贝:复制一份引用,所有引用对象都指向一份数据,并且都可以修改这份数据。 深拷贝(复杂):复制变量值,对于非基本类型的变量,则递归至基本类型变量后,再复制。 1.深拷贝 1.1. 最简单的方法就是JSON.parse...
  • 深拷贝和浅拷贝

    2021-01-08 16:38:10
    深拷贝和浅拷贝,也叫做深层次复制浅层次复制 如对数组或者对象进行拷贝: 浅拷贝原理:只是将数组的内存地址复制给另一个变量,实际还是同一个内存地址空间,对任何一个变量修改元素,都是在修改同一个内存地址...
  • 深拷贝和浅拷贝一、如何区分深拷贝和浅拷贝二、举例加深理解深拷贝和浅拷贝三、图文理解四、哪些方法是浅拷贝,如何进行深拷贝 一、如何区分深拷贝和浅拷贝 内在的区别浅拷贝就是简单的把指向别人的值的一个指针...
  • 面试题:深拷贝和浅拷贝(超级详细,有内存图)

    万次阅读 多人点赞 2019-08-07 13:07:34
    深拷贝和浅拷贝是经常在面试中会出现的,主要考察你对基本类型引用类型的理解深度。我在无数次的面试中,应聘者还没有一个人能把这个问题回答情况,包括很多机构的培训老师。这篇文章会让你把基本类型引用类型...
  • Python 深拷贝和浅拷贝区别

    千次阅读 2020-02-10 19:26:18
    Python 深拷贝和浅拷贝区别 深浅拷贝在python中经常使用,其区别的外在表现是: 使用浅拷贝,当原容器对象中可变对象中有元素发生变化,拷贝得到的对象也会变化。而使用深拷贝时,不会有这种问题。 浅拷贝: # -*-...
  • Java 的深拷贝和浅拷贝区别

    千次阅读 2018-06-26 11:19:58
    如果一个对象内部只有基本数据类型,那用 clone() 方法获取到的就是这个对象的深拷贝,而如果其内部还有引用数据类型,那用 clone() 方法就是一次浅拷贝的操作。 1.浅拷贝 对基本数据类型进行值传递,对引用...
  • 变量-引用-对象(可变对象,不可变对象)-切片-拷贝(浅拷贝深拷贝) 【变量-对象-引用】 在Python中一切都是对象,比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象,type对象 Python...
  • js中的深拷贝和浅拷贝区别

    千次阅读 2019-09-03 17:26:29
    js中的深拷贝和浅拷贝与值传递引用传递有着些许的关联,都是根据堆栈中数据的储存来传递数据。 下面主要说一下我对深拷贝和浅拷贝的理解: 简单举个例子来说明;当我们声明一个a变量并且赋值,并且让b等于a,...
  • 浅拷贝和深拷贝都是对于JS中的引用类型而言的,浅拷贝就只是复制对象的引用,如果拷贝后的对象发生变化,原对象也会发生变化。只有深拷贝才是真正地对对象的拷贝
  • 前两天在用python写A*算法的时候,被python的深拷贝和浅拷贝恶搞了一番,实际上还是因为没搞清楚哪些是深拷贝,哪些是浅拷贝,现特意写一篇小结,加深理解。 什么是浅拷贝 所谓浅拷贝,就是复制了地址,实质上是产生...
  • 深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体,而不是引用。 假设B复制了A,修改A的时候,看B是否发生变化: 如果B跟着也变了,说明是浅拷贝,拿人手短!(修改堆内存中的同一个值) 如果B没有...
  • 本文实例讲述了JS赋值、浅拷贝和深拷贝(数组对象的深浅拷贝)。分享给大家供大家参考,具体如下: 深拷贝和浅拷贝是只针对ObjectArray这样的引用数据类型的。  浅拷贝 只是拷贝了基本类型的数据,而引用类型...
  • 深拷贝和浅拷贝最根本的区别在于是否是真正获取了一个对象的复制实体,而不是引用,深拷贝在计算机中开辟了一块内存地址用于存放复制的对象,而浅拷贝仅仅是指向被拷贝的内存地址,如果原地址中对象被改变了,那么...
  • 本文实例讲述了JS浅拷贝和深拷贝原理与实现方法。分享给大家供大家参考,具体如下: 浅拷贝只会拷贝一层,深层的引用类型改变还是会受到影响。 深拷贝是所有内部的属性还有值都被拷贝了一份,不管深层的引用类型怎么...
  • 概括的说:浅拷贝是让两个指针指向同一个位置,而深拷贝是让另一个指针自己再开辟空间。 #include<bits/stdc++.h> using namespace std; class Student { int name; int* p; public: ~Student() { //cout...
  • 本文将会深入的探讨一下在拷贝对象中会出现的浅拷贝和深拷贝的情况。 拷贝接口 java中所有的对象都是继承自java.lang.Object。Object对象中提供了一个clone方法,来供我们对java对象进行拷贝。 protected native ...
  • 深拷贝和浅拷贝区别有哪些? ​ 1.首先明白什么是引用? ​ 当我们在创建对象时,首先在堆区进行内存的分配,然后调用构造方法进行初始化。对象的实例保存在堆中,对象的引用保存在栈中。引用就好像c语言中的指针...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,532
精华内容 37,012
关键字:

深拷贝和浅拷贝的区别