原文：mp.weixin.qq.com/s/qoKqHdLQ0… 我们在C++编程中，内存复制是一个非常常见的操作，而 memcpy 和 std::copy 是两种实现内存复制的典型方法。尽管它们都可以实现类似的功能，但它们之间有许多重要的区别。
🌟
基本概念介绍
memcpy
memcpy 是C标准库中的一个函数，定义在 头文件中。它的功能是从一个内存位置复制指定大小的字节到另一个内存位置。函数签名如下：
void* memcpy(void* dest, const void* src, std::size_t count);
参数说明：
dest：目标内存地址。
src：源内存地址。
count：要复制的字节数。
返回值：返回目标内存地址 dest。
std::copy
std::copy 是C++标准库中的一个算法，具体来说是 C++ STL 提供的算法，定义在 头文件中。它的功能是将一个范围内的元素复制到另一个范围中，支持多种容器和指针类型。函数模板如下：
template<class InputIt, class OutputIt>
OutputIt copy(InputIt first, InputIt last, OutputIt d_first);
参数说明：
first：源范围的起始迭代器。
last：源范围的结束迭代器（不包括此位置）。
d_first：目标范围的起始迭代器。
返回值：返回目标范围的尾后迭代器。
🦄
区别分析
1、使用场景
memcpy：
适用于底层的字节级别复制。
通常用于POD（Plain Old Data，传统C风格的数据类型），例如int、double、结构体等。
不关心数据的类型和对象的构造/析构。
std::copy：
适用于C++中的复杂对象，例如包含构造函数和析构函数的类对象。
适用于标准容器（如std::vector、std::array等）。
支持自定义的迭代器，因此更灵活。
需要类型安全的复制。
2、类型安全性
memcpy:
完全基于内存的字节级复制，不关心数据的类型。
容易出现类型不匹配的问题，例如将int类型的数据复制到double类型的内存区域，可能会导致未定义行为。
std::copy
基于模板实现，具有强大的类型安全性。
编译器会根据模板推导出合适的类型，如果类型不匹配，会在编译期报错。
会调用适当的拷贝构造函数或赋值运算符。
使用迭代器进行复制。
3、性能
memcpy：
通常情况下，memcpy的性能更高。
它是低级别的、针对特定硬件优化的函数，直接操作内存。
不执行额外的检查和构造/析构。
std::copy：
性能相对较低，尤其是当复制的对象需要调用拷贝构造函数时。
适合需要执行对象生命周期管理的场景。
4、 深浅拷贝
memcpy：
始终执行浅拷贝，即仅复制内存中的二进制数据。
对于指针类型或包含指针的对象，只会复制指针地址，不会复制指针指向的内容。
std::copy：
根据对象的定义，可以执行深拷贝。例如，如果对象实现了拷贝构造函数，std::copy会调用该构造函数。
5、 安全性
memcpy：
如果源和目标内存区域重叠，会导致未定义行为。
使用不当可能会导致缓冲区溢出等问题。
std::copy：
能够处理源和目标范围重叠的情况，适合更复杂的内存布局。
使用迭代器进行操作，更不容易出现内存越界问题。
✏
性能比较
写一个简单的示例
#include <iostream>
#include <chrono>
#include <algorithm>
#include <cstring>
#include <vector>
void performance_test() {
const int size = 10000000;
int* source = new int[size];
int* dest1 = new int[size];
int* dest2 = new int[size];
// 初始化数据
for (int i = 0; i < size; i++) {
source[i] = i;
}
// 测试 memcpy
auto start = std::chrono::high_resolution_clock::now();
memcpy(dest1, source, size * sizeof(int));
auto end = std::chrono::high_resolution_clock::now();
auto memcpy_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
// 测试 std::copy
start = std::chrono::high_resolution_clock::now();
std::copy(source, source + size, dest2);
end = std::chrono::high_resolution_clock::now();
auto copy_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
std::cout << "memcpy 耗时: " << memcpy_time << " 微秒\n";
std::cout << "std::copy 耗时: " << copy_time << " 微秒\n";
delete[] source;
delete[] dest1;
delete[] dest2;
}
针对这个案例，我自己测试，在数组数量小的时候，std::copy反而耗时更少，性能更好。当数组数量大到一定程度，memcpy性能更好。
🍞
使用建议
选择 memcpy 的情况：
当处理的是简单的 POD（Plain Old Data）类型数据
需要直接的内存复制
性能是首要考虑因素
确保源和目标内存不重叠
选择 std::copy 的情况：
处理非 POD 类型的 C++ 对象
需要确保类型安全
使用 STL 容器或迭代器
代码可维护性比性能更重要
可能存在内存重叠的情况
实际应用案例
处理基本类型数组
void basic_types_example() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[5];
// 两种方式都可以
memcpy(arr2, arr1, sizeof(arr1)); // 性能可能更好
std::copy(arr1, arr1 + 5, arr2); // 更符合 C++ 风格
}
处理自定义对象
class MyClass {
public:
MyClass() : data(0) {}
MyClass(const MyClass& other) : data(other.data) {
std::cout << "拷贝构造\n";
}
private:
int data;
};
void custom_class_example() {
std::vector<MyClass> vec1(5);
std::vector<MyClass> vec2(5);
// 正确：会调用拷贝构造函数
std::copy(vec1.begin(), vec1.end(), vec2.begin());
// 错误：不要使用 memcpy
// memcpy(&vec2[0], &vec1[0], vec1.size() * sizeof(MyClass));
}
💡
总结
选择 memcpy 还是 std::copy，需要根据具体场景来决定：
如果处理的是基本数据类型，并且性能是关键考虑因素，可以使用 memcpy
如果处理的是 C++ 对象，或者需要更好的类型安全性和可维护性，应该使用 std::copy
在现代 C++ 开发中，除非有特殊的性能要求，否则推荐使用 std::copy
对于 STL 容器的操作，始终应该优先考虑使用 std::copy
