Perché Linux memmove() è implementato così com'è?

Question

Dalla pagina di manuale Linux per memmove(3)

I memmove) copie (funzione n byte da un'area di memoria src per area di memoria dest. Le aree di memoria possono sovrapporsi: la copiatura avviene come se i byte in src fossero prima copiati in una matrice temporanea che non si sovrappone a src o dest, e quindi i byte vengano copiati dall'array temporaneo a dest.

Invece di allocare una matrice temporanea e copiare i valori due volte potremmo effettuare le seguenti operazioni:

void *my_memmove(void *dest, const void *src, size_t n) { 
    signed char operation; 
    size_t end; 
    size_t current; 

    if(dest != src) { 
    if(dest < src) { 
     operation = 1; 
     current = 0; 
     end = n; 
    } else { 
     operation = -1; 
     current = n - 1; 
     end = -1; 
    } 

    for(; current != end; current += operation) { 
     *(((unsigned char*)dest) + current) = *(((unsigned char*)src) + current); 
    } 
    } 
    return dest; 
} 

In questa implementazione semplicemente occupiamo della posizione in cui si comincia a copiare.

C'è un inconveniente nella mia implementazione?

Nota: in realtà non userò la mia implementazione. Sono solo curioso.

Answer 1

Potete guardare qualche codice sorgente per memmove here, here, here e here.

Quello che noterete è che non lo fanno in realtà fare un array temporaneo. Le pagine man sono scritte per aiutarti a capire cosa sta facendo logicamente, non in realtà. Quindi, dicono "come se".

Che memmove() in realtà non fa altro che copiare il byte da src a dest, e le copie avanti se dest < src (che è essenzialmente la stessa cosa di memcpy), e indietro altrimenti.

La differenza tra memcpy e memmove è che memcpy ciecamente copie avanti - che è il motivo per cui dest e src non deve sovrapporsi. Ma memmove prende la precauzione di assicurare che la sovrapposizione non rovini il risultato finale.