Perché copiare gli argomenti delle funzioni in variabili locali?

Question

Qual è la ragione di strlcpy.c per copiare gli argomenti in variabili locali:

size_t 
strlcpy(char *dst, const char *src, size_t siz) 
{ 
    char *d = dst; 
    const char *s = src; 
    size_t n = siz; 

    /* Copy as many bytes as will fit */ 
    if (n != 0) { 
     while (--n != 0) { 
      if ((*d++ = *s++) == '\0') 
       break; 
     } 
    } 

    /* Not enough room in dst, add NUL and traverse rest of src */ 
    if (n == 0) { 
     if (siz != 0) 
      *d = '\0';  /* NUL-terminate dst */ 
     while (*s++) 
      ; 
    } 

    return(s - src - 1); /* count does not include NUL */ 
} 

Aggiornamento

ho aggiunto il corpo.

Answer 1

Una ragione molto comune è che le variabili vengono modificate nella funzione e quindi utilizzate in un'espressione insieme agli argomenti.

Ad esempio, la funzione potrebbe modificare la variabile n e successivamente ad es. return siz - n;.

Answer 2

In realtà nel resto del codice siz e SRC sono necessari per calcolare alcune cose:

/* Not enough room in dst, add NUL and traverse rest of src */ 
if (n == 0) { 
    if (siz != 0) 
     *d = '\0';  /* NUL-terminate dst */ 
    while (*s++) 
     ; 
} 

return(s - src - 1); /* count does not include NUL */ 

ma non riesco a capire perché l'ora legale viene copiato localmente. Forse solo per simmetria.

Answer 3

Almeno per l'argomento src, viene utilizzato per calcolare la lunghezza da restituire. La linea finale di tale funzione mostra che:

return(s - src - 1); 

In termini di argomentazione dst, non è effettivamente necessaria ma può essere stato fatto per coerenza. Probabilmente non ha importanza perché probabilmente un compilatore decente non sarà influenzato da questa variabile apparentemente extra.

Answer 4

Per dst e d, penso, solo per simmetria. Per le altre variabili sono utilizzati in "codice" sia con i loro valori iniziali che aggiornati.

Answer 5

size_t 
strlcpy(char *dst, const char *src, size_t siz) 
{      ^-------------------------->constant so must not be modified. that's why a temp variable is needed for modification.  
    char *d = dst;  <-- useless may be. 
    const char *s = src; 
    size_t n = siz;  

    /* Copy as many bytes as will fit */ 
    if (n != 0) {   
     while (--n != 0) { 
      if ((*d++ = *s++) == '\0') 
       break; 
     } 
    } 

    /* Not enough room in dst, add NUL and traverse rest of src */ 
    if (n == 0) {     <-- new n arg. 
     if (siz != 0)    <--- original siz arg 
      *d = '\0';  /* NUL-terminate dst */ 
     while (*s++) 
      ; 
    } 

    return(s - src - 1); /* count does not include NUL */ <-- using the original and modified values of s and src together. 
}