C++ String strncpy() Function

What You’ll Learn

The strncpy() function copies at most num characters from a source C-string into a destination buffer. It is often taught as a “safer” alternative to strcpy(), but beginners must learn its quirks: it may not add a null terminator, and it may zero-pad when the source is short.

Definition and Usage

In C++, strncpy() is declared in <cstring>. It writes up to num characters from source into destination. If the source string ends before num characters are copied, the remaining bytes up to num are filled with '\0' padding.

If the source is longer than or equal to num characters before its own terminator, strncpy copies exactly num bytes and may leave destination without a trailing '\0'. That is why printing or passing the result to functions expecting C-strings can misbehave unless you terminate manually.

📝 Syntax

Function signature and a typical call:

#include <cstring>

char* strncpy(char* destination, const char* source, size_t num);

// Example (buffer must hold num+1 if you null-terminate at [num]):
char dest[20];
strncpy(dest, "Hello, World!", 10);
dest[10] = '\0';  // manual terminator

Parameters

• destination — writable buffer receiving the copy.
• source — null-terminated C-string to copy from.
• num — maximum number of characters to copy from source (may include padding behavior).

Return Value

Returns destination. The buffer content may or may not be a valid C-string until you terminate it yourself.

Examples Gallery

Compile with g++ strncpy.cpp -std=c++17 -o strncpy. Every example shows explicit null termination when strncpy alone would not guarantee a printable C-string.

#include <iostream>
#include <cstring>

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

    std::strncpy(destination, source, 10);
    destination[10] = '\0'; // required for safe printing

    std::cout << "Copied: " << destination << "\n";
    std::cout << "Length: " << std::strlen(destination) << "\n";

    return 0;
}

Copied: Hello, Wor
Length: 10

#include <iostream>
#include <cstring>

int main() {
    char dest[12];
    const char* source = "Hi";

    std::strncpy(dest, source, 8);
    dest[8] = '\0'; // good practice even after padding

    std::cout << "Text: \"" << dest << "\"\n";
    std::cout << "strlen: " << std::strlen(dest) << "\n";

    return 0;
}

Text: "Hi"
strlen: 2

#include <iostream>
#include <cstring>

int main() {
    const char* source = "CodeToFun";
    char limited[20];
    char full[20];

    std::strncpy(limited, source, 4);
    limited[4] = '\0';

    std::strcpy(full, source);

    std::cout << "strncpy(4): " << limited << "\n";
    std::cout << "strcpy():   " << full << "\n";

    return 0;
}

strncpy(4): Code
strcpy():   CodeToFun

#include <iostream>
#include <cstring>

void copySafe(char* dest, std::size_t destSize, const char* src) {
    if (destSize == 0) {
        return;
    }
    std::strncpy(dest, src, destSize - 1);
    dest[destSize - 1] = '\0';
}

int main() {
    char buffer[8];
    copySafe(buffer, sizeof buffer, "LongUserName");

    std::cout << "Stored: " << buffer << "\n";
    std::cout << "Length: " << std::strlen(buffer) << "\n";

    return 0;
}

Stored: LongUse
Length: 7

#include <iostream>
#include <cstring>

struct Player {
    char name[12];
    int score;
};

int main() {
    Player p{};
    p.score = 980;

    const char* input = "SuperStarGamer2026";
    std::strncpy(p.name, input, sizeof p.name - 1);
    p.name[sizeof p.name - 1] = '\0';

    std::cout << "Name:  " << p.name << "\n";
    std::cout << "Score: " << p.score << "\n";

    return 0;
}

Name:  SuperStarGa
Score: 980

🚀 Common Use Cases

• Fixed-size struct fields — store names, codes, or titles with a max length.
• Truncating external input — cap data from files, networks, or users.
• Legacy C APIs — fill buffers expected by older libraries.
• Teaching bounded I/O — step between unrestricted strcpy and std::string.
• Partial copies — move exactly n characters without allocating new memory.

📝 Notes

• If source length is ≥ num, destination may be not null-terminated.
• If source length is < num, remaining bytes up to num are zero-filled.
• num is a maximum from source, not the total destination buffer size.
• Do not use on overlapping memory regions; use memmove instead.
• Modern C++ favors std::string, std::string_view, or snprintf for clearer semantics.

⚡ Optimization

Zero-padding when source is short can write many unnecessary bytes if num is large. Prefer copying min(strlen(src), n-1) with an explicit terminator, or use higher-level string types. Avoid repeated strncpy on huge fixed fields when only a short prefix changes.

💡 Best Practices