How to Check If a File Exists in Standard C++ (C++11, C++14, C++17)

By the end of this page, you will understand the standard ways to check whether a file exists in C++, when to use std::ifstream versus std::filesystem::exists, why “exists” checks can be misleading in some workflows, and how this is typically handled in real codebases.

In C++, checking whether a file exists depends on which standard version you are using.

• C++17 introduced std::filesystem, which provides a clear, standard way to work with paths and file status.
• C++11/C++14 do not have standard filesystem support, so a common standard-only approach is to try opening the file with std::ifstream.
• In C, the usual standard-library approach is trying to open the file with fopen.

A key idea: "checking if a file exists" is often really "checking whether I can access it right now."

That matters because:

• A path may exist but refer to a directory, not a regular file.
• A file may exist but you may not have permission to open it.
• A file may be deleted or changed between the check and the actual use.

This is why many real programs prefer to perform the operation directly and handle failure, instead of doing a separate existence check first.

Still, existence checks are useful when:

• validating input paths,
• scanning a large batch of expected files,
• reporting missing resources before processing starts,
• filtering paths before attempting expensive work.

Standard approaches

C++17

Use std::filesystem::exists(path).

C++11 / C++14

Use std::ifstream and test whether the file stream opened successfully.

Think of a file path like a house address.

• exists(path) asks: “Is there something at this address?”
• Opening the file asks: “Can I actually enter and use this place?”

Those are not always the same.

A house may exist, but:

• it might be locked,
• it might be the wrong building,
• it might disappear before you arrive.

So if your real goal is to read the file, the safest mindset is:

1. Try to open it.
2. If it opens, use it.
3. If it fails, handle the error.

Use existence checks mainly when you truly need a separate validation step.

C++17: std::filesystem::exists

#include <filesystem>
#include <string>

inline bool exist(const std::string& name)
{
    return std::filesystem::exists(name);
}

This is the most direct standard solution in C++17.

If you specifically want to check for a regular file and not just any filesystem entry:

#include <filesystem>
#include <string>

inline bool exist(const std::string& name)
{
    return std::filesystem::is_regular_file(name);
}

This avoids returning true for directories.

C++11 / C++14: std::ifstream

Consider this C++17 example:

#include <iostream>
#include <filesystem>

int main()
{
    std::string path = "report.txt";

    if (std::filesystem::exists(path)) {
        std::cout << "Found\n";
    } else {
        std::cout << "Missing\n";
    }
}

Step by step

1. path is set to "report.txt".
2. std::filesystem::exists(path) asks the operating system about that path.
3. If the path exists:
   • the condition is true
   • Found is printed
4. If the path does not exist:
   • the condition is false
   • Missing is printed

Trace example

Suppose the current directory contains:

Batch file processing

A program may receive a list of expected input files and report which ones are missing before starting work.

for (const auto& path : paths) {
    if (!std::filesystem::exists(path)) {
        std::cout << path << " is missing\n";
    }
}

Loading configuration files

Applications often look for optional configuration files.

• If the file exists, load it.
• If not, fall back to defaults.

Verifying assets

Games, media tools, and web build systems may check whether required assets exist:

• images,
• shaders,
• templates,
• translation files.

Import pipelines

Data-processing scripts may skip rows that reference missing files.

CLI tools

A command-line program may validate a user-supplied path before performing an action and print a clearer error message.

In real projects, developers rarely write a file-existence function in isolation without thinking about the next step.

Common pattern: try the real operation

If you are going to read the file anyway, do this:

#include <fstream>
#include <string>

bool loadFile(const std::string& name)
{
    std::ifstream file(name);
    if (!file) {
        return false;
    }

    // read file here
    return true;
}

This avoids checking once and then opening again.

Guard clause pattern

if (!std::filesystem::exists(path)) {
    return false;
}

This is useful when missing files should stop processing early.

Validation pattern

When accepting user input:

if (!std::filesystem::is_regular_file(path)) {
     std::();
}

1. Assuming exists() means “readable file”

Broken assumption:

if (std::filesystem::exists(path)) {
    std::ifstream file(path);
    // may still fail
}

Why it happens:

• the path may be a directory,
• permissions may block access,
• the file may change after the check.

How to avoid it:

• use is_regular_file(path) if you need a real file,
• or simply try to open it and handle failure.

2. Checking first, then opening unnecessarily

if (std::filesystem::exists(path)) {
    std::ifstream file(path);
}

This may do extra work and still is not fully safe.

Better:

std::ifstream file(path);
if (!file) {
    // handle missing or inaccessible file
}

3. Forgetting to close FILE* in C

// C++17: path exists
#include <filesystem>
bool existsPath(const std::string& name) {
    return std::filesystem::exists(name);
}

// C++17: regular file exists
#include <filesystem>
bool existsFile(const std::string& name) {
    return std::filesystem::is_regular_file(name);
}

// C++11/C++14: try opening
#include <fstream>
bool existsFile(const std::string& name) {
    std::ifstream file(name);
    return file.good();
}

// C: try opening
#include <stdio.h>
#include <stdbool.h>

bool exist {
    FILE* file = fopen(name, );
     (file) {
        fclose(file);
         ;
    }
     ;
}

How do I check if a file exists in standard C++17?

Use std::filesystem::exists(path). If you specifically need a normal file, use std::filesystem::is_regular_file(path).

How do I check if a file exists in C++11 or C++14 without non-standard libraries?

Use std::ifstream and check whether the stream opened successfully.

Is std::filesystem::exists faster than std::ifstream?

Not always in a meaningful, portable way. Performance depends on the OS and filesystem. Choose the approach that best matches your intent.

Should I check if the file exists before opening it?

Usually not if you plan to open it immediately. Just open it and handle failure.

Does exists() return true for directories?

Yes. If you need a real file, prefer std::filesystem::is_regular_file().

Can exists() still be followed by a failed file open?

Yes. Permissions, file type, or timing changes can cause the later open to fail.

What is the standard C way to check file existence?

Use fopen(path, "r"), check for NULL, and call fclose if opening succeeded.

• std::filesystem::path — Represents filesystem paths safely and clearly.
• File I/O with std::ifstream — Useful for opening and reading files in pre-C++17 code.
• Error handling — Important because file checks and file access can fail for many reasons.
• Guard clauses — Common pattern for returning early when a file is missing.
• Exception vs std::error_code — Relevant when using C++17 filesystem APIs.
• Directories and path types — Helpful for understanding the difference between files, directories, and other filesystem entries.