C++ String strerror() Function

What You’ll Learn

When a C or C++ library call fails, it often sets the global variable errno to a numeric error code. The strerror() function turns that number into a plain-English message like No such file or directory—so users and developers understand what went wrong without memorizing error constants.

Definition and Usage

In C++, strerror() is declared in <cstring>. You pass an integer error code—usually the value of errno immediately after a failed system call—and receive a pointer to a short descriptive C-string managed by the C library.

This function does not clear or modify errno. It only translates a number you supply. Messages are defined by the operating system and may vary slightly between platforms, but common codes like ENOENT and EACCES produce familiar text on most systems.

📝 Syntax

Function signature and required headers:

#include <cstring>
#include <cerrno>

char* strerror(int errnum);

// Typical usage after a failed call:
// int err = errno;
// const char* msg = strerror(err);

Parameters

• errnum — an error number, commonly errno or a constant like ENOENT.

Return Value

Returns a pointer to a null-terminated message string. The storage is owned by the library—copy it if you need to keep the text beyond the next call to strerror().

Examples Gallery

Compile with g++ strerror.cpp -std=c++17 -o strerror. These examples show how to turn numeric error codes into messages beginners can read and log.

#include <iostream>
#include <cstring>
#include <cerrno>

int main() {
    errno = ENOENT; // No such file or directory

    const char* errorMessage = std::strerror(errno);

    std::cout << "Error code: " << errno << "\n";
    std::cout << "Message:    " << errorMessage << "\n";

    return 0;
}

Error code: 2
Message:    No such file or directory

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cerrno>

int main() {
    std::FILE* file = std::fopen("missing_config.txt", "r");

    if (file == nullptr) {
        int err = errno;
        std::cout << "Could not open file: "
                  << std::strerror(err) << "\n";
        return 1;
    }

    std::fclose(file);
    return 0;
}

Could not open file: No such file or directory

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cerrno>

int main() {
    std::FILE* f = std::fopen("/no/access/here.txt", "r");
    if (f == nullptr) {
        int saved = errno;

        // Another call might change errno:
        std::strerror(saved);

        std::cout << "Saved errno: " << saved << "\n";
        std::cout << "Message:     " << std::strerror(saved) << "\n";
    }
    return 0;
}

Saved errno: 2
Message:     No such file or directory

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cerrno>

int main() {
    errno = EACCES; // Permission denied

    std::cout << "Using strerror:\n";
    std::cout << "  Access failed: " << std::strerror(errno) << "\n\n";

    std::cout << "Using perror (also writes to stderr):\n  ";
    std::perror("Access failed");

    return 0;
}

Using strerror:
  Access failed: Permission denied

Using perror (also writes to stderr):
  Access failed: Permission denied

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

std::string describeError(int code) {
    return std::string(std::strerror(code));
}

int main() {
    errno = EINVAL;

    std::string msg = describeError(errno);
    std::cout << "Invalid operation: " << msg << "\n";

    return 0;
}

Invalid operation: Invalid argument

🚀 Common Use Cases

• File and I/O errors — explain why fopen, read, or write failed.
• User-facing error dialogs — show a readable reason instead of a raw number.
• Logging and diagnostics — include system messages in log files.
• Teaching and debugging — learn what constants like ENOENT mean in practice.
• Wrapper functions — convert low-level failures into std::string exceptions or error types.

📝 Notes

• Include <cerrno> for errno and symbolic constants; include <cstring> for strerror.
• The returned pointer must not be freed with delete or free.
• Read errno immediately after failure—successful calls may leave it unchanged from an older error.
• C++ exceptions (std::system_error) are the modern alternative for new code, but errno + strerror remains common in C APIs.
• Error text may be translated according to system locale settings.

⚡ Optimization

strerror() is fast enough for error paths that run rarely. Avoid calling it inside tight loops on success paths. Cache the copied message once per failure instead of translating the same code repeatedly. For hot paths, log the numeric errno and translate offline if needed.

💡 Best Practices