strcpy vs. memcpy

Jaka jest różnica między memcpy()i strcpy()? Próbowałem go znaleźć za pomocą programu, ale oba dają ten sam wynik.

int main()
{
    char s[5]={'s','a','\0','c','h'};
    char p[5];
    char t[5];
    strcpy(p,s);
    memcpy(t,s,5);
    printf("sachin p is [%s], t is [%s]",p,t);
    return 0;
}

Wynik

sachin p is [sa], t is [sa]

co można zrobić, aby zobaczyć ten efekt

Skompiluj i uruchom ten kod:

void dump5(char *str);

int main()
{
    char s[5]={'s','a','\0','c','h'};

    char membuff[5]; 
    char strbuff[5];
    memset(membuff, 0, 5); // init both buffers to nulls
    memset(strbuff, 0, 5);

    strcpy(strbuff,s);
    memcpy(membuff,s,5);

    dump5(membuff); // show what happened
    dump5(strbuff);

    return 0;
}

void dump5(char *str)
{
    char *p = str;
    for (int n = 0; n < 5; ++n)
    {
        printf("%2.2x ", *p);
        ++p;
    }

    printf("\t");

    p = str;
    for (int n = 0; n < 5; ++n)
    {
        printf("%c", *p ? *p : ' ');
        ++p;
    }

    printf("\n", str);
}

Spowoduje to:

73 61 00 63 68  sa ch
73 61 00 00 00  sa

Widać, że „ch” zostało skopiowane przez memcpy(), ale nie strcpy().

strcpyzatrzymuje się, gdy napotka znak NUL ( '\0'), memcpynie. Nie widać tu efektu, ponieważ %sprintf również zatrzymuje się na NUL.

strcpykończy się, gdy zostanie znaleziony zerowy terminator ciągu źródłowego. memcpywymaga przekazania parametru rozmiaru. W przypadku, gdy przedstawiłeś, printfinstrukcja zatrzymuje się po znalezieniu terminatora null dla obu tablic znaków, jednak znajdziesz t[3]i t[4]skopiujesz również dane w nich.

strcpy kopiuje jeden po drugim znak ze źródła do celu, aż znajdzie znak NULL lub „\ 0” w źródle.

while((*dst++) = (*src++));

gdzie jako memcpykopiuje dane (nie znak) ze źródła do miejsca przeznaczenia o danym rozmiarze n, niezależnie od danych w źródle.

memcpypowinno być używane, jeśli dobrze wiesz, że źródła zawierają inne elementy niż znak. w przypadku danych zaszyfrowanych lub danych binarnych memcpy jest idealnym rozwiązaniem.

strcpyjest przestarzały, więc użyj strncpy.

Ze względu na pusty znak w sciągu printfnie pokaże niczego poza tym. Różnica między pi tbędzie w postaci 4 i 5. pnie będzie miała żadnego (będą śmieci) i tbędzie miała 'c'i 'h'.

• Różnica w zachowaniu: strcpyzatrzymuje się, gdy napotka NULLlub'\0'
• Różnica w wydajności: memcpyjest zwykle bardziej wydajna niż ta strcpy, która zawsze skanuje dane, które kopiuje

Główna różnica polega na tym, że memcpy()zawsze kopiuje dokładnie określoną liczbę bajtów; strcpy()z drugiej strony będzie kopiować, dopóki nie odczyta bajtu NUL (znanego również jako 0), a następnie zatrzyma się.

Problem z twoim programem testowym polega na tym, że printf()przestaje wstawiać argument do %s, gdy napotka zakończenie zerowe \0. Więc w swoim wyjściu prawdopodobnie nie zauważyłeś, że memcpy()skopiowałeś znaki ci hrównież.

Widziałem w GNU glibc-2.24, że (dla x86) strcpy()tylko wywołania memcpy(dest, src, strlen(src) + 1).

printf("%s",...) zatrzymuje drukowanie danych po napotkaniu wartości null, więc oba wyjścia są takie same.

Poniższy kod rozróżnia strcpyi memcpy:

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

int main()
{
    char s[5]={'s','a','\0','c','h'};
    char p[5];
    char t[5];
    int i;
    strcpy(p,s);
    memcpy(t,s,5);
    for(i=0;i<5;i++)
        printf("%c",p[i]);
        printf("\n");
    for(i=0;i<5;i++)
        printf("%c",t[i]);

    return 0;
}