C String strcpy() Function

What You’ll Learn

The strcpy() function copies a C-string from src into a writable buffer dest, including the terminating '\0'. It is the classic way to duplicate string content into your own memory so you can modify it independently.

Definition and Usage

strcpy stands for string copy. It reads bytes from src one at a time and writes them to dest until it copies the null terminator. After the call, dest holds a complete C-string equal to src.

The destination must be modifiable memory—a char array or malloc buffer—not a string literal. You must allocate at least strlen(src) + 1 bytes because strcpy performs no bounds checking.

📝 Syntax

Standard C declaration:

char *strcpy(char *dest, const char *src);

Parameters

• dest — writable buffer that will receive the copy.
• src — null-terminated source string (not modified).

Return Value

• Returns dest (pointer to the destination buffer).
• The copied string lives in dest; no new string object is created.

Header

• #include <string.h>

Examples Gallery

Compile with gcc strcpy.c -std=c11 -o strcpy. Every example uses a destination buffer large enough for the source string.

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

int main(void) {
    char source[] = "Hello, World!";
    char destination[20];

    strcpy(destination, source);

    printf("Source:      %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}

Source:      Hello, World!
Destination: Hello, World!

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

int main(void) {
    const char *original = "CodeToFun";
    char working[32];

    strcpy(working, original);
    working[4] = '-';

    printf("Original: %s\n", original);
    printf("Working:  %s\n", working);

    return 0;
}

Original: CodeToFun
Working:  Code-ToFun

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

int main(void) {
    const char *src = "Learning C strings";
    char dest[32];
    size_t need = strlen(src) + 1;
    size_t cap = sizeof dest;

    if (need > cap) {
        printf("Buffer too small: need %zu, have %zu\n", need, cap);
        return 1;
    }

    strcpy(dest, src);
    printf("Copied: %s\n", dest);

    return 0;
}

Copied: Learning C strings

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

int main(void) {
    char buf[24];

    printf("Copied: %s\n", strcpy(buf, "strcpy returns dest"));

    return 0;
}

Copied: strcpy returns dest

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

int main(void) {
    const char *src = "A long message that must fit safely";
    char dest[20];

    if (snprintf(dest, sizeof dest, "%s", src) >= (int)sizeof dest) {
        printf("Warning: string truncated to fit buffer.\n");
    }

    printf("Result: %s\n", dest);

    return 0;
}

Warning: string truncated to fit buffer.
Result: A long message th

🚀 Common Use Cases

• Duplicate input — copy user text into a local buffer for editing.
• Default values — initialize a char array from a string literal template.
• Parse pipelines — copy a token before passing it to functions that modify strings.
• Struct fields — fill fixed-size char name[N] members from constants.
• Learning foundation — understand before moving to strncpy and dynamic allocation.

📝 Notes

• Destination must be writable—never strcpy into a string literal.
• Allocate at least strlen(src) + 1 bytes in dest.
• dest and src must not overlap—use memmove instead.
• No length check—overflow is a common security bug.
• Modern code often prefers snprintf, strncpy (with care), or strdup.

⚡ Optimization

Library strcpy implementations are tuned for speed on typical strings. Avoid calling strlen before every strcpy unless you need the length for a bounds check—one pass for copy alone is enough when the buffer is known to fit.

💡 Best Practices