浅拷贝 vs 深拷贝 (C++)

🎯 浅拷贝 vs 深拷贝

浅拷贝和深拷贝是 C++ 中关于对象拷贝的两个核心概念，直接关系到内存安全、资源管理和程序稳定性。

📋 一、浅拷贝（Shallow Copy）

定义

浅拷贝只是简单地复制对象的所有成员变量的值（对于指针类型，只复制指针本身，不复制指针指向的数据）。

默认行为

如果类没有自定义拷贝构造函数和赋值运算符，编译器会自动生成一个默认拷贝构造函数和默认赋值运算符，它们执行的就是浅拷贝。

示例代码

cpp

class Shallow {
public:
    int* data;
    int size;
    
    Shallow(int s) : size(s) {
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = i;
        }
    }
    
    // 使用编译器默认生成的拷贝构造函数（浅拷贝）
    // Shallow(const Shallow& other) = default;  // 默认行为
};

int main() {
    Shallow obj1(5);
    Shallow obj2 = obj1;  // 浅拷贝！
    
    // obj1.data 和 obj2.data 指向同一块内存！
    
    obj1.data[0] = 100;
    std::cout << obj2.data[0];  // 输出 100（互相影响）
    
    // 析构时：同一块内存被释放两次 → 崩溃！
    return 0;
}

问题示意图

text

原始对象 (obj1)          拷贝对象 (obj2)
┌─────────────┐         ┌─────────────┐
│ data: 0x100 │ ────→   │ data: 0x100 │ ────→  同一块堆内存
│ size: 5     │         │ size: 5     │
└─────────────┘         └─────────────┘
         ↑                       ↑
         └─────── 共享 ──────────┘

核心问题：

• ✅ 成员变量 size 被正确复制

• ❌ 指针 data 只复制了地址（值），两个对象指向同一块内存

• ❌ 修改一个对象的数据会影响另一个（数据竞争）

• ❌ 析构时重复释放（double free）→ 程序崩溃

📋 二、深拷贝（Deep Copy）

定义

深拷贝不仅复制对象本身，还会递归复制指针所指向的动态分配内存，为新对象分配独立的内存空间。

示例代码

cpp

class Deep {
public:
    int* data;
    int size;
    
    Deep(int s) : size(s) {
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = i;
        }
    }
    
    // 自定义拷贝构造函数（深拷贝）
    Deep(const Deep& other) : size(other.size) {
        data = new int[size];              // 分配新内存
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];       // 复制数据
        }
    }
    
    // 自定义赋值运算符（深拷贝）
    Deep& operator=(const Deep& other) {
        if (this != &other) {               // 防止自赋值
            delete[] data;                  // 释放旧内存
            size = other.size;
            data = new int[size];           // 分配新内存
            for (int i = 0; i < size; i++) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }
    
    ~Deep() {
        delete[] data;  // 每个对象释放自己的内存
    }
};

int main() {
    Deep obj1(5);
    Deep obj2 = obj1;  // 深拷贝！
    
    // obj1.data 和 obj2.data 指向不同的内存块
    
    obj1.data[0] = 100;
    std::cout << obj2.data[0];  // 输出 0（不受影响）
    
    // 析构时各自释放自己的内存 → 安全！
    return 0;
}

示意图

text

原始对象 (obj1)          拷贝对象 (obj2)
┌─────────────┐         ┌─────────────┐
│ data: 0x100 │ ────→   │ data: 0x200 │ ────→  独立堆内存
│ size: 5     │         │ size: 5     │
└─────────────┘         └─────────────┘
     ↓                         ↓
  [0,1,2,3,4]              [0,1,2,3,4]  完全独立

🆚 三、对比表格

🎮 四、游戏服务器中的实际场景

场景 1：玩家对象（必须深拷贝）

cpp

class Player {
public:
    std::string name;
    int* scores;        // 动态数组
    int scoreCount;
    
    // 必须实现深拷贝
    Player(const Player& other) 
        : name(other.name), scoreCount(other.scoreCount) {
        scores = new int[scoreCount];
        std::copy(other.scores, other.scores + scoreCount, scores);
    }
};

场景 2：网络数据包（浅拷贝 + 引用计数）

cpp

class Packet {
public:
    char* data;
    int size;
    std::shared_ptr<char> sharedData;  // 使用智能指针自动管理
    
    // 智能指针自动实现安全的"浅拷贝"（引用计数）
    Packet(const Packet& other) = default;  // shared_ptr 自动处理
};

场景 3：只读配置表（浅拷贝即可）

cpp

class Config {
public:
    const int* configData;  // 指向只读全局数据
    int length;
    
    // 浅拷贝足够，因为数据是只读的
    Config(const Config& other) = default;
};

🛡️ 五、如何避免手写深拷贝

1. 使用 RAII 容器（推荐）⭐⭐⭐⭐⭐

cpp

class BetterPlayer {
public:
    std::string name;
    std::vector<int> scores;  // 自动管理内存
    
    // 不需要自定义拷贝，vector 自动深拷贝
    // BetterPlayer(const BetterPlayer&) = default;  // 安全！
};

2. 使用智能指针

cpp

class Player {
public:
    std::shared_ptr<int[]> scores;  // 自动引用计数
    int scoreCount;
    
    // 默认拷贝安全（共享所有权，自动管理）
    Player(const Player&) = default;
};

3. 禁止拷贝

cpp

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

🎯 六、面试高频考点

Q1: 什么时候需要深拷贝？

A: 当类包含动态分配的内存、文件句柄、网络连接等资源时，必须实现深拷贝。

Q2: 为什么不推荐手动实现深拷贝？

A:

1. 容易出错（自赋值、异常安全）

2. 代码冗长

3. 推荐使用 RAII 容器（如 std::vector）替代原始指针

Q3: 移动语义和深拷贝的区别？

A:

• 深拷贝：复制资源（资源翻倍）

• 移动语义：转移资源所有权（零拷贝）

cpp

Player(Player&& other) noexcept 
    : scores(other.scores), scoreCount(other.scoreCount) {
    other.scores = nullptr;  // 窃取资源
}

Q4: 什么是拷贝赋值运算符的"自赋值"问题？

cpp

Player& operator=(const Player& other) {
    if (this == &other) return *this;  // 必须检查！
    // ... 否则：delete[] data; 再复制自己 → 崩溃
}

💡 七、最佳实践总结

🚀 八、面试回答模板

"浅拷贝只复制对象的值，对于指针只复制地址，导致多个对象共享同一块内存，容易引发 double free。深拷贝则会为新对象分配独立的内存，复制指针指向的数据。

在游戏服务器开发中，玩家数据、场景对象等包含动态资源的类必须实现深拷贝。但更好的做法是使用 RAII 容器（如 std::vector）或智能指针，避免手动管理内存。

根据 C++ 的三五法则，如果类需要自定义析构函数，通常也需要自定义拷贝构造和拷贝赋值。现代 C++ 中，我们更推荐使用移动语义来优化性能，避免不必要的深拷贝。"