ft_memmove.c

Esta función permite copiar una cantidad de bytes de la cadena de orígen a la de destino. En este caso no se contempla el problema de superposición, ya que lo veremos en el próximo ejercicio.

Enunciado

memmove(3)

NOMBRE
    memcpy --> copia una cadena
CABECERA
    void *memmove(void *dst, const void *src, size_t n);
DESCRIPCIÓN
    Copia `n` bytes de la cadena de orígen `src` hacia la de destino `dst`. En caso de que se droduzca una superposición de datos, preserva la integridad de estos, copiandolos de una forma no destructiva.
DEVOLUCIÓN
    Devuelve el valor original de `dst`.

Esta función, hace lo mismo que memcpy, pero esta vez, se realiza la copia de forma no destructiva, es decir que en caso de que las dos cadenas ('src' y 'dst') se superpongan en memoria, no se va a sobreescribir nada que cause una pérdida de datos.

Para hacer ese control, deberemos comprobar si realmente hay superposición, para saber si empezar copiando desde la izquierda (como es habitual) o por lo contrario, lo haremos al revés (por la derecha).

Superposición de memória

Tal y como puedes ver en esta explicación de "Medium", se produce un overlap de memória en cuanto al copiar byte por byte una cadena, resulta que cuando llegamos a un punto donde al intentar copiar un valor, vemos que ese ya ha sido modificado con uno de los valores que hemos copiado anteriormente.

Supongamos que disponemos de una cadena de 5 chars, donde cada uno equivale a un byte de longitud:

+++++++++++++++++++++++++++++++
| 'a' | 'b' | 'c' | 'd' | 'e' |
+++++++++++++++++++++++++++++++
 0x100 0x101 0x102 0x103 0x104

Ahora, recordando el planteamiento del manual acerca de memcpy, tomamos 3 argumentos, un puntero al bloque de memória de origen y el tamaño de los bytes que queremos copiar de un lado al otro.

¿Qué pasaría si el destino fuera 0x102, el orígen 0x100 y el tamaño, fuera 3 ? En este caso, ocurre la superposición de memórias. Es decir que, 0x100 sería copiado sobre 0x102, 0x101 sería copiado sobre 0x103 y 0x102 lo sería sobre 0x104.

Date cuenta que primero copiamos 0x102. Cuando siguiendo la cadena, procedemos a copiar 0x102, su valor se ha perdido ya que lo hemos sobreescrito a medida que copiabamos los valores. Por tanto, terminaremos con algo parecido a esto:

+++++++++++++++++++++++++++++++
| 'a' | 'b' | 'a' | 'b' | 'a' |
+++++++++++++++++++++++++++++++
 0x100 0x101 0x102 0x103 0x104

En lugar de:

+++++++++++++++++++++++++++++++
| 'a' | 'b' | 'a' | 'b' | 'c' |
+++++++++++++++++++++++++++++++
 0x100 0x101 0x102 0x103 0x104

Entonces, ¿Cómo se ocupa la función memmove de evitar la superposición?

De acuerdo a la página original del manual, primero copiaremos los valores en una matriz temporal y luego los pegaremos en un bloque distinto al que estaban en inicio, a diferencia de memcpy que pega el contenido sobre el mismo bloque donde se ubicab anteriormente

Planteamiento

ft_memmove.c

#include "libft.h"

void *ft_memmove(void *dst, const void *src, size_t n) {
    /* definimos un contador y lo inicializamos a su valor predeterminado */
    /* definimos como variable auxiliar, un puntero para trabajar con `dst`, puesto que al ser void no tiene tipaje. Inicializamos el valor de nuestra variable auxiliar a `(unsigned char *)`.
     * definimos como variable auxiliar un puntero para trabajar con `src`. Inicializamos el valor de nuestra variable auxiliar a `(unsigned const char *) */
    if (/* destino es mayor que origen, es decir que SI hay `overlap` */) {
        while(/* `n` sea mayor o igual a `0` */) {
            /* establecemos el valor de la posición (n - 1) de `dst` al carácter (n - 1) de `src` es decir, copiaremos de derecha a izquierda */
            /* preparamos la siguiente iteración */
        }
    }
    /* en caso contrario, es decir, si NO hay `overlap` */
    else {
        /* copiamos en el sentido habitual */
    }
    /* bajo cualquier caso, devolveremos `dst` */
    return (dst);
}

Solución

Recuerda: para entregar tu proyecto, debes poder defenderlo. Por ello, resuelve cada enunciado con la respuesta que te parezca mas entendible a nivel presonal.

J: "No hay respuestas incorrectas, solo puntos de vista distantes".

Solución Base

ft_memcpy.c

#include "libft.h"

int ft_memmove(void *dst, const void *src, size_t n) {
    /* definimos un contador y lo inicializamos a su valor predeterminado */
    /* definimos como variable auxiliar, un puntero para trabajar con `dst`, puesto que al ser void no tiene tipaje. Inicializamos el valor de nuestra variable auxiliar a `(unsigned char *)`.
     * definimos como variable auxiliar un puntero para trabajar con `src`. Inicializamos el valor de nuestra variable auxiliar a `(unsigned const char *) */
    size_t i;
    unsigned char *dst_ptr;
    unsigned const char *src_ptr;
    
    i = 0;
    dst_ptr = (unsigned char *) dst;
    src_ptr = (unsigned const char *) src;
    /* en caso de que `destino` sea mayor que `origen`, por tanto, SI que haya ´overlap` */
    if (dst > src){
        /* siempre que nos queden +0 bytes por copiar */
        while(n >= 0) {
            /* establecemos el valor de la posición (n - 1) de `dst` al carácter (n - 1) de `src` es decir, copiaremos de derecha a izquierda */
            dst_ptr[n - 1] = src_ptr[n - 1];
            /* preparamos la siguiente iteración - (descendiente) */
            n--;
        }
    }
    /* en caso contrario, es decir, si NO hay `overlap` */
    else {
        /* copiamos en el sentido habitual */
        ft_memcpy(dst, src, n);
    }
    /* bajo cualquier caso, devolveremos `dst` */
    return (dst);
}