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

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指向这块内存空间：

2. 浅拷贝: 创建新对象，其内容是原对象的引用。

? 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) 拷贝的可变对象中有复杂子对象（例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象，浅拷贝的值改变并不会影响原来的值。 但是改变原来的值中的复杂子对象的值会影响浅拷贝的值。

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

只有一种形式，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. 赋值对象随着原列表一起变化。