C++ String strcat() Function

What You’ll Learn

The strcat() function from <cstring> appends one C-style string to another. It is a classic C library tool still used in C++ when working with char arrays and legacy APIs. This guide covers syntax, buffer safety, return values, and when to prefer std::string instead.

Definition and Usage

In C++, strcat() is declared in <cstring> (the C++ header for C string functions). It copies characters from source onto the end of destination, overwriting the null terminator of the destination and adding a new null terminator after the appended text.

Unlike std::string, which grows automatically, strcat() assumes you have already allocated a char array large enough to hold the combined result. The destination must contain a valid C-string before the call.

📝 Syntax

The function signature from the C standard library:

char* strcat(char* destination, const char* source);

Parameters

• destination — pointer to a modifiable char array that already holds a null-terminated string. Must have enough remaining space for source and the final '\0'.
• source — pointer to the C-string to append (read-only). Cannot overlap with destination in a way that violates the standard; do not append a string to itself.

Return Value

Returns destination (the same pointer passed in). The concatenated text is stored in the destination array.

Header

#include <cstring>   // C++ style
// or
#include <string.h>  // C style (also works in C++)

Examples Gallery

Compile with g++ strcat.cpp -std=c++17 -o strcat. Every example uses a buffer large enough for the result—always plan capacity before calling strcat().

#include <iostream>
#include <cstring>

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

    strcat(destination, source);

    std::cout << "Concatenated: " << destination << std::endl;
    return 0;
}

Concatenated: Hello, World!

#include <iostream>
#include <cstring>

int main() {
    char message[48] = "C++";
    strcat(message, " strings");
    strcat(message, " are");
    strcat(message, " powerful!");

    std::cout << message << std::endl;
    return 0;
}

C++ strings are powerful!

#include <iostream>
#include <cstring>

int main() {
    char path[32] = "/cpp/string/function/";
    const char* page = "strcat";

    std::cout << "Full path: "
              << strcat(path, page) << std::endl;

    return 0;
}

Full path: /cpp/string/function/strcat

#include <iostream>
#include <cstring>

int main() {
    const char* first = "Code";
    const char* second = "ToFun";
    char buffer[16];

    strcpy(buffer, first);
    strcat(buffer, second);

    std::size_t needed = std::strlen(first) + std::strlen(second) + 1;
    std::cout << "Result: " << buffer << std::endl;
    std::cout << "Bytes needed: " << needed << std::endl;

    return 0;
}

Result: CodeToFun
Bytes needed: 9

#include <iostream>
#include <string>

int main() {
    std::string greeting = "Hello, ";
    greeting += "World!";

    std::string path = "/cpp/string/function/";
    path.append("strcat");

    std::cout << greeting << std::endl;
    std::cout << path << std::endl;

    return 0;
}

Hello, World!
/cpp/string/function/strcat

🚀 Common Use Cases

• Legacy C APIs — build paths or messages in char buffers required by older libraries.
• Embedded systems — fixed-size buffers where dynamic allocation is avoided.
• File path assembly — join directory and file name segments (when size is known).
• Learning C foundations — understand how C-strings work before using std::string.
• Interview basics — explain concatenation, null terminators, and buffer overflow risks.

📝 Notes

• Buffer overflow is the main danger—the function never checks array bounds.
• Destination must be mutable and already null-terminated before the call.
• Do not use strcat(dest, dest) or overlapping buffers unless using the safe variant from your platform docs.
• Include <cstring> for strcat, strlen, and strcpy.
• In C++, std::string plus += or append() is usually safer for application code.

⚡ Optimization

strcat() is efficient for small, fixed buffers because it avoids heap allocation. Repeated concatenation into the same small buffer in a loop can become slow (each call rescans from the start of the destination). For many append operations, std::string with reserved capacity (reserve()) or a single pre-sized buffer often performs better and is easier to reason about.

💡 Best Practices