深拷贝与浅拷贝：理解与实现-CSDN博客

本文链接：https://blog.csdn.net/qq_37884031/article/details/148341545

引言

在编程中，尤其是处理复杂数据结构时，拷贝操作是我们经常需要进行的。然而，拷贝并非总是看起来那么简单。根据拷贝的"深度"不同，我们可以分为浅拷贝(shallow copy)和深拷贝(deep copy)。理解这两种拷贝方式的区别对于避免程序中的潜在错误至关重要。

什么是浅拷贝？

浅拷贝是最简单的拷贝形式，它只复制对象本身，而不复制对象所引用的其他对象。换句话说，浅拷贝创建了一个新对象，然后将原始对象的所有字段值复制到新对象中。如果字段是基本类型，就直接复制值；如果字段是引用类型，则复制引用但不复制引用的对象。

浅拷贝的特点

对于基本数据类型，直接复制值
对于引用数据类型，复制引用地址（指针）
原始对象和拷贝对象共享引用类型的成员变量
修改一个对象的引用类型成员会影响另一个对象

浅拷贝的实现示例（JavaScript）

// 对象浅拷贝
const original = { a: 1, b: { c: 2 } };
const shallowCopy = Object.assign({}, original);

// 或者使用展开运算符
const shallowCopy2 = { ...original };

// 修改浅拷贝后的对象会影响原对象
shallowCopy.b.c = 3;
console.log(original.b.c); // 输出 3，原对象也被修改了

什么是深拷贝？

深拷贝不仅复制对象本身，还递归复制对象所引用的所有对象。深拷贝创建的新对象与原始对象完全独立，修改其中一个不会影响另一个。

深拷贝的特点

对于基本数据类型，直接复制值
对于引用数据类型，递归复制整个对象
原始对象和拷贝对象完全不共享任何引用
修改一个对象不会影响另一个对象

深拷贝的实现示例（JavaScript）

// 简单深拷贝（有局限性）
const original = { a: 1, b: { c: 2 } };
const deepCopy = JSON.parse(JSON.stringify(original));

// 修改深拷贝后的对象不会影响原对象
deepCopy.b.c = 3;
console.log(original.b.c); // 输出 2，原对象保持不变

浅拷贝与深拷贝的比较

特性	浅拷贝	深拷贝
复制深度	只复制一层	递归复制所有层级
速度	快	慢（特别是对于复杂对象）
内存占用	少	多
引用类型处理	共享引用	创建新的独立对象
修改影响	影响原对象	不影响原对象

各种编程语言中的实现

Python

import copy

# 浅拷贝
original = [1, [2, 3]]
shallow = copy.copy(original)

# 深拷贝
deep = copy.deepcopy(original)

Java

// 浅拷贝 - 实现Cloneable接口并重写clone方法
class MyClass implements Cloneable {
    public Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}

// 深拷贝 - 需要手动实现
class MyClass implements Cloneable {
    private SomeObject ref;
    
    public Object clone() throws CloneNotSupportedException {
        MyClass copy = (MyClass)super.clone();
        copy.ref = new SomeObject(this.ref); // 深拷贝引用对象
        return copy;
    }
}

C++

// 浅拷贝 - 默认拷贝构造函数和赋值运算符
class MyClass {
    int* data;
public:
    // 默认拷贝构造函数是浅拷贝
    MyClass(const MyClass& other) : data(other.data) {}
};

// 深拷贝
class MyClass {
    int* data;
public:
    // 深拷贝构造函数
    MyClass(const MyClass& other) : data(new int(*other.data)) {}
    
    // 深拷贝赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete data;
            data = new int(*other.data);
        }
        return *this;
    }
};

何时使用浅拷贝或深拷贝？

使用浅拷贝的情况：

对象只包含基本数据类型
对象包含引用但希望共享这些引用
性能是关键因素且确定共享引用是安全的

使用深拷贝的情况：

对象包含引用且需要完全独立的副本
不确定原始对象是否会被修改
需要完全隔离两个对象的状态

常见问题与陷阱

循环引用问题：深拷贝时如果对象有循环引用，简单的递归实现会导致栈溢出。需要维护一个"已拷贝"映射表来解决。

function deepCopy(obj, map = new WeakMap()) {
    if (obj === null || typeof obj !== 'object') return obj;
    if (map.has(obj)) return map.get(obj);
    
    let copy = Array.isArray(obj) ? [] : {};
    map.set(obj, copy);
    
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            copy[key] = deepCopy(obj[key], map);
        }
    }
    return copy;
}