深拷贝和浅拷贝

最新推荐文章于 2024-09-16 21:40:59 发布
最新推荐文章于 2024-09-16 21:40:59 发布
阅读量782 收藏
点赞数
分类专栏： java基础知识
本文通过实例详细解析了浅复制与深复制的概念，并演示了在Java中如何实现这两种复制方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

浅复制与深复制概念 ：

⑴浅复制（浅克隆） 

    被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 

⑵深复制（深克隆） 

    被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 


1、直接赋值

好，下面我们先看第一种方式，直接赋值。在Java中，A a1 = a2，我们需要理解的是这实际上复制的是引用，也就是说a1和a2指向的是同一个对象。因此，当a1变化的时候，a2里面的成员变量也会跟着变化。各位，请看下面的代码吧！

[java]  view plain  copy
  1. package interfaces.nesting;  
  2.   
  3. /* 建立类 */  
  4. class Resume {  
  5.     private String name;  //姓名  
  6.     private String sex;   //性别  
  7.     private int age;      //年龄  
  8.     private String experience; //工作经历  
  9.       
  10.     public Resume(String name, String sex, int age) {  
  11.         this.name = name;  
  12.         this.sex = sex;  
  13.         this.age = age;  
  14.     }  
  15.       
  16.     public void setAge(int age) {  
  17.         this.age = age;  
  18.     }  
  19.     public int getAge() {  
  20.         return age;  
  21.     }  
  22.       
  23.     public void setExperience(String experience) {  
  24.         this.experience = experience;  
  25.     }  
  26.     public String getExperience() {  
  27.         return experience;  
  28.     }  
  29.       
  30.     public void displayResume() {  
  31.         System.out.println("姓名："+name+" 性别："+sex+" 年龄:"+age);  
  32.         System.out.println("工作经历："+experience);  
  33.     }  
  34. }  
  35.   
  36. public class MainClass {  
  37.     public static void main(String[] args) {  
  38.         Resume zhangsan = new Resume("zhangsan","男",24);  
  39.         zhangsan.setExperience("2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码复制");  
  40.         zhangsan.displayResume();  
  41.         Resume zhangsan1 = zhangsan;  
  42.         zhangsan1.setExperience("2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等");  
  43.         zhangsan.displayResume();  
  44.         zhangsan1.displayResume();  
  45.     }  
  46. }  

程序运行结果
[java]  view plain  copy
  1. 姓名：zhangsan 性别：男 年龄:24  
  2. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码复制  
  3. 姓名：zhangsan 性别：男 年龄:24  
  4. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等  
  5. 姓名：zhangsan 性别：男 年龄:24  
  6. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等  
在本程序中，生成了一份zhangsan的简历。之后又复制了一份简历zhangsan1，可见zhangsan1中工作经历发生变化时，zhangsan的工作经历也发生了变化。

2、浅拷贝

上面直接赋值的结果，有时候可能并不是我们所想要的。就像我们投简历的时候，可能会根据应聘公司的类型做出相应的调整，如果是投技术类的工作可能会偏技术一点；如果是投国企啊什么之类的，社会经历学生工作什么的可能也是很重要的一部分。所以我们不需要当我们修改一份简历的时候，所有的简历都变调。不然到时候投技术类的公司又得改回来。说了这么多，我们也就是希望，把a1赋值给a2之后，a1和a2能保持独立，不要互相影响。

实现上面想法之一的方法就是Object的Clone()函数了。在这里，我们需要了解clone()主要做了些什么，创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。
好，我们先看这一段话的前一部分，如果字段是值类型，则直接复制。如下面程序所示
[java]  view plain  copy
  1. package interfaces.nesting;  
  2.   
  3. /* 建立类，实现Clone方法  */  
  4. class Resume  implements Cloneable{  
  5.     private String name;  //姓名  
  6.     private String sex;   //性别  
  7.     private int age;      //年龄  
  8.     private String experience; //工作经历  
  9.       
  10.     public Resume(String name, String sex, int age) {  
  11.         this.name = name;  
  12.         this.sex = sex;  
  13.         this.age = age;  
  14.     }  
  15.       
  16.     public void setAge(int age) {  
  17.         this.age = age;  
  18.     }  
  19.     public int getAge() {  
  20.         return age;  
  21.     }  
  22.       
  23.     public void setExperience(String experience) {  
  24.         this.experience = experience;  
  25.     }  
  26.     public String getExperience() {  
  27.         return experience;  
  28.     }  
  29.       
  30.     public void displayResume() {  
  31.         System.out.println("姓名："+name+" 性别："+sex+" 年龄:"+age);  
  32.         System.out.println("工作经历："+experience);  
  33.     }  
  34.       
  35.     public Object clone() {  
  36.         try {  
  37.             return (Resume)super.clone();  
  38.         } catch (Exception e) {  
  39.             e.printStackTrace();  
  40.             return null;  
  41.         }  
  42.     }  
  43. }  
  44.   
  45. public class MainClass {  
  46.     public static void main(String[] args) {  
  47.         Resume zhangsan = new Resume("zhangsan","男",24);  
  48.         zhangsan.setExperience("2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码拷贝和粘贴");  
  49.         zhangsan.displayResume();  
  50.         Resume zhangsan1 = (Resume)zhangsan.clone();  
  51.         zhangsan1.setAge(23);  
  52.         zhangsan1.displayResume();  
  53.         Resume zhangsan2 = (Resume)zhangsan.clone();  
  54.         zhangsan2.setExperience("2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码");  
  55.         zhangsan2.displayResume();  
  56.         zhangsan.displayResume();  
  57.     }  
  58. }  

程序运行结果
[java]  view plain  copy
  1. 姓名：zhangsan 性别：男 年龄:24  
  2. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码拷贝和粘贴  
  3. 姓名：zhangsan 性别：男 年龄:23  
  4. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码拷贝和粘贴  
  5. 姓名：zhangsan 性别：男 年龄:24  
  6. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码  
  7. 姓名：zhangsan 性别：男 年龄:24  
  8. 工作经历：2009-2013就读于家里蹲大学，精通JAVA,C,C++,C#等代码拷贝和粘贴  
由程序的运行结果可以看出，我们实现了a1和a2引用的独立。

但是什么叫“如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。”，到底什么意思？不用着急，我们接下来看下面一段程序：
[java]  view plain  copy
  1. package interfaces.nesting;  
  2.   
  3. class Experience {  
  4.       
  5.     private String educationBackground;  
  6.     private String skills;  
  7.       
  8.     public void setExperience(String educationBackground, String skills) {  
  9.         // TODO Auto-generated constructor stub  
  10.         this.educationBackground = educationBackground;  
  11.         this.skills = skills;  
  12.     }  
  13.     public String toString() {  
  14.         return educationBackground + skills;  
  15.     }  
  16. }  
  17.   
  18. /* 建立类，实现Clone方法  */  
  19. class Resume  implements Cloneable{  
  20.     private String name;  //姓名  
  21.     private String sex;   //性别  
  22.     private int age;      //年龄  
  23.     private Experience experience; //工作经历  
  24.       
  25.     public Resume(String name, String sex, int age) {  
  26.         this.name = name;  
  27.         this.sex = sex;  
  28.         this.age = age;  
  29.         this.experience = new Experience();  
  30.     }  
  31.       
  32.     public void setAge(int age) {  
  33.         this.age = age;  
  34.     }  
  35.     public int getAge() {  
  36.         return age;  
  37.     }  
  38.       
  39.     public Experience getExperience() {  
  40.         return experience;  
  41.     }  
  42.       
  43.     public void setExperience(String educationBackground, String skills) {  
  44.         experience.setExperience(educationBackground, skills);  
  45.     }  
  46.       
  47.     public void displayResume() {  
  48.         System.out.println("姓名："+name+" 性别："+sex+" 年龄:"+age);  
  49.         System.out.println("工作经历："+experience.toString());  
  50.     }  
  51.       
  52.     public Object clone() {  
  53.         try {  
  54.             return (Resume)super.clone();  
  55.         } catch (Exception e) {  
  56.             e.printStackTrace();  
  57.             return null;  
  58.         }  
  59.     }  
  60. }  
  61.   
  62. public class MainClass {  
  63.     public static void main(String[] args) {  
  64.         Resume zhangsan = new Resume("zhangsan","男",24);  
  65.         zhangsan.setExperience("2009-2013就读于家里蹲大学","精通JAVA,C,C++,C#等代码拷贝和粘贴");  
  66.         zhangsan.displayResume();  
  67.   
  68.         Resume zhangsan2 = (Resume)zhangsan.clone();  
  69.         zhangsan2.setExperience("2009-2013就读于家里蹲大学","精通JAVA,C,C++,C#等");  
  70.         zhangsan2.displayResume();  
  71.         zhangsan.displayResume();  
  72.         zhangsan2.displayResume();  
  73.     }  
  74. }  
程序运行结果：
[java]  view plain  copy
  1. 姓名：zhangsan 性别：男 年龄:24  
  2. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等代码拷贝和粘贴  
  3. 姓名：zhangsan 性别：男 年龄:24  
  4. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等  
  5. 姓名：zhangsan 性别：男 年龄:24  
  6. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等  
  7. 姓名：zhangsan 性别：男 年龄:24  
  8. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等  
我们看一下上面两段程序差异在哪儿，第一段程序的工作经历是作为Resume类的一个普通的成员变量，也就是值属性。而后面一段程序中，工作经历Experience是一个类。结合上面程序的运行结果，我们再来理解“ 如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。” 其实也就是说，zhangsan和zhangsan2里面的Experience类指向的是同一个对象嘛！那不管是zhangsan里面的Experience变化，还是zhangsan2里面的Experience变化都会影响另外一个啊。

浅拷贝，大家懂没？Over了啊！

3、深拷贝

由前面的分析，浅拷贝无法实现含有其他对象引用的本对象的拷贝。那么很显然，深拷贝，就是说创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都乖乖的进行复制。
有了这个出发点，其实改起来很好改啊。浅拷贝的死穴就在于原始对象及其副本引用同一个对象，那我们让他们不指向同一个对象不就完了嘛！见代码：
[java]  view plain  copy
  1. package interfaces.nesting;  
  2.   
  3. class Experience {  
  4.       
  5.     private String educationBackground;  
  6.     private String skills;  
  7.       
  8.     public void setExperience(String educationBackground, String skills) {  
  9.         // TODO Auto-generated constructor stub  
  10.         this.educationBackground = educationBackground;  
  11.         this.skills = skills;  
  12.     }  
  13.     public String toString() {  
  14.         return educationBackground + skills;  
  15.     }  
  16. }  
  17.   
  18. /* 建立类，实现Clone方法  */  
  19. class Resume  implements Cloneable{  
  20.     private String name;  //姓名  
  21.     private String sex;   //性别  
  22.     private int age;      //年龄  
  23.     private Experience experience; //工作经历  
  24.       
  25.     public Resume(String name, String sex, int age) {  
  26.         this.name = name;  
  27.         this.sex = sex;  
  28.         this.age = age;  
  29.         this.experience = new Experience();  
  30.     }  
  31.       
  32.     public void setAge(int age) {  
  33.         this.age = age;  
  34.     }  
  35.     public int getAge() {  
  36.         return age;  
  37.     }  
  38.       
  39.     public Experience getExperience() {  
  40.         return experience;  
  41.     }  
  42.       
  43.     public void setExperience(String educationBackground, String skills) {  
  44.         experience = new Experience();  
  45.         experience.setExperience(educationBackground, skills);  
  46.     }  
  47.       
  48.     public void displayResume() {  
  49.         System.out.println("姓名："+name+" 性别："+sex+" 年龄:"+age);  
  50.         System.out.println("工作经历："+experience.toString());  
  51.     }  
  52.       
  53.     public Object clone() {  
  54.         try {  
  55.             return (Resume)super.clone();  
  56.         } catch (Exception e) {  
  57.             e.printStackTrace();  
  58.             return null;  
  59.         }  
  60.     }  
  61. }  
  62.   
  63. public class MainClass {  
  64.     public static void main(String[] args) {  
  65.         Resume zhangsan = new Resume("zhangsan","男",24);  
  66.         zhangsan.setExperience("2009-2013就读于家里蹲大学","精通JAVA,C,C++,C#等代码拷贝和粘贴");  
  67.         zhangsan.displayResume();  
  68.   
  69.         Resume zhangsan2 = (Resume)zhangsan.clone();  
  70.         zhangsan2.setExperience("2009-2013就读于家里蹲大学","精通JAVA,C,C++,C#等");  
  71.         zhangsan2.displayResume();  
  72.         zhangsan.displayResume();  
  73.         zhangsan2.displayResume();  
  74.     }  
  75. }  
程序运行结果：
[java]  view plain  copy
  1. 姓名：zhangsan 性别：男 年龄:24  
  2. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等代码拷贝和粘贴  
  3. 姓名：zhangsan 性别：男 年龄:24  
  4. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等  
  5. 姓名：zhangsan 性别：男 年龄:24  
  6. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等代码拷贝和粘贴  
  7. 姓名：zhangsan 性别：男 年龄:24  
  8. 工作经历：2009-2013就读于家里蹲大学精通JAVA,C,C++,C#等  
Springboot 错用list.stream , 遭遇list浅拷贝偷袭，实战图解
默默不代表沉默
07-04 1406
list 浅拷贝、深拷贝问题 ，list.stream() 是浅拷贝
深浅拷贝详解
weixin_42617262的博客
04-23 619
深浅拷贝 Object类clone()方法 深浅拷贝概念(重要) 深浅拷贝实现方式 我们首先来学习一下Object类中的clone()方法 //我们可以看到，clone()方法为本地方法，且使用该方法可能会抛出CloneNotSupportedException异常 protected native Object clone() throws CloneNotSupportedExceptio...
java深拷贝浅拷贝
binbin199604的博客
05-06 341
转载：http://blog.youkuaiyun.com/XIAXIA__/article/details/41652057 1、直接赋值 好，下面我们先看第一种方式，直接赋值。在Java中，A a1 = a2，我们需要理解的是这实际上复制的是引用，也就是说a1和a2指向的是同一个对象。因此，当a1变化的时候，a2里面的成员变量也会跟着变化。各位，请看下面的代码吧！
java 深拷贝 流_Java 浅拷贝和深拷贝
weixin_36111764的博客
02-16 306
其实出现问题的关键就在于clone()方法上，我们知道该clone()方法是使用Object类的clone()方法，但是该方法存在一个缺陷，它并不会将对象的所有属性全部拷贝过来，而是有选择性的拷贝，基本规则如下：1、 基本类型如果变量是基本很类型，则拷贝其值，比如int、float等。2、 对象如果变量是一个实例对象，则拷贝其地址引用，也就是说此时新对象与原来对象是公用该实例变量。3、 Strin...
流，序列化，深拷贝
qq_38331606的博客
07-24 281
流的分类 按照流的方向：输入流（inputStream）和输出流（outputStream）。 按照实现功能分：节点流（可以从或向一个特定的地方（节点）读写数据；如 FileReader）和处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写；如 BufferedReader。） 按照处理数据的单位：字节流和字符流。字节流继承于 InputStream 和 Outpu...
JavaScript深拷贝和浅拷贝概念与用法实例分析
01-19
js中的浅拷贝和深拷贝，只是针对复杂数据类型(Objcet，Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础上再生成一份的作用。但是根据新生成的对象能否影响到原对象可以分为浅拷贝和深拷贝。 ...
java，深拷贝和浅拷贝
水w的博客
09-16 1319
深拷贝和浅拷贝
Python中的深拷贝和浅拷贝详解
12-25
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝) 【变量-对象-引用】 在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象，type对象 Python...
Python 深拷贝和浅拷贝详解
03-09
对于不可变类型（如整数、字符串、元组），浅拷贝和深拷贝没有实质区别，因为这些类型不可变，所以拷贝后的新对象和原对象是等价的，但不一定是同一对象（即`is`操作符可能返回`False`）。 总之，深拷贝和浅拷贝的...
Java基础之X_深拷贝与浅拷贝
IMchg的博客
12-23 777
与python中深浅拷贝一样的，这里主要是介绍api。对于深拷贝，只要记住一点：深拷贝API都是非递归的方式 Java获取对象地址： https://blog.youkuaiyun.com/zhoufanyang_china/article/details/86750351 Java对象hashcode计算：所有对象都有hashcode，hashcode并不是由对象地址计算得到的，不能用于判断两个对象是否是同一个对象，上面和下面两个教程都可以说明 https://blog.youkuaiyun.com/baidu_37107.
Java中的深拷贝和浅拷贝
漏网之鱼
07-07 265
一、介绍 浅拷贝 对于基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象，而对于引用数据类型的成员变量（如：某个数组，某个类的对象等），浅拷贝会进行引用传递，也就是只是将该成员变量的内存地址复制一份给新的对象，因此复制前后的两个对象的该成员变量，都指向了同一个实例，所以浅拷贝引用类型成员变量的情况下，在一个对象中修改该成员变量必然会影响到另一个对象的该成员变量的值。 深拷贝 对于基本数据类型的成员变量，深拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象，换言之就是复
java 实现深度复制
轻描淡写
02-26 805
Java中，创建一个对象，我们通常会有一个引用（可以理解为变量）指向该对象，当我们通过引用变量改变对象的值（属性）时，引用是不变的，变的是内存里面的那块内存，即引用所指向的对象。引用意味着，任何人对引用所指向的对象属性或方法做改变时，都将会体现出来。有时候我们需要真正的复制（拷贝内存地址所有资料存放到另外一个地址，也就是同时拥有两份一模一样的东西在两个地方存在），而不仅仅是复制了改引用给另外一个变...
浅层复制与深层复制
qq_42428703的博客
09-26 266
几种浅拷贝 1、遍历循环复制 List<Person> destList = new ArrayList<Person>(srcList.size()); for(Person p : srcList){ destList.add(p); } 2、使用List实现类的构造方法 List<Person> destList = new ArrayList<Person>(srcList); 3、使用list.addAl
Java 浅拷贝和深拷贝的理解和实现方式
weixin_30656145的博客
08-12 156
转载：https://www.cnblogs.com/shakinghead/p/7651502.html Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。举例说明：比如，对象A和对象B都属于类S，具有属性a和b。那么对对象A进行拷贝操作赋值给对象B就是：B.a=A.a; B.b=A.b; 在程序中拷贝对象是...
C#中4种深拷贝方法介绍
寒冰屋的专栏
12-13 547
为什么要用到深拷贝呢？比如我们建了某个类Person，并且实例化出一个对象，然后，突然需要把这个对象复制一遍，并且复制出来的对象要跟之前的一模一样，来看下我们一般会怎么做。
List的浅拷贝和深拷贝
gpy1240301202的博客
10-25 623
需求描述：遍历菜单时，给有选择的菜单赋值为true 问题描述：所有菜单指向一个对象 // 问题代码 // 获取所有菜单列表 List<GrupInfo> gropDeopDown = crmGroupService.getGropDeopDown((byte) -1, -1L); List<ResourceInfoDto> resourceInfoDtos = funModel.stream().map(e -> { ... // 把菜单列表存入返回的d
最简单的深拷贝_飘云羽逸_新浪博客
飘云羽逸
10-16 334
package com.leitan.architect.pattern.prototype.deep;import java.io.*;import java.util.Date;public class QiTianDaSheng extends Monkey implements Cloneable, Serializable { public JinGuBang ji...
深拷贝和浅拷贝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、付费专栏及课程。

余额充值