W jakich przypadkach powinienem używać memcpy zamiast standardowych operatorów w C++?

Możesz używać memcpy tylko wtedy, gdy kopiowane obiekty nie mają jawnych konstruktorów, tak jak ich członkowie (tzw. POD, "zwykłe stare dane"). Można więc wywołać memcpy dla float, ale źle jest dla, np. std::string.

Ale część pracy została już wykonana za Ciebie: std::copy from {[5] } jest wyspecjalizowana dla typów wbudowanych (i prawdopodobnie dla każdego innego typu POD-zależy od implementacji STL). Tak więc pisanie std::copy(a, a + 3, b) jest tak szybkie (po optymalizacji kompilatora) jak memcpy, ale jest mniej podatne na błędy.

Kompilatory specjalnie optymalizują memcpy wywołania, przynajmniej clang & gcc tak robi. Więc powinieneś go preferować, gdzie tylko możesz.

Użyj std::copy(). Jako plik nagłówkowy dla g++ Uwagi:

Ta wbudowana funkcja sprowadza się do wywołania @C memmove, o ile to możliwe.

Prawdopodobnie Visual Studio nie różni się zbytnio. Idź w normalny sposób i zoptymalizuj, gdy wiesz o szyjce butelki. W przypadku prostej kopii kompilator prawdopodobnie już się za Ciebie optymalizuje.

Nie wybieraj przedwczesnych mikro-optymalizacji, takich jak używanie memcpy w ten sposób. Użycie przypisania jest bardziej przejrzyste i mniej podatne na błędy, a każdy porządny kompilator wygeneruje odpowiednio wydajny kod. Jeśli, i tylko wtedy, gdy sprofilowałeś kod i uznałeś, że przypisania są znaczącym wąskim gardłem, możesz rozważyć pewien rodzaj mikro-optymalizacji, ale ogólnie powinieneś zawsze pisać jasny, solidny kod w pierwszej instancji.

Korzyści z memcpy? Prawdopodobnie czytelność. W przeciwnym razie musiałbyś wykonać kilka zadań lub mieć pętlę for do kopiowania, z których żadne nie jest tak proste i jasne jak wykonywanie memcpy (oczywiście, o ile Twoje typy są proste i nie wymagają budowy / niszczenia).

Ponadto, memcpy jest na ogół stosunkowo zoptymalizowane dla konkretnych platform, do tego stopnia, że nie będzie dużo wolniejsze niż proste przypisanie, a nawet może być szybsze.

Podobno, jak powiedział Nawaz, wersja przypisania powinna być szybsza na większości platform. To dlatego, że memcpy() będzie kopiować bajt po bajcie, podczas gdy druga wersja może kopiować 4 bajty na raz.

Jak zawsze, zawsze powinieneś profilować aplikacje, aby mieć pewność, że to, czego oczekujesz, będzie wąskim gardłem, pasuje do rzeczywistości.

Edit
To samo dotyczy tablicy dynamicznej. Skoro wspominasz o C++ powinieneś użyć algorytmu std::copy() w tym case.

Edit
Jest to kod wyjściowy dla Windows XP z GCC 4.5.0, skompilowany z flagą-o3:

extern "C" void cpy(float* d, float* s, size_t n)
{
    memcpy(d, s, sizeof(float)*n);
}

Wykonałem tę funkcję, ponieważ op podał również tablice dynamiczne.

Zestaw wyjściowy jest następujący:

_cpy:
LFB393:
    pushl   %ebp
LCFI0:
    movl    %esp, %ebp
LCFI1:
    pushl   %edi
LCFI2:
    pushl   %esi
LCFI3:
    movl    8(%ebp), %eax
    movl    12(%ebp), %esi
    movl    16(%ebp), %ecx
    sall    $2, %ecx
    movl    %eax, %edi
    rep movsb
    popl    %esi
LCFI4:
    popl    %edi
LCFI5:
    leave
LCFI6:
    ret

To jest wersja przypisania:

extern "C" void cpy2(float* d, float* s, size_t n)
{
    while (n > 0) {
        d[n] = s[n];
        n--;
    }
}

Co daje następujący kod:

_cpy2:
LFB394:
    pushl   %ebp
LCFI7:
    movl    %esp, %ebp
LCFI8:
    pushl   %ebx
LCFI9:
    movl    8(%ebp), %ebx
    movl    12(%ebp), %ecx
    movl    16(%ebp), %eax
    testl   %eax, %eax
    je  L2
    .p2align 2,,3
L5:
    movl    (%ecx,%eax,4), %edx
    movl    %edx, (%ebx,%eax,4)
    decl    %eax
    jne L5
L2:
    popl    %ebx
LCFI10:
    leave
LCFI11:
    ret

Który przenosi 4 bajty na raz.