C++ String strncat() Function

What You’ll Learn

The strncat() function appends up to num characters from a source C-string onto the end of a destination C-string, then adds a null terminator. It is the bounded version of strcat()—you choose how much of the source to copy when you do not want the entire string appended.

Definition and Usage

In C++, strncat() is declared in <cstring>. It finds the existing null terminator of destination, then copies characters from source starting there—at most num characters, or until source ends if it is shorter than num.

After copying, strncat always writes a final '\0'. The destination must already contain a valid C-string (often initialized with text or "") and must have enough unused bytes for the append plus terminator.

📝 Syntax

Function signature and a typical call:

#include <cstring>

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

// Example:
char dest[20] = "Hello, ";
strncat(dest, "World!", 6);
// dest == "Hello, World!"

Parameters

• destination — writable char array already holding a null-terminated string.
• source — C-string to append from (not modified).
• num — maximum number of characters to copy from source.

Return Value

Returns destination. The combined string is stored in the destination buffer.

Examples Gallery

Compile with g++ strncat.cpp -std=c++17 -o strncat. Every example uses a destination buffer large enough for the final string plus '\0'.

#include <iostream>
#include <cstring>

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

    std::strncat(destination, source, 6);

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

    return 0;
}

Result: Hello, World!
Length: 13

#include <iostream>
#include <cstring>

int main() {
    char label[32] = "File: ";
    const char* filename = "report_final.pdf";

    std::strncat(label, filename, 3); // only "rep"

    std::cout << label << "\n";
    return 0;
}

File: rep

#include <iostream>
#include <cstring>

int main() {
    char bounded[24] = "C++: ";
    char full[24]    = "C++: ";
    const char* topic = "strncat tutorial";

    std::strncat(bounded, topic, 7);  // "strncat"
    std::strcat(full, topic);         // entire source

    std::cout << "strncat(7): " << bounded << "\n";
    std::cout << "strcat():   " << full << "\n";

    return 0;
}

strncat(7): C++: strncat
strcat():   C++: strncat tutorial

#include <iostream>
#include <cstring>

int main() {
    char dest[16] = "Score: ";
    const char* points = "42";

    std::strncat(dest, points, 10); // source has only 2 chars + '\0'

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

    return 0;
}

Score: 42
Length: 9

#include <iostream>
#include <cstring>

int main() {
    char path[64] = "";
    const char* root = "/home/user";
    const char* folder = "/projects";
    const char* file = "/main.cpp";

    std::strncat(path, root,   std::strlen(root));
    std::strncat(path, folder, std::strlen(folder));
    std::strncat(path, file,    std::strlen(file));

    std::cout << "Path: " << path << "\n";
    return 0;
}

Path: /home/user/projects/main.cpp

🚀 Common Use Cases

• Truncated concatenation — append only a prefix of untrusted or long input.
• Fixed-width fields — combine labels with limited suffix text.
• Legacy C APIs — build messages in char buffers passed to older libraries.
• Incremental path assembly — join path segments with explicit limits.
• Teaching bounded I/O — step between unrestricted strcat and safer modern types.

📝 Notes

• destination must already be null-terminated before the call.
• num caps source length only—you must still size the destination buffer correctly.
• strncat always null-terminates (unlike strncpy in edge cases).
• Source and destination must not overlap (same rule as strcat).
• Prefer std::string or std::string::append in new C++ application code.

⚡ Optimization

strncat() scans the destination to find its end on every call, so repeated appends to the same buffer cost O(n) per call. For many concatenations, track the write position or use std::string, which avoids rescanning from the start each time.

💡 Best Practices