Checking If A File Or Directory Exists In C++

The stat() system call is the traditional approach for checking file existence:

#include <sys/stat.h>

int file_exists(const char *path) {
    struct stat buffer;
    return (stat(path, &buffer) == 0);
}

This returns 1 if the file exists, 0 otherwise. The stat() call fills the buffer with file metadata, but when checking existence alone, you’re mainly interested in the return value.

Be aware that stat() follows symlinks by default. If you need to check a symlink itself (not its target), use lstat() instead:

int symlink_exists(const char *path) {
    struct stat buffer;
    return (lstat(path, &buffer) == 0);
}

Using access() in C

The access() function checks both existence and permissions:

#include <unistd.h>

if (access("/path/to/file", F_OK) != -1) {
    /* file exists */
}

You can also check specific permissions:

if (access("/path/to/file", R_OK) == 0) {
    /* readable */
}
if (access("/path/to/file", W_OK) == 0) {
    /* writable */
}
if (access("/path/to/file", X_OK) == 0) {
    /* executable */
}

Note: access() checks real UID/GID, not effective ones. It’s useful when you need to verify actual permissions before attempting operations.

Race Conditions

Both stat() and access() have a TOCTOU (Time-of-Check-Time-of-Use) vulnerability: the file state can change between the check and when you actually use it. If this matters for your application, open or access the file directly and handle the error instead of pre-checking existence.

C++ with std::filesystem

If you’re writing C++17 or later, use std::filesystem::exists():

#include <filesystem>

if (std::filesystem::exists("/path/to/file")) {
    // file or directory exists
}

This is cleaner, handles UTF-8 paths correctly, and works across platforms. Check specific types when needed:

#include <filesystem>
namespace fs = std::filesystem;

if (fs::is_regular_file("/path/to/file")) {
    // it's a regular file
}
if (fs::is_directory("/path/to/dir")) {
    // it's a directory
}
if (fs::is_symlink("/path/to/link")) {
    // it's a symlink
}

You can also check if a symlink’s target exists:

// exists() follows symlinks by default
if (fs::exists("/path/to/symlink")) {
    // target exists
}

// Check the symlink itself
if (fs::exists(fs::symlink_status("/path/to/symlink"))) {
    // symlink entry exists (even if target doesn't)
}

For error handling without exceptions:

std::error_code ec;
bool exists = fs::exists("/path/to/file", ec);
if (ec) {
    // handle error
}

Summary

C: Use stat() for existence checks or access() when you need permission verification
C++17+: Use std::filesystem::exists() — it’s safer, more readable, and handles edge cases better
Always consider TOCTOU: Pre-checking existence introduces race conditions; prefer opening files and handling errors instead

Practical Tips and Common Gotchas

When working with programming languages on Linux, environment management is crucial. Use version managers like asdf, pyenv, or sdkman to handle multiple language versions without system-wide conflicts. Always pin dependency versions in production to prevent unexpected breakage from upstream changes.

For build automation, modern alternatives often outperform traditional tools. Consider using just or task instead of Make for simpler task definitions. Use containerized build environments to ensure reproducibility across different development machines.

Debugging Strategies

Start with the simplest debugging approach and escalate as needed. Print statements and logging often reveal the issue faster than attaching a debugger. For complex issues, use language-specific debuggers like gdb for C and C++, jdb for Java, or dlv for Go. Always check error messages carefully before diving into code.

Quick Verification

After applying the changes described above, verify that everything works as expected. Run the relevant commands to confirm the new configuration is active. Check system logs for any errors or warnings that might indicate problems. If something does not work as expected, review the steps carefully and consult the official documentation for your specific version.

Checking if a File or Directory Exists in C++