Esempio di memcpy_s

void*memcpy(void*dest,constvoid*src,size_t count );

void*memcpy(void*restrict dest,constvoid*restrict src,size_t count );

errno_tmemcpy_s(void*restrict dest,rsize_t destsz,constvoid*restrict src,rsize_t count );

1) Copie count dall'oggetto puntato da src all'oggetto puntato da dest. Entrambi gli oggetti sono interpretati come array di unsigned char.
Il comportamento è indefinito se l'accesso avviene oltre la fine dell'array dest. Se gli oggetti si sovrappongono (il che rappresenta una violazione del parametro restrict contratto)(dal C99) il comportamento è indefinito. Il comportamento è indefinito se dest o src è un puntatore nullo.2) Come (1) tranne che per il fatto che i seguenti errori vengono rilevati in fase di esecuzione e causano l'intero intervallo di destinazioni [dest, dest+destsz) viene azzerato (se entrambi i campi dest e destsz sono validi), oltre a richiamare la funzione di gestione dei vincoli attualmente installata:

• dest o src è un puntatore nullo
• destsz o count è maggiore di RSIZE_MAX
• count è maggiore di destsz (si verificherebbe un overflow del buffer)
• gli oggetti di origine e di destinazione si sovrappongono

Il comportamento è indefinito se la dimensione dell'array di caratteri puntato da dest count <= destszin altre parole, un valore errato di destsz non rivela l'imminente overflow del buffer. Come per tutte le funzioni con controllo dei limiti, memcpy_s è garantita solo se __STDC_LIB_EXT1__ è definito dall'implementazione e se l'utente definisce __STDC_WANT_LIB_EXT1__ alla costante intera 1 prima di includere string.h.

Parametri

Valore di ritorno

1) Restituisce una copia di dest2) Restituisce zero in caso di successo e un valore non nullo in caso di errore. Anche in caso di errore, se dest non è un puntatore nullo e destsz è valido, scrive destsz zero byte nell'array di destinazione.

Note

memcpy può essere utilizzato per impostare il tipo effettivo di un oggetto ottenuto da una funzione di allocazione.

memcpy è la routine di libreria più veloce per la copia da memoria a memoria. Di solito è più efficiente di strcpyche deve scansionare i dati che copia o memmove, che deve prendere precauzioni per gestire la sovrapposizione degli input.

Diversi compilatori C trasformano i loop che copiano la memoria in cicli memcpy chiamate.

Dove l'aliasing rigoroso proibisce di esaminare la stessa memoria come valori di due tipi diversi, memcpy può essere utilizzato per convertire i valori.

Esempio

#define__STDC_WANT_LIB_EXT1__1#include#include#include#include#includeintmain(void){// simple usagechar source[]="once upon a midnight dreary...", dest[4];memcpy(dest, source,sizeof dest);for(size_t n =0; n <sizeof dest;++n)putchar(dest[n]);// setting effective type of allocated memory to be intint*p =malloc(3*sizeof(int));// allocated memory has no effective typeint arr[3]={1,2,3};memcpy(p,arr,3*sizeof(int));// allocated memory now has an effective type// reinterpreting datadouble d =0.1;//    int64_t n = *(int64_t*)(&d); // strict aliasing violationint64_t n;memcpy(&n,&d,sizeof d);// OKprintf("n%a is %" PRIx64 " as an int64_tn", d, n);#ifdef__STDC_LIB_EXT1__set_constraint_handler_s(ignore_handler_s);char src[]="aaaaaaaaaa";char dst[]="xyxyxyxyxy";int r =memcpy_s(dst,sizeof dst,src,5);printf("dst = "%s", r = %dn", dst,r);
    r =memcpy_s(dst,5,src,10);//  count is greater than destsz  printf("dst = "");for(size_t ndx=0; ndx<sizeof dst;++ndx){char c = dst[ndx];
        c ?printf("%c", c):printf("\0");}printf("", r = %dn", r);#endif}

Possibile uscita:

once
0x1.999999999999ap-4 is 3fb999999999999a as an int64_t
dst ="aaaaayxyxy", r =0
dst ="yxyxy", r =22

Riferimenti

• Norma C11 (ISO/IEC 9899:2011):
• 7.24.2.1 La funzione memcpy (p: 362)
• K.3.7.1.1 La funzione memcpy_s (p: 614)
• Standard C99 (ISO/IEC 9899:1999):
• 7.21.2.1 La funzione memcpy (p: 325)
• Standard C89/C90 (ISO/IEC 9899:1990):
• 4.11.2.1 La funzione memcpy

Vedi anche