C String strncpy() Function

What You’ll Learn

The strncpy() function copies at most n bytes from a source string into a destination buffer. It is the bounded cousin of strcpy(), but its null-termination rules trip up many beginners—this tutorial shows how to use it safely.

Definition and Usage

strncpy stands for string n copy. It writes up to n bytes from src into dest. If strlen(src) < n, it copies the source (including its '\0') and fills any remaining space up to n bytes with extra null characters.

If strlen(src) ≥ n, it copies exactly n bytes and does not add a terminating null unless one appeared within those n bytes. That is why you often see dest[sizeof(dest) - 1] = '\0'; immediately after strncpy.

📝 Syntax

Standard C declaration:

char *strncpy(char *dest, const char *src, size_t n);

Safe pattern for C-strings

strncpy(dest, src, sizeof(dest) - 1);
dest[sizeof(dest) - 1] = '\0';

Parameters

• dest — destination buffer (must have room for at least the bytes written).
• src — source null-terminated string.
• n — maximum number of bytes to copy from src (including padding behavior).

Return Value

• Returns dest (pointer to the destination buffer).

Header

• #include <string.h>

Examples Gallery

Compile with gcc strncpy.c -std=c11 -o strncpy. Every example that prints a string shows explicit null-termination when needed.

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

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

    strncpy(destination, source, 10);
    destination[10] = '\0';

    printf("Copied String: %s\n", destination);

    return 0;
}

Copied String: Hello, Wor

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

int main(void) {
    char dest[16];
    const char *src = "This string is too long for the buffer";

    strncpy(dest, src, sizeof(dest) - 1);
    dest[sizeof(dest) - 1] = '\0';

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

    return 0;
}

This string is t

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

int main(void) {
    char dest[8];
    const char *src = "Hi";

    strncpy(dest, src, sizeof(dest));

    printf("Text: [%s]\n", dest);
    printf("Length after strncpy: %zu\n", strlen(dest));

    return 0;
}

Text: [Hi]
Length after strncpy: 2

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

int main(void) {
    char dest[5];
    const char *src = "ABCDEFGH";

    /* BAD for printing: n equals buffer size, no room for '\0' */
    strncpy(dest, src, sizeof(dest));

    /* Fix before use: */
    dest[sizeof(dest) - 1] = '\0';

    printf("Safe after fix: %s\n", dest);

    return 0;
}

Safe after fix: ABCD

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

int main(void) {
    char full[32];
    char partial[32];
    const char *src = "CodeToFun";

    strcpy(full, src);

    strncpy(partial, src, 4);
    partial[4] = '\0';

    printf("strcpy:   [%s]\n", full);
    printf("strncpy:  [%s]\n", partial);

    return 0;
}

strcpy:   [CodeToFun]
strncpy:  [Code]

🚀 Common Use Cases

• Fixed-width fields — legacy record layouts that pad short values with nulls.
• Truncated labels — store only the first n characters of a long name.
• Bounded copies — when you know dest size and src may be longer.
• Reading interview code — recognize the post-copy null assignment pattern.
• Kernel / POSIX code — appears in older APIs before snprintf was common.

📝 Notes

• Does not guarantee a null-terminated C-string when strlen(src) ≥ n.
• Padding with zeros can be slower than necessary for plain text buffers.
• Behavior if dest and src overlap is undefined.
• Unlike strncat, strncpy does not append—it writes from the start of dest.
• snprintf(dest, size, "%s", src) is often clearer for new code.

⚡ Optimization

Zero-padding up to n bytes can waste cycles when you only need a truncated C-string. Copying with memcpy plus an explicit '\0', or using snprintf, avoids writing hundreds of padding nulls into large fixed fields.

💡 Best Practices