¿En qué casos debo usar memcpy sobre operadores estándar en C++?

Puede usar memcpy solo si los objetos que está copiando no tienen constructores explícitos, así como sus miembros (los llamados POD, "Datos antiguos simples"). Así que está bien llamar memcpy para float, pero está mal para, por ejemplo, std::string.

Pero parte del trabajo ya se ha hecho para usted: std::copy de <algorithm> está especializado para tipos integrados (y posiblemente para cualquier otro tipo de POD-depende de la implementación de STL). Así que escribir std::copy(a, a + 3, b) es tan rápido (después de la optimización del compilador) como memcpy, pero es menos propenso a errores.

Los compiladores optimizan específicamente las llamadas memcpy, al menos clang & gcc lo hace. Así que deberías preferirlo donde puedas.

Use std::copy(). Como el archivo de cabecera para g++ notas:

Esta función en línea se reducirá a una llamada a @c memmove siempre que sea posible.

Probablemente, Visual Studio no es muy diferente. Ir con la forma normal, y optimizar una vez que eres consciente de un cuello de botella. En el caso de una copia simple, el compilador probablemente ya esté optimizando para usted.

No optes por micro-optimizaciones prematuras como usar memcpy de esta manera. El uso de la asignación es más claro y menos propenso a errores y cualquier compilador decente generará código adecuadamente eficiente. Si, y solo si, ha perfilado el código y encuentra que las asignaciones son un cuello de botella significativo, puede considerar algún tipo de microoptimización, pero en general siempre debe escribir código claro y robusto en primera instancia.

Los beneficios de memcpy? Probablemente legibilidad. De lo contrario, tendría que hacer un número de asignaciones o tener un bucle for para copiar, ninguno de los cuales es tan simple y claro como solo hacer memcpy (por supuesto, siempre y cuando sus tipos sean simples y no requieran construcción/destrucción).

Además, memcpy generalmente está relativamente optimizado para plataformas específicas, hasta el punto de que no será mucho más lento que una simple asignación, e incluso puede ser más rápido.

Supuestamente, como dijo Nawaz, la versión de asignación debería ser más rápida en la mayoría de las plataformas. Esto se debe a que memcpy() copiará byte por byte, mientras que la segunda versión podría copiar 4 bytes a la vez.

Como siempre es el caso, siempre debe perfilar las aplicaciones para asegurarse de que lo que espera que sea el cuello de botella coincide con la realidad.

Editar
Lo mismo se aplica a la matriz dinámica. Ya que mencionas C++ deberías usar std::copy() algoritmo en eso caso.

Editar
Esta es la salida de código para Windows XP con GCC 4.5.0, compilado con la bandera-O3:

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

He hecho esta función porque OP especificó matrices dinámicas también.

El conjunto de salida es el siguiente:

_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

Por supuesto, asumo que todos los expertos aquí saben lo que rep movsb significa.

Esta es la versión de asignación:

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

Que produce el siguiente código:

_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

Que mueve 4 bytes a la vez.