Hand-Rolled mystrcpy

char dest[20]; strcpy(dest, "Hello"); printf("%s\n", dest); // → Hello

strcpy(dst, src) copies every character from src into dst, including the terminating '\0'. It overwrites whatever was in dst before.

Three ways to write it

You like writing things multiple ways (your three mystrlen implementations proved that). Here are three ways to do mystrcpy, each teaching something different.

Version 1 — index form (the one you already know)

void mystrcpy_v1(char *dst, const char *src) {
    int i = 0;
    while (src[i] != '\0') {
        dst[i] = src[i];
        i++;
    }
    dst[i] = '\0';       // copy the terminator
}

Simple, readable. You've written loops exactly like this before. The '\0' is copied after the loop — the loop stops at the terminator, and the explicit line seals the copy.

Version 2 — pointer form (expanded, from lesson 2)

void mystrcpy_v2(char *dst, const char *src) {
    char *p = dst;
    const char *q = src;

    while (*q != '\0') {
        *p = *q;
        p++;
        q++;
    }
    *p = '\0';           // seal
}

Same as mystrcat's Act 2, but starting from position 0 instead of the end. No Act 1 needed — the write pointer starts at the beginning. Same three-line lockstep you've been practicing.

Version 3 — compact form (from lesson 4)

void mystrcpy_v3(char *dst, const char *src) {
    while (*src != '\0') {
        *dst++ = *src++;
    }
    *dst = '\0';
}

The two-pointer lockstep compressed into one line per iteration. This is the form you'll see in real C codebases. After lesson 4, you know exactly what *dst++ = *src++ expands to.

Bonus — version 3b (the clever one-liner)

void mystrcpy_v3b(char *dst, const char *src) {
    while (*dst++ = *src++)
        ;   // empty body — all the work is in the condition
}

This is the classic C trick. The loop condition does everything: copy a character, advance both pointers, test if the copied character was '\0' (i.e. zero). When '\0' is copied, the condition is false and the loop exits — after writing the terminator into dst. No separate seal line needed.

See them side by side

while (src[i] != '\0') {
    dst[i] = src[i];
    i++;
}
dst[i] = '\0';

while (*src != '\0') {
    *dst++ = *src++;
}
*dst = '\0';

Every index i is a pointer offset. src[i] ≡ *(src + i). The pointer form just keeps the pointer moving instead of recalculating src + i each time. Same work, less arithmetic.

The safety checklist (lesson 1, again)

Before any strcpy — hand-rolled or library — the One Principle applies:

1. Does dst have real storage? Must be an array or malloc'd memory.
2. Big enough? strlen(src) + 1 bytes minimum. The +1 is for the '\0'.

char dest[20];
mystrcpy(dest, "Hello");   // strlen("Hello") + 1 = 6 ≤ 20 ✓

char small[4];
mystrcpy(small, "Hello");  // 6 > 4 → UB, buffer overflow

Check yourself