C++中 memcpy 和赋值拷贝的核心区别

三、关键概念：平凡可拷贝类型（memcpy 的唯一安全适用类型）

上面表格中提到 memcpy 仅适用于平凡可拷贝类型（Trivially Copyable Type），这是 C++ 标准定义的概念，也是新手最容易踩坑的点——非平凡可拷贝类型用 memcpy 拷贝会直接导致程序崩溃/未定义行为。

1. 什么是平凡可拷贝类型？

满足以下条件的类型，称为平凡可拷贝类型：

• 内置类型：int/char/short/long/float/double/指针 等，都是平凡可拷贝类型；
• 自定义 struct/class：
  1. 没有自定义的拷贝构造函数、赋值运算符、析构函数；
  2. 所有成员变量都是平凡可拷贝类型；
  3. 没有虚函数/虚基类（虚函数会引入虚函数表指针，memcpy 拷贝会导致虚表指针混乱）；
  4. 继承体系中的所有基类都是平凡可拷贝类型。

简单来说：没有自定义拷贝/析构逻辑、没有虚函数、成员都是内置类型的简单结构体/类，就是平凡可拷贝类型。

2. 非平凡可拷贝类型（绝对不能用 memcpy）

典型的非平凡可拷贝类型：

• 包含动态内存分配的类（如 std::string、std::vector、自定义的链表/树类）；
• 有自定义拷贝构造/赋值运算符/析构函数的类；
• 包含虚函数/虚基类的类；
• 嵌套了非平凡可拷贝类型的结构体/类。

四、典型示例：正确使用 vs 错误使用（新手必看）

通过代码示例，直观感受二者的使用场景和错误后果，分为内置类型/简单结构体（memcpy 和赋值拷贝都可用）、自定义复杂类型（仅赋值拷贝可用，memcpy 必错）两个场景。

场景 1：内置类型/简单平凡可拷贝结构体（二者都安全，性能持平）

#include <cstring>
#include <iostream>
using namespace std;

// 简单结构体：无自定义拷贝/析构，无虚函数，成员都是内置类型→平凡可拷贝类型
struct Point {
    int x;
    int y;
};

int main() {
    // 1. 内置类型
    int a = 10, b = 0;
    b = a; // 赋值拷贝（值拷贝）
    memcpy(&b, &a, sizeof(int)); // memcpy 拷贝（逐字节拷贝 4 个字节），与赋值拷贝效果一致

    // 2. 简单结构体
    Point p1 = {1, 2}, p2 = {0, 0};
    p2 = p1; // 赋值拷贝（编译器自动逐成员值拷贝）
    memcpy(&p2, &p1, sizeof(Point)); // memcpy 拷贝（逐字节拷贝 8 个字节），与赋值拷贝效果一致

    cout << p2.x << "," << p2.y << endl; // 输出 1,2，两种方式都正确
    return 0;
}

说明：此场景下，memcpy 和赋值拷贝的效果完全一致，性能几乎没有区别（编译器对赋值拷贝的优化会和 memcpy 持平），实际开发中用赋值拷贝更简洁（无需写 sizeof）。

场景 2：自定义复杂类型（非平凡可拷贝，memcpy 拷贝直接崩溃）

以包含 std::string 的类为例（std::string 是典型的非平凡可拷贝类型，内部有动态内存分配）：

#include <cstring>
#include <iostream>
#include <string>
using namespace std;

// 复杂类：包含 std::string→非平凡可拷贝类型
struct Person {
    string name;
    int age;
    // 编译器自动生成拷贝构造/赋值运算符（深拷贝，会复制 string 的动态内存）
};

int main() {
    Person p1 = {"Tom", 20}, p2;
    // 方式 1：赋值拷贝（正确！触发编译器生成的赋值运算符，深拷贝 string）
    p2 = p1;
    cout << "赋值拷贝：" << p2.name << "," << p2.age << endl; // 输出 Tom,20

    // 方式 2：memcpy 拷贝（错误！未定义行为，大概率程序崩溃/野指针）
    Person p3;
    memcpy(&p3, &p1, sizeof(Person));
    cout << "memcpy 拷贝：" << p3.name << "," << p3.age << endl; // 崩溃/乱码
    return 0;
}

错误原因解析：

1. std::string 内部维护了指向堆内存的指针（存储字符串内容）、字符串长度、容量等成员；
2. memcpy 逐字节拷贝 Person 对象时，只是把 p1.name 中的堆指针值复制到 p3.name，而非复制堆内存中的字符串（浅拷贝）；
3. 当 p1/p3 析构时，会两次释放同一块堆内存（double free），直接导致程序崩溃；
4. 而赋值拷贝会触发 std::string 的赋值运算符重载，执行深拷贝（重新分配堆内存，复制字符串内容），避免了浅拷贝问题。

场景 3：含虚函数的类（memcpy 拷贝导致虚表指针混乱）

#include <cstring>
#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base" << endl;
    } // 虚函数，有虚表指针
    int a = 10;
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived" << endl;
    }
    int b = 20;
};

int main() {
    Derived d;
    Base b1, b2;
    b1 = d; // 赋值拷贝（正确！切片，虚表指针指向 Derived 的虚表）
    b1.show(); // 输出 Derived，正确

    memcpy(&b2, &d, sizeof(Base)); // 错误！memcpy 拷贝虚表指针，导致未定义行为
    b2.show(); // 崩溃/乱输出，虚表指针混乱
    return 0;
}

错误原因：含虚函数的类会有一个虚表指针（vptr），指向类的虚函数表（vtable）；memcpy 直接拷贝虚表指针的二进制值，会导致目标对象的虚表指针指向非法地址，调用虚函数时触发未定义行为。

五、性能对比：memcpy 是否一定更快？

很多人认为 memcpy 是底层操作，性能一定比赋值拷贝好，其实大部分场景下二者性能持平，只有超大块连续平凡可拷贝数据时，memcpy 才有微弱优势。

1. 内置类型/简单结构体：性能一致

编译器对 C++ 的赋值拷贝有极致优化（如 GCC/Clang 的 -O2/-O3 优化），会将内置类型的连续赋值拷贝直接优化为底层内存拷贝，和 memcpy 的汇编代码完全一致，性能没有区别。

比如：

int arr1[10000] = {1, 2, 3...};
int arr2[10000] = {0};
arr2 = arr1; // 赋值拷贝，编译器优化为 memcpy 级别的内存操作
memcpy(arr2, arr1, sizeof(arr1)); // 与上面性能一致

2. 超大块连续平凡可拷贝数据：memcpy 微优

当拷贝的内存块极大（如 100MB 以上的连续数组），memcpy 的底层实现（通常是汇编优化的块拷贝，如 x86 的 rep movsb 指令）会比编译器自动优化的赋值拷贝略快，因为 memcpy 是专门为内存拷贝设计的函数，无任何额外逻辑。

3. 自定义类型：赋值拷贝的性能取决于拷贝逻辑

如果自定义类型的拷贝构造/赋值运算符是深拷贝（如 std::vector），赋值拷贝的性能远低于 memcpy（但此时 memcpy 不能用，否则崩溃）；如果是浅拷贝（平凡可拷贝类型），则和 memcpy 性能持平。

六、实际开发中的选择原则（避坑核心）

开发中到底该用 memcpy 还是赋值拷贝？遵循**'能用人赋值拷贝，就不用 memcpy'的原则，仅在特定极致性能场景**下使用 memcpy，具体选择规则：

1. 优先使用赋值拷贝：
   • 适用于所有场景（内置/自定义类型），语法简洁、安全，符合 C++ 面向对象范式；
   • 无需关心字节数、类型是否可拷贝，编译器会兜底做类型检查和逻辑处理；
   • 自定义类型可通过重写拷贝构造/赋值运算符，灵活实现深拷贝/浅拷贝，避免内存问题。
2. 仅在以下场景使用 memcpy：
   • 拷贝的是平凡可拷贝类型（内置类型/简单结构体）；
   • 拷贝的是大块连续的内存数据（如超大数组、缓冲区），且对性能有极致要求；
   • 底层 C 风格编程（如操作裸指针、缓冲区、网络数据解析），需要直接操作内存二进制流。
3. 绝对禁止用 memcpy 的场景：
   • 拷贝非平凡可拷贝类型（含 std::string/std::vector、自定义拷贝逻辑、虚函数的类）；
   • 拷贝的内存地址存在重叠（此时应用 memmove，而非 memcpy，memcpy 不处理地址重叠）；
   • 无法准确计算拷贝的字节数 n（n 过大导致内存越界，n 过小导致拷贝不完整）。

七、补充：memcpy 与 memmove 的区别（避免地址重叠坑）

新手容易混淆 memcpy 和 memmove，这里简单补充：

• memcpy：不处理内存地址重叠，如果 dest 和 src 的内存区域有重叠，会导致拷贝数据错乱；
• memmove：处理内存地址重叠，内部会先把 src 的数据拷贝到临时缓冲区，再复制到 dest，避免错乱；
• 性能：memcpy 略快于 memmove（无临时缓冲区开销），无地址重叠时用 memcpy，有重叠时必须用 memmove。

示例：

int arr[5] = {1, 2, 3, 4, 5};
// 地址重叠：src=arr+1，dest=arr，拷贝 4 个 int
memcpy(arr, arr + 1, 4 * sizeof(int)); // 数据错乱，未定义行为
memmove(arr, arr + 1, 4 * sizeof(int)); // 正确，arr 变为{2,3,4,5,5}

总结

C++ 中 memcpy 和赋值拷贝的核心区别与使用原则，用 3 句话概括：

1. 本质区别：memcpy 是C 语言底层无类型的二进制逐字节拷贝，赋值拷贝是C++ 语法层面的有类型逻辑拷贝（内置类型值拷贝，自定义类型调用拷贝函数）；
2. 安全边界：memcpy 仅适用于平凡可拷贝类型，非平凡可拷贝类型（含动态内存/虚函数/自定义拷贝逻辑）用 memcpy 会导致崩溃/未定义行为，赋值拷贝则安全适配所有类型；
3. 选择原则：优先使用赋值拷贝（简洁、安全、符合 C++ 范式），仅在大块连续平凡可拷贝数据的极致性能场景下使用 memcpy，绝对避免在非平凡可拷贝类型上使用 memcpy。

新手最核心的避坑点：不要用 memcpy 拷贝 C++ 的自定义对象（尤其是 STL 容器、含虚函数/动态内存的类），赋值拷贝才是 C++ 的正确选择。