¿Cuál es la diferencia entre memmove y memcpy?

Question

¿Cuál es la diferencia entre memmove y memcpy? ¿Cuál usas habitualmente y cómo?

Answer 1

Con memcpy, el destino no puede superponerse a la fuente en absoluto. Con memmove puede. Esto significa que memmove podría ser un poco más lento que memcpy, ya que no puede hacer las mismas suposiciones. Por ejemplo, memcpy siempre copia direcciones de menor a mayor. Si el destino se superpone después de la fuente, esto significa que algunas direcciones se sobrescribirán antes de copiarse. memmove detectaría esto y copiaría en la otra dirección, de mayor a menor, en este caso. Sin embargo, comprobar esto y cambiar a otro algoritmo (posiblemente menos eficiente) lleva tiempo.

Answer 2

Uno maneja los destinos superpuestos y el otro no.

Answer 3

De la página del manual memcpy.

El memcpy() Función de copias n bytes de src área de memoria a la zona de memoria dest. Las áreas de memoria no deben superponerse a . Use memmove (3) si las áreas de memoria se superponen.

Answer 4

memmove puede manejar la superposición de memoria, memcpy no puede.

Considere

char[] str = "foo-bar"; 
memcpy(&str[3],&str[4],4); //might blow up 

Obviamente, el origen y el destino ahora se superponen, estamos sobrescribiendo "-bar" con la "barra". Es un comportamiento indefinido usando memcpy si la fuente y el destino se superponen, por lo que en este caso necesitamos memmove.

memmove(&str[3],&str[4],4); //fine 

Answer 5

La diferencia técnica se ha documentado bastante bien en las respuestas anteriores. Las diferencias prácticas también deben tenerse en cuenta:

Memcpy necesitará aproximadamente el doble de la cantidad de memoria para realizar la misma tarea, pero el memmove podría tomar mucho más tiempo que memcpy.

Ejemplo:

Digamos que usted tiene una lista de 100 elementos en la memoria, teniendo 100 MB de memoria. Ahora desea descartar la primera partida por lo que sólo tiene 99.

establecimiento de memoria requerirá la original de 100 MB y un adicional de 99 MB para su nueva lista de 99 artículos. Aproximadamente 199 MB en total para realizar la operación, pero debe ser muy rápido.

Memmove, en el peor de los casos, requerirá los 100 MB originales y moverá cada elemento 1 de la dirección de memoria a la vez. Esto solo requiere los 100 MB originales, pero será significativamente más lento que Memcpy.

Por supuesto, crear un nuevo puntero para apuntar al segundo elemento de su lista logrará el mismo efecto de "soltar" el primer elemento de su lista, pero el ejemplo muestra las diferencias en memcpy y memmove.

- EDITAR para ayudar a aclarar MI RESPUESTA CRAPPY -
Sí, las implementaciones de memcpy() y memmove() probablemente no difieren en el uso de memoria (que realmente no saben), pero ¿cómo se utiliza ellos afectarán enormemente el uso de la memoria de su programa. Eso es lo que quise decir con las diferencias prácticas de memcpy() y memmove().

int SIZE = 100; 
Item *ptr_item = (Item *) malloc(size_of(Item) * SIZE); 
Item *ptr_src_item = ptr_item + 1; 
Item *ptr_dst_item = ptr_item; 
memmove(ptr_dst_item, ptr_src_item, SIZE - 1); 

Esto crea su lista de elementos con el primer elemento faltante. Esto esencialmente no requiere más memoria para su programa que lo que se necesita para asignar el bloque de memoria ptr_item original. No puede hacer esto usando memcpy() ... si lo hiciera, su programa necesitaría asignar aproximadamente el doble de memoria.

int SIZE = 100; 
Item *ptr_src_item = (Item *) malloc(size_of(Item) * SIZE); 
Item *ptr_dst_item = (Item *) malloc(size_of(Item) * (SIZE - 1)); 
memcpy(ptr_dst_item, ptr_src_item, SIZE - 1); 

En este segundo bloque de código, el programa requerirá el doble de memoria que el primer bloque. Sin embargo, este segundo bloque debe funcionar significativamente más rápido que el primer bloque, especialmente a medida que aumenta TAMAÑO.

Así es como yo estaba tratando de explicar las diferencias prácticas en los dos ... pero ¿tal vez estoy equivocado con esto también?

Answer 6

La principal diferencia entre memmove() y memcpy() es que en memmove() un búfer - memoria temporal - se utiliza, por lo que no hay riesgo de solapamiento. Por otro lado, memcpy() copia directamente los datos de la ubicación que apunta la fuente a la ubicación señalada por el destino . (http://www.cplusplus.com/reference/cstring/memcpy/)

Considere los siguientes ejemplos:

1. #include <stdio.h> 
   #include <string.h> 
   
   int main (void) 
   { 
       char string [] = "stackoverflow"; 
       char *first, *second; 
       first = string; 
       second = string; 
   
       puts(string); 
       memcpy(first+5, first, 5); 
       puts(first); 
       memmove(second+5, second, 5); 
       puts(second); 
       return 0; 
   } 
   

   como se esperaba, esto va a imprimir:

   stackoverflow 
   stackstacklow 
   stackstacklow 
   

2. Sin embargo, en este ejemplo, los resultados no será el mismo:

   #include <stdio.h> 
   #include <string.h> 
   
   int main (void) 
   { 
       char string [] = "stackoverflow"; 
       char *third, *fourth; 
       third = string; 
       fourth = string; 
   
       puts(string); 
       memcpy(third+5, third, 7); 
       puts(third); 
       memmove(fourth+5, fourth, 7); 
       puts(fourth); 
       return 0; 
   } 
   

   Salida:

   stackoverflow 
   stackstackovw 
   stackstackstw 
   

Se debe a que "memcpy()" hace lo siguiente:

1. stackoverflow 
2. stacksverflow 
3. stacksterflow 
4. stackstarflow 
5. stackstacflow 
6. stackstacklow 
7. stackstacksow 
8. stackstackstw 

Answer 7

Intenté funcionar por encima de código: La razón principal quiero saber la diferencia de memcpy y memmove.

#include <stdio.h> 
#include <string.h> 

int main (void) 
{ 
    char string [] = "stackoverflow"; 

    char *third, *fourth; 

    third = string; 

    fourth = string; 

    puts(string); 

    memcpy(third+5, third, 7); 

    puts(third); 

    memmove(fourth+5, fourth, 7); 

    puts(fourth); 

    return 0; 
} 

da debajo de la salida

stackoverflow 
stackstackovw 
stackstackstw 

Ahora he reemplazado con memmovememcpy y me dio la misma salida

#include <stdio.h> 
#include <string.h> 

int main (void) 
{ 
    char string [] = "stackoverflow"; 

    char *first, *second; 

    first = string; 

    second = string; 

    puts(string); 

    memcpy(first+5, first,7); 

    puts(first); 

    memcpy(second+5, second, 7); 

    puts(second); 

    return 0; 
} 

Salida:

stackoverflow 
stackstackovw 
stackstackstw 

Answer 8

simplemente fr om el estándar ISO/IEC: 9899 está bien descrito.

7.21.2.1 La función memcpy

[...]

2 La función copia memcpy n caracteres del objeto apuntado por s2 en el objeto apuntado por s1. Si la copia se realiza entre objetos que se superponen, el comportamiento no está definido.

Y

7.21.2.2 La función memmove

[...]

2 La función copia memmove n caracteres del objeto apuntado por s2 en el objeto apuntado por s1. La copia se lleva a cabo como si los n caracteres del objeto apuntados por s2 se copiaran primero en una matriz temporal de n caracteres que no se se superponen los objetos apuntados por s1 y s2, y luego los n caracteres del matriz temporal se copian en el objeto señalado por s1.

Cuál usualmente uso según la pregunta, depende de qué función necesito.

en texto plano memcpy() no permite s1 y s2 a solaparse, mientras memmove() hace.

Answer 9

cadena de caracteres [] = "stackoverflow";

char *first, *second; 

first = string; 

second = string; 

puts(string); 

o/p - Stackoverflow

memcpy(first+5, first,7); 

puts(first); 

Aquí 7 caracteres apuntados por segundo es decir, "stackov" pegado en 5 posición resultante

o/p - stackstackovw

memcpy(second+5, second, 7); 

puts(second); 

aquí la cadena de entrada es "stackstackovw", 7 caracteres apuntados por segundo (i.e "stackst") se copia en una memoria intermedia, entonces pegada en el lugar de 5 resultante

o/p - stackstackstw

0 ----- + 5
stackst pila w

Answer 10

Hay son dos maneras obvias para implementar mempcpy(void *dest, const void *src, size_t n) (ignorando el valor de retorno):

1. for (char *p=src, *q=dest; n-->0; ++p, ++q) 
       *q=*p; 
   

2. char *p=src, *q=dest; 
   while (n-->0) 
       q[n]=p[n]; 
   

En la primera implementación, la copia procede de direcciones bajas a altas, y en el segundo, de mayor a menor. Si el rango que se va a copiar se superpone (como ocurre cuando se desplaza un framebuffer, por ejemplo), solo una dirección de operación es correcta y la otra sobrescribirá las ubicaciones de las que posteriormente se leerá.

Una implementación de memmove(), en su forma más simple, probará dest<src (de alguna manera dependiente de la plataforma), y ejecutará la dirección apropiada de memcpy().

El código de usuario no puede hacer eso, por supuesto, porque incluso después de convertir src y dst en algún tipo de puntero concreto, no apuntan (en general) al mismo objeto y, por lo tanto, no se pueden comparar. Pero la biblioteca estándar puede tener suficiente conocimiento de plataforma para realizar dicha comparación sin causar un Comportamiento no definido.

---

Tenga en cuenta que en la vida real, las implementaciones tienden a ser significativamente más complejo, para obtener el máximo rendimiento de las transferencias más grandes (cuando lo permita la alineación) y/o una buena utilización de caché de datos. El código anterior es solo para hacer el punto lo más simple posible.

Answer 11

memmove puede ocuparse de la superposición de regiones de origen y destino, mientras que memcpy no. Entre los dos, memcpy es mucho más eficiente. Entonces, es mejor usar memcpy si puedes.

Referencia: https://www.youtube.com/watch?v=Yr1YnOVG-4g Dr. Jerry Caín, (Stanford Introducción Sistemas de Conferencia - 7) Hora: 36:00