[算法与数据结构][c++][python]:C++与Python中的赋值、浅拷贝与深拷贝

2024-01-09 18:30:36

C++与Python中的赋值、浅拷贝与深拷贝

写在前面:Python和C++中的赋值与深浅拷贝,由于其各自语言特性的问题,在概念和实现上稍微有点差异,本文将这C++和Python中的拷贝与赋值放到一起,希望通过对比学习两语言实现上的异同点,加深对概念的理解。

1.Python中的赋值、浅拷贝、深拷贝

C++中所谓的**浅拷贝就是由(系统默认的)拷贝构造函数对数据成员进行逐一的赋值,通常默认的拷贝构造函数就是可以达到该效果的,但是如果类中有指针类型的数据(需要在堆上分配内存),那么此时使用默认的拷贝构造函数就会带来错误。因为此时采用简单的浅拷贝,则两个类中的两个指针将指向同一个地址**,当对象释放时,会调用两次析构函数,而导致指针悬挂现象(悬浮指针)

而C++的**深拷贝则是,使用自定义的拷贝构造函数**,将原有对象的所有成员变量拷贝给新对象,对于指针等数据还会为新对象重新在堆上分配一块内存,并将原有对象所持有的堆上的数据也拷贝过来,这样能保证原有对象和新对象所持有的动态内存都是相互独立的,更改一个对象的数据不会影响另一个对象,同时也不会造成double free的错误。

C++中的**赋值,默认调用的是默认的拷贝构造函数即浅拷贝**,如果要使用深拷贝需要重载赋值运算符,为动态内存在堆上分配空间即可~

C++ 浅拷贝示例:

  #include <iostream>

  // 浅拷贝 使用默认的构造函数
  class shallowCopy {
  public:
      shallowCopy(int len) : m_len(len) {
          m_ptr = new int(0); // m_ptr指向一个值为0的int
      }
      shallowCopy() {}

      ~shallowCopy() {
          delete m_ptr;
      }

  public: // 定义为public,方便输出
      int* m_ptr;
      int m_len;
  };

int main()
{
  shallowCopy sc(1);
  auto sc1 = sc; // 浅拷贝
  std::cout << "shallowCopy: " << std::endl;
  std::cout << "sc.m_ptr = " << sc.m_ptr << std::endl;
  std::cout << "sc1.m_ptr = " << sc1.m_ptr << std::endl;  
}

>>>shallowCopy: 
sc.m_ptr = 0x560c930aeeb0
sc1.m_ptr = 0x560c930aeeb0
free(): double free detected in tcache 2  // 尝试两次释放同一地址!!!报错
Aborted

C++ 深拷贝示例:

#include <iostream>

  
class deepCopy {
  public:
      deepCopy(int len) : m_len(len) {
          std::cout << "call deepCopy(int len) " << std::endl;
          m_ptr = new int(1);
      }
      deepCopy(const deepCopy& deepcopy) {
          std::cout << "call deepCopy(const deepCopy& deepcopy) " << std::endl;
          m_len = deepcopy.m_len;
          m_ptr = new int(*(deepcopy.m_ptr)); // 重新分配内存,并且赋值
      } // 拷贝构造函数
      ~deepCopy() {
          delete m_ptr;
      }

  public:
      int* m_ptr;
      int m_len;
 };

int main()
{	
  std::cout << "deepCopy: " << std::endl;
  deepCopy dc(1);
  deepCopy dc1(dc); // 深拷贝
  std::cout << "dc.m_ptr = " << dc.m_ptr << std::endl;
  std::cout << "dc1.m_ptr = " << dc1.m_ptr << std::endl;    
}

>>>deepCopy: 
call deepCopy(int len) 
call deepCopy(const deepCopy& deepcopy) 
dc.m_ptr = 0x560c930af2e0
dc1.m_ptr = 0x560c930af300

2.C++中的赋值、浅拷贝、深拷贝

Python参数传递,“值传递”还是“引用传递“?一文中我们从Python中可变对象与不可变对象的角度理解了Python中的参数传递的方式,在赋值、深拷贝、浅拷贝中,我们同样从这个角度入手,理解Python中的深浅拷贝。对可变对象、不可变对象不是很清晰的同学,可以移步链接复习一下~。

  • 不可变对象:一旦创建就不可修改的对象,包括字符串、元组、数值类型

(该对象所指向的内存中的值不能被改变。当改变某个变量时候,由于其所指的值不能被改变,相当于把原来的值复制一份后再改变,这会开辟一个新的地址,变量再指向这个新的地址。)

  • 可变对象:可以修改的对象,包括列表、字典、集合

(该对象所指向的内存中的值可以被改变。变量(准确的说是引用)改变后,实际上是其所指的值直接发生改变,并没有发生复制行为,也没有开辟新的地址,通俗点说就是原地改变。)


2.1 概念

  1. 赋值,类似于C++中的引用(别名),只是复制了新对象的引用,不会开辟新的内存空间,Python中赋值的一般形式为a = 'nihao',内存中实现是:内存开辟空间存储字符串nihao,将a指向这块内存空间:
image-20240109135158539
  1. 浅拷贝: 创建新对象,其内容是原对象的引用。

? Python中的浅拷贝有三种形式: 切片操作,工厂函数,copy模块中的copy函数。

? 如: lst = [1,2,[3,4]]

? 切片操作lst1 = lst[:] 或者 lst1 = [each for each in lst]

? 工厂函数:lst1 = list(lst)

? copy函数:lst1 = copy.copy(lst)

?

? 浅拷贝之所以称为浅拷贝,是因为它仅仅只拷贝了一层,拷贝了最外围的对象本身,内部的元素都只是拷贝了一个引用而已,如在lst中有一个嵌套的 list[3,4],如果我们修改了它,情况就不一样了。

? 浅拷贝要分两种情况进行讨论:

? 1)当浅拷贝的值是*不可变对象(字符串、元组、数值类型)时和“赋值”的情况一样,对象的id值(id()函数用于获取对象的内存地址)***与浅拷贝原来的id值相同。

? 2)当浅拷贝的值是**可变对象(列表、字典、集合)**时会产生一个“不是那么独立的对象”存在。

? 2.1) 拷贝的可变对象中无复杂子对象,原来值的改变并不会影响浅拷贝的值,同时浅拷贝的值改变也并不会影响原来的值。

? 2.2) 拷贝的可变对象中有复杂子对象(例如列表中的一个子元素是一个列表),如果不改变其中复杂子对象,浅拷贝的值改变并不会影响原来的值。 但是改变原来的值中的复杂子对象的值会影响浅拷贝的值。

  1. 深拷贝:和浅拷贝对应,深拷贝拷贝了对象的所有元素,包括多层嵌套的元素。深拷贝出来的对象是一个全新的对象,不再与原来的对象有任何关联。

只有一种形式,copy模块中的deepcopy函数

2.2 示例:从例子中理解

1) 不可变对象的赋值、深拷贝、浅拷贝
import copy

# 不可变对象,无法添加删除元素
a = (1, 2, 3)

print("==========")
b = a
print(a, b)
print(id(a), id(b))

print("=====shallow copy=====")
s = copy.copy(a)
print(a, s)
print(id(a), id(s))

print("=====deep copy=====")
d = copy.deepcopy(a)
print(a, d)
print(id(a), id(d))

>>>==========
((1, 2, 3), (1, 2, 3))
(4564433008, 4564433008)
=====shallow copy=====
((1, 2, 3), (1, 2, 3))
(4564433008, 4564433008)
=====deep copy=====
((1, 2, 3), (1, 2, 3))
(4564433008, 4564433008)
2) 可变对象的赋值、浅拷贝与深拷贝
import copy

a = [1, 2, 3]
print("==========")
b = a
b.append(4)
print(a, b)
print(id(a), id(b)) # 赋值仅是变量的别名,两变量拥有相同的内存地址,无论更改哪一个另一个都会更改

a = [1, 2, 3]
print("=====shallow copy=====")
s = copy.copy(a)
print(a, s)
print(id(a), id(s))
a.append(4)
print("------append 4-------")
print(a, s)
print(id(a), id(s))

a = [1, 2, 3]
print("=====deep copy=====")
d = copy.deepcopy(a)
print(a, d)
print(id(a), id(d))
print("------append 4-------")
a.append(4)
print(a, d)
print(id(a), id(d))


>>>==========
([1, 2, 3, 4], [1, 2, 3, 4])
(4564157144, 4564157144)
=====shallow copy=====
([1, 2, 3], [1, 2, 3])
(4564158440, 4564158512)
------append 4-------
([1, 2, 3, 4], [1, 2, 3])
(4564158440, 4564158512)
=====deep copy=====
([1, 2, 3], [1, 2, 3])
(4564158368, 4564158440)
------append 4-------
([1, 2, 3, 4], [1, 2, 3])
(4564158368, 4564158440)
3) 可变对象深浅拷贝(外层、内层改变元素)

# 外层元素更改
import copy
l = [1, 2, 3, [4, 5]]

l1 = l
l2 = copy.copy(l)
l3 = copy.deepcopy(l)
l.append(6) 

print(l)
print(l1)
print(l2)
print(l3)

>>>[1, 2, 3, [4, 5], 6]
[1, 2, 3, [4, 5], 6]
[1, 2, 3, [4, 5]]
[1, 2, 3, [4, 5]]

# 内层元素更改
import copy
l = [1,2,3,[4, 5]]

l1 = l #赋值
l2 = copy.copy(l) #浅拷贝
l3 = copy.deepcopy(l) #深拷贝
l[3].append(6) 

print(l) 
print(l1)
print(l2)
print(l3)

>>> [1, 2, 3, [4, 5, 6]] 
[1, 2, 3, [4, 5, 6]] 
[1, 2, 3, [4, 5, 6]] 
[1, 2, 3, [4, 5]]
  1. 外层添加元素时,浅拷贝不会随原列表变化而变化;内层添加元素时,浅拷贝才会变化。

  2. 无论原列表如何变化,深拷贝都保持不变。

  3. 赋值对象随着原列表一起变化。

文章来源:https://blog.csdn.net/qq_41897558/article/details/135486327
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。