std::copy与memcpy比较-Toy模板网

这篇具有很好参考价值的文章主要介绍了std::copy与memcpy比较。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

比较

std::copy和memcpy都可以用于内存块之间的复制操作，但有几个重要的异同点：

相同点：

它们都是C++中的函数，用于内存块之间的复制。
它们都是通过指针操作进行内存复制。

不同点：

std::copy是C++标准库中的函数，用于将一个范围内的元素从源地址复制到目标地址。因此它更加通用且类型安全，可以在不同类型的对象之间进行复制，也可以处理自定义类型。
memcpy是C标准库中的函数，只能用于字节级别的复制。因此，它不太灵活，不能处理自定义类型。
std::copy可以调用类的拷贝构造函数或赋值运算符来复制对象，而memcpy只是简单地按字节复制，不会调用类的任何成员函数。
当涉及到非平凡类型（如具有析构函数、虚函数等）时，使用std::copy比使用memcpy更安全，因为它确保正确地处理所有对象的生命周期。

例子

下面给出两个个分别用std::copy和memcpy拷贝char*p[1024]内容的例子

#include <algorithm>
#include <cstring>

int main()
{
    char* p[1024] = {"Hello", "World", "!"};

    // 使用std::copy拷贝
    char* copy_p[1024];
    std::copy(std::begin(p), std::end(p), std::begin(copy_p));

    // 使用memcpy拷贝
    char* memcpy_p[1024];
    std::memcpy(memcpy_p, p, sizeof(p));

    return 0;
}

#include <algorithm>
#include <cstring>

int main()
{
    const char* p = "Hello, world!";

    // 使用std::copy拷贝
    char copy_p[1024];  // 目标数组需要足够大以容纳源字符串
    std::copy(p, p + std::strlen(p) + 1, copy_p);
    std::cout << copy_p << std::endl;
    // 使用memcpy拷贝
    char memcpy_p[1024];  // 目标数组需要足够大以容纳源字符串
    std::memcpy(memcpy_p, p, std::strlen(p) + 1);
    std::cout << memcpy_p << std::endl;
    return 0;
}

在这个例子中，我们有一个名为p的指向字符串"Hello, world!"的指针。我们想要将这个字符串复制到另外两个数组copy_p和memcpy_p中。

对于使用std::copy的情况，我们创建一个名为copy_p的新字符数组，并调用std::copy函数来从源字符串p中复制所有字符到目标数组copy_p中。

对于使用memcpy的情况，我们创建一个名为memcpy_p的新字符数组，并调用std::memcpy函数来从源字符串p中复制所有字符到目标数组memcpy_p中。由于我们知道源字符串的长度，所以我们可以直接使用std::strlen§ + 1来计算复制的字节数量（需要加上字符串结束符’\0’）。

不适用std::copy却适用memcpy的场景

虽然std::copy和memcpy都可以用于内存块的复制，但是有一些情况下，可能更适合使用memcpy而不是std::copy：

对于简单类型（如char、int、float），使用memcpy通常比std::copy更快。
当源和目标内存区域没有重叠时，使用memcpy比std::copy更高效。因为在这种情况下，memcpy可以直接进行位拷贝，而不会涉及到元素迭代器和复制构造函数等操作。
当涉及到指针数组或者字符数组时，使用memcpy可能更方便，因为它不需要处理迭代器和元素复制构造函数等类型安全性问题。
当需要处理非平凡类型（如具有析构函数、虚函数等）时，使用memcpy可能会导致未定义行为，因此应该使用std::copy来确保处理正确的生命周期。

总之，当你确信要复制的内存区域是平凡类型，且源和目标内存区域没有重叠时，使用memcpy可能更加高效。但是在复杂情况下，还是推荐使用std::copy以确保正确的类型安全和生命周期处理。

适用std::copy不适用memcpy的场景

对于非POD（Plain Old Data）类型，如具有析构函数、虚函数等的类型，使用memcpy进行拷贝会导致其对象的生命周期不正确，从而可能导致未定义行为。
对于结构体或类中存在指针成员变量的情况，使用memcpy进行拷贝只是进行了浅拷贝，导致指针成员变量的指向不正确，从而可能导致未定义行为。
如果源内存区域和目标内存区域重叠，则结果是未定义的。
在使用memcpy时，需要确保源内存块的大小不小于目标内存块的大小，否则可能会导致缓冲区溢出或者内存泄漏等问题。

#include <algorithm>
#include <cstring>
#include <iostream>

class Person {
public:
    Person() {}
    Person(const std::string& name) : name_(name) {}
    virtual ~Person() {
        std::cout << name_ << std::endl;
    }  // 虚析构函数
    virtual void print() const { std::cout << "Person: " << name_ << std::endl; }
private:
    std::string name_;
};

int main()
{
    Person p1("Alice");
    Person p2("Bob");

    // 使用memcpy进行拷贝
    Person copied_p1;
    std::memcpy(&copied_p1, &p1, sizeof(Person));  // 此处使用了未定义的行为
    return 0;
}