如果你真的需要最大的复制性能(你可能不需要)，这两个都不要用。

可以做很多事情来优化内存复制——如果你愿意使用多个线程/内核的话，甚至可以做得更多。例如:

在这个memcpy实现中缺少什么/不是最优的?

问题和一些答案都建议了实现或实现的链接。

如果你真的需要最大的复制性能(你可能不需要)，这两个都不要用。

可以做很多事情来优化内存复制——如果你愿意使用多个线程/内核的话，甚至可以做得更多。例如:

在这个memcpy实现中缺少什么/不是最优的?

问题和一些答案都建议了实现或实现的链接。

我的原则很简单。如果你正在使用c++，更喜欢c++库而不是C:)

始终使用std::copy，因为memcpy仅限于c风格的POD结构，如果目标实际上是POD，编译器可能会用memcpy替换对std::copy的调用。

另外，std::copy可以用于许多迭代器类型，而不仅仅是指针。Std::copy更灵活，没有性能损失，是明显的赢家。

我所知道的所有编译器都会在适当的时候用memcpy替换一个简单的std::copy，或者更好的是，将拷贝向矢量化，这样它会比memcpy更快。

在任何情况下:侧写和找出自己。不同的编译器会做不同的事情，它很可能不会完全按照你的要求去做。

请参阅编译器优化的介绍(pdf)。

下面是GCC对POD类型的简单std::拷贝所做的工作。

#include <algorithm>

struct foo
{
  int x, y;    
};

void bar(foo* a, foo* b, size_t n)
{
  std::copy(a, a + n, b);
}

下面是反汇编(只有-O优化)，显示了对memmove的调用:

bar(foo*, foo*, unsigned long):
    salq    $3, %rdx
    sarq    $3, %rdx
    testq   %rdx, %rdx
    je  .L5
    subq    $8, %rsp
    movq    %rsi, %rax
    salq    $3, %rdx
    movq    %rdi, %rsi
    movq    %rax, %rdi
    call    memmove
    addq    $8, %rsp
.L5:
    rep
    ret

如果将函数签名更改为

void bar(foo* __restrict a, foo* __restrict b, size_t n)

然后memmove变成memcpy，以实现轻微的性能改进。注意，memcpy本身将被大量向量化。

分析显示:std::copy()总是和memcpy()一样快或更快为false。

我的系统:

HP-Compaq-dx7500-Microtower 3.13.0-24-generic #47-Ubuntu SMP周五5月2日 23:30:00 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux。 gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2

代码(语言:c++):

    const uint32_t arr_size = (1080 * 720 * 3); //HD image in rgb24
    const uint32_t iterations = 100000;
    uint8_t arr1[arr_size];
    uint8_t arr2[arr_size];
    std::vector<uint8_t> v;

    main(){
        {
            DPROFILE;
            memcpy(arr1, arr2, sizeof(arr1));
            printf("memcpy()\n");
        }

        v.reserve(sizeof(arr1));
        {
            DPROFILE;
            std::copy(arr1, arr1 + sizeof(arr1), v.begin());
            printf("std::copy()\n");
        }

        {
            time_t t = time(NULL);
            for(uint32_t i = 0; i < iterations; ++i)
                memcpy(arr1, arr2, sizeof(arr1));
            printf("memcpy()    elapsed %d s\n", time(NULL) - t);
        }

        {
            time_t t = time(NULL);
            for(uint32_t i = 0; i < iterations; ++i)
                std::copy(arr1, arr1 + sizeof(arr1), v.begin());
            printf("std::copy() elapsed %d s\n", time(NULL) - t);
        }
    }

g++ -O0 -o test_stdcopy test_stdcopy.cpp Memcpy()配置文件:main:21: now:1422969084:04859 elapsed:2650 us Std::copy()配置文件:main:27: now:1422969084:04862 elapsed:2745 us Memcpy()消失44秒std::copy()消失45秒 g++ -O3 -o test_stdcopy test_stdcopy.cpp Memcpy()配置文件:主要:21:现在:1422969601:04939经过:2385 us Std::copy()配置文件:main:28: now:1422969601:04941 elapsed:2690 us Memcpy()消失了27秒std::copy()消失了43秒

红色警报指出，代码使用memcpy从数组到数组和std::复制从数组到向量。这可能是memcpy更快的原因。

因为有

v .储备(sizeof (arr1);

复制到向量或数组时应该没有区别。

代码在这两种情况下都固定使用数组。Memcpy更快:

{
    time_t t = time(NULL);
    for(uint32_t i = 0; i < iterations; ++i)
        memcpy(arr1, arr2, sizeof(arr1));
    printf("memcpy()    elapsed %ld s\n", time(NULL) - t);
}

{
    time_t t = time(NULL);
    for(uint32_t i = 0; i < iterations; ++i)
        std::copy(arr1, arr1 + sizeof(arr1), arr2);
    printf("std::copy() elapsed %ld s\n", time(NULL) - t);
}

memcpy()    elapsed 44 s
std::copy() elapsed 48 s