深拷贝和浅拷贝

本文深入探讨了Python中拷贝的概念,包括六种基本数据类型的浅拷贝与深拷贝的区别,以及不同拷贝方式对可变类型和不可变类型的影响,并介绍了除copy模块外的其他拷贝方法。

1. 铺垫知识:

Python3中,有6个标准的数据类型,他们又分为可变和不可变。

1.1 不可变数据(3个):

  • Number(数字)
  • String(字符串)
  • Tuple(元组)

1.2可变数据(3个):

  • List(列表)
  • Dictionary(字典)
  • Set(集合)

2. 浅拷贝和深度拷贝

2.1浅拷贝

2.1.1 copy模块里面的copy方法实现
  1. 对于不可变类型 Number、String、Tuple,浅复制仅仅是地址指向,不会开辟新空间。
  2. 列表项对于可变类型List、Dictionary、Set,浅复制会开辟新的空间地址(仅仅是最顶层开辟了新的空间,里层的元素地址还是一样的),进行浅拷贝
  3. 浅拷贝后,改变原始对象中为可变类型的元素的值,会同时影响拷贝对象的;改变原始对象中为不可变类型的元素的值,只有原始类型受影响。(操作拷贝对象对原始对象的也是同理)

2.2 深拷贝

2.2.1 copy模块里面的deepcopy方法实现
  1. 深拷贝,除了顶层拷贝,还对子元素也进行了拷贝(本质上递归浅拷贝)
  2. 经过深拷贝后,原始对象和拷贝对象所有的元素地址都没有相同的了
  3. 可以用切片表达式进行浅拷贝
  4. 字典的copy方法可以拷贝一个字典
  5. 深拷贝内部子元素如果是不可变类型,但内部子元素的子元素存在可变类型,则按照可变类型的递归浅拷贝对子元素进行拷贝

3. 可变类型和不可变类型在浅拷贝中的区别

3.1 不可变类型 Number String Tuple

对于不可 变类型 Number String Tuple,浅复制仅仅是地址指向,不会开辟新空间拷贝值

import copy
num1 = 17
num2 = copy.copy(num1)

print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同


str1 = "hello"
str2 = copy.copy(str1)
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同

tup1 = (18, "tom")
tup2 = copy.copy(tup1)
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同

print("="*20)

3.2 可变类型 List、Dictionary、Set

对于可变类型 List、Dictionary、Set,浅复制会开辟新的空间地址(仅仅是最顶层开辟了新的空间),进行浅拷贝

list1 = [11,12]
list2 = copy.copy(list1)
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同


dic1 = [11,12,"hi"]
dic2 = copy.copy(dic1)
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同

set1 = {"AA","BB"}
set2 = copy.copy(set1)
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同

3.3 对于不可变类型被修改后造成的影响,我们用一个更加简单的例子便可更好理解:

num = 123
print(str(id(num)))

num = 666
print(str(id(num)))

console:

4348603632
4350009296

4. 深拷贝对6种基本类型的影响

我们对3种可变类型3种不可变类型进行深拷贝。
结果发现,和浅拷贝几乎一致。
其实这也好理解,因为深拷贝对比浅拷贝,强调的是递归,强调的是子元素。
对顶层的操作,深浅拷贝无异。

4.1 不可变类型 Number String Tuple

对于不可 变类型 Number String Tuple,深复制依然是地址指向,不会开辟新空间拷贝值

import copy
num1 = 17
num2 = copy.deepcopy(num1) # 深拷贝

print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同


str1 = "hello"
str2 = copy.deepcopy(str1)  # 深拷贝
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同

tup1 = (18, "tom")
tup2 = copy.deepcopy(tup1) # 深拷贝
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同

print("="*20)

4.2可变类型 List、Dictionary、Set

对于可变类型 List、Dictionary、Set,深拷贝会开辟新的空间地址,进行拷贝


list1 = [11,12]
list2 = copy.deepcopy(list1) # 深拷贝
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同


dic1 = [11,12,"hi"]
dic2 = copy.deepcopy(dic1) # 深拷贝
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同

set1 = {"AA","BB"}
set2 = copy.deepcopy(set1) # 深拷贝
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同

4.3浅拷贝的会对子元素也进行拷贝

import copy

l1 = [11, 12]
l2 = [21, 22]
num = 555

allOne = [l1, l2,num]


# 深拷贝,除了顶层拷贝,还对子元素也进行了拷贝(本质上递归浅拷贝)
# 经过深拷贝后,原始对象和拷贝对象所有的元素地址都没有相同的了

allOne2 = copy.deepcopy(allOne) # copy.deepcopy 深拷贝

allOne[1] = [113,114]
allOne2[2] = [227,228]

print(allOne)
print(allOne2)

print("id allOne:"+str(id(allOne)))
print("id allOne[0]:"+str(id(allOne[0])))
print("id allOne[1]:"+str(id(allOne[1])))
print("id allOne[2]:"+str(id(allOne[2])))

print("===")
print("id allOne2:"+str(id(allOne2)))
print("id allOne2[0]:"+str(id(allOne2[0])))
print("id allOne2[1]:"+str(id(allOne2[1])))
print("id allOne2[2]:"+str(id(allOne2[2])))

console

[[11, 12], [113, 114], 555]
[[11, 12], [21, 22], [227, 228]]
id allOne:4549589640
id allOne[0]:4554067720
id allOne[1]:4554067848
id allOne[2]:4548329424
===
id allOne2:4554067912
id allOne2[0]:4554067784
id allOne2[1]:4554067592
id allOne2[2]:4554100808

本例是跟浅拷贝做对比的。
在之前的浅拷贝中,子元素是不会开辟新空间做拷贝的。
而在深拷贝中,子元素也进行了拷贝。

5. 其他拷贝方式

除了copy模块的中的copy和deepcopy,还有其他自带的方式可实现拷贝。

  1. 分片表达式进行浅拷贝
  2. 字典的copy方法可以拷贝一个字典

5.1 分片表达式拷贝

l1 = [11, 12]
l2 = [21, 22]
num = 555
orgi = [l1, l2, num]
nList = orgi[:]
print("orgi:"+str(id(orgi)))
print("orgi[0]:"+str(id(orgi[0])))
print("orgi[1]:"+str(id(orgi[1])))
print("orgi[2]:"+str(id(orgi[2])))
print("*"*30)
print("nList:"+str(id(nList)))
print("nList[0]:"+str(id(nList[0])))
print("nList[1]:"+str(id(nList[1])))
print("nList[2]:"+str(id(nList[2])))

用分片表达式进行的拷贝,是浅拷贝。

5.2 字典自带的copy方法可实现深拷贝

dic = {"key": "hello", "num": 18}

dic2 = dic.copy()

dic["key"] = "one"
dic2["key"] = "two"

print(dic)
print("dic:" + str(id(dic)))

print(dic2)
print("dic2:" + str(id(dic2)))

console:
{'key': 'one', 'num': 18}
dic:4382946792
{'key': 'two', 'num': 18}
dic2:4382946864

<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_heightp1.m_height指向同一地址 ``` 析构时会导致**重复释放同一内存地址**,引发程序崩溃[^1] #### 四、应用场景分析 - **必须使用深拷贝**:类包含指针成员且指向动态分配内存时(如字符串、数组等) - **可使用浅拷贝**:仅包含基本数据类型或没有资源所有权的指针时 - **典型案例**:自定义容器类(如动态数组`Array`类[^4])、包含文件句柄的类
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值