C++ String strcpy() Function

What You’ll Learn

The strcpy() function copies a null-terminated C-string from a source pointer into a writable destination buffer. It is one of the oldest string utilities in C and C++—essential for understanding how character arrays work before you move to safer std::string in modern code.

Definition and Usage

In C++, strcpy() is declared in <cstring>. It walks the source string character by character, writing each byte into destination until it reaches and copies the terminating null character ('\0').

Unlike C++ assignment with std::string, you cannot copy into a char[] array with =. Arrays decay to pointers and would only copy addresses, not text. strcpy() performs the actual byte-by-byte copy that beginners often expect from the assignment operator.

📝 Syntax

Function signature and a typical call:

#include <cstring>

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

// Example:
char buffer[20];
strcpy(buffer, "Hello, C++!");

Parameters

• destination — writable char array or allocated memory that will receive the copy.
• source — null-terminated C-string to copy from (not modified).

Return Value

Returns destination (the same pointer passed as the first argument). The destination buffer now holds a duplicate of the source string.

Examples Gallery

Compile with g++ strcpy.cpp -std=c++17 -o strcpy. Every example uses a destination buffer large enough for the source string plus the null terminator.

#include <iostream>
#include <cstring>

int main() {
    const char* source = "Hello, C++!";
    char destination[20]; // Room for 12 chars + '\0' and extra space

    std::strcpy(destination, source);

    std::cout << "Source:      " << source << "\n";
    std::cout << "Destination: " << destination << "\n";

    return 0;
}

Source:      Hello, C++!
Destination: Hello, C++!

#include <iostream>
#include <cstring>

int main() {
    char label[32];
    const char* title = "CodeToFun";

    std::cout << "Copied: " << std::strcpy(label, title) << "\n";
    std::cout << "Same buffer: " << label << "\n";

    return 0;
}

Copied: CodeToFun
Same buffer: CodeToFun

#include <iostream>
#include <cstring>

int main() {
    char greeting[64];
    const char* defaultMsg = "Welcome to C++ strings!";

    std::strcpy(greeting, defaultMsg);

    // Later, replace the whole message:
    std::strcpy(greeting, "Ready to learn strcpy()?");

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

Ready to learn strcpy()?

#include <iostream>
#include <cstring>
#include <string>

int main() {
    const char* source = "Tutorial";
    char destA[20];
    std::string destB;

    // Correct for char arrays:
    std::strcpy(destA, source);

    // Correct for std::string:
    destB = source;

    std::cout << "char[] copy: " << destA << "\n";
    std::cout << "std::string: " << destB << "\n";

    return 0;
}

char[] copy: Tutorial
std::string: Tutorial

#include <iostream>
#include <cstring>

bool safeCopy(char* dest, std::size_t destSize, const char* src) {
    std::size_t needed = std::strlen(src) + 1;
    if (needed > destSize) {
        return false;
    }
    std::strcpy(dest, src);
    return true;
}

int main() {
    char buffer[16];
    const char* shortName = "Ada";
    const char* longName  = "Christopher";

    if (safeCopy(buffer, sizeof buffer, shortName)) {
        std::cout << "Copied: " << buffer << "\n";
    }

    if (!safeCopy(buffer, sizeof buffer, longName)) {
        std::cout << "Skipped copy — buffer too small for \"" << longName << "\"\n";
    }

    return 0;
}

Copied: Ada
Skipped copy — buffer too small for "Christopher"

🚀 Common Use Cases

• Duplicating a C-string — store a copy in your own buffer when the original pointer may change or go out of scope.
• Initializing char arrays — fill a fixed buffer after declaration when = is not available.
• Legacy C APIs — many libraries expect null-terminated char* buffers you prepare with strcpy.
• Embedded / constrained systems — fixed-size buffers without dynamic allocation.
• Learning pointer semantics — understand why C++ strings and C arrays behave differently.

📝 Notes

• The destination buffer must have room for all characters plus '\0'.
• strcpy does not allocate memory—you provide the buffer.
• Source and destination must not overlap; use memmove for overlapping regions.
• Passing nullptr to either argument causes undefined behavior.
• For new C++ projects, std::string assignment avoids manual buffer sizing entirely.

⚡ Optimization

strcpy() is highly optimized in standard libraries and is fine for small, fixed buffers when sizes are known at compile time. If you copy large strings often, consider storing data in std::string to avoid repeated manual length checks and to get move semantics. Avoid calling strlen before every strcpy when the source length is already known (e.g., string literals).

💡 Best Practices