How to Check if a File Exists in C

By the end of this page, you will understand how file existence checks work in C, why fopen() is sometimes enough, when stat() or access() may be more appropriate, and what common mistakes to avoid when working with files and file paths.

In C, checking whether a file exists sounds simple, but the best method depends on what you actually need to know.

Sometimes you only care about this question:

• Can I open this file right now?

In that case, trying to open it is often a perfectly valid solution.

Other times, you want to know something more specific:

• Does a path exist?
• Is it a regular file or a directory?
• Do I have permission to read it?
• Will it still exist when I try to use it a moment later?

That is where functions like stat() and access() become useful.

Why this matters

In real programs, file handling is rarely just about existence. You usually want to:

• load configuration files
• read user uploads
• process log files
• create backups only if a file is present
• validate input paths

A key idea is this:

A separate “exists” check is often less useful than directly performing the operation you actually want.

For example, if your real goal is to read a file, then fopen() already answers the important question: can the file be opened for reading right now?

Common options in C

fopen()

Use this when your next step is to actually read or write the file.

Think of a file path like a house address.

• fopen() is like walking to the door and trying the handle.

  • If it opens, you can go in.
  • If it does not, the reason could be many things: the house is gone, the door is locked, or you are not allowed in.

• stat() is like checking public property records.

  • You can learn whether something exists at that address and what kind of thing it is.

• access() is like asking, “Am I allowed to enter?”

  • It focuses more on permissions.

The most practical lesson is:

• If your goal is to enter the house, just try the door.
• If your goal is to inspect the property, use a metadata tool like stat().

Using fopen()

Your original approach is valid if you want to know whether the file can be opened for reading.

#include <stdio.h>

int file_exists(const char *fname)
{
    FILE *file = fopen(fname, "r");
    if (file != NULL)
    {
        fclose(file);
        return 1;
    }
    return 0;
}

What this does

• Tries to open the file in read mode
• If successful, closes it immediately
• Returns 1 for success and 0 for failure

Using stat()

If you want to know whether a path exists, stat() is often a better fit.

#include <sys/stat.h>

int file_exists(const  *path)
{
    
     stat(path, &buffer) == ;
}

Consider this example:

#include <stdio.h>

int file_exists(const char *fname)
{
    FILE *file = fopen(fname, "r");
    if (file != NULL)
    {
        fclose(file);
        return 1;
    }
    return 0;
}

Now imagine we call:

int result = file_exists("notes.txt");

Step by step

Case 1: notes.txt exists and is readable

1. fopen("notes.txt", "r") is called.
2. The operating system finds the file and allows read access.
3. fopen() returns a non-NULL pointer.
4. The if condition is true.
5. fclose(file) releases the file handle.
6. The function returns 1.
7. result becomes .

Configuration files

A program may try to load config.txt or settings.json at startup.

• If the file is required, try opening it directly and report an error if it fails.
• If the file is optional, check and fall back to defaults if it is missing.

Log processing tools

A utility may scan a log file path before parsing it.

• stat() can verify the path exists
• S_ISREG() can confirm it is a normal file and not a directory

Backup scripts

Before copying or archiving data, a program might confirm the source file exists.

• stat() is useful if you want metadata too
• fopen() is fine if the next step is reading

Upload and import systems

A desktop or command-line tool may accept a file path from the user.

• Check whether the path exists
• Ensure it is the correct file type or at least a regular file
• Then open and process it

Temporary or generated files

Programs often look for lock files, cache files, or marker files.

• Existence itself may be meaningful
• stat() is a natural choice when the file is used as a signal

In production code, developers usually avoid writing code that checks a file first and then performs the real action later unless there is a clear reason.

Common pattern: do the real operation first

FILE *file = fopen(path, "r");
if (file == NULL)
{
    perror("Could not open file");
    return 0;
}

/* Use the file here */

fclose(file);

This avoids an unnecessary extra check.

Guard clauses

Developers often use early returns to keep file-handling code clear.

#include <sys/stat.h>

int load_if_regular_file(const char *path)
{
    struct stat st;

    if (stat(path, &st) != 0)
        return 0;

    if (!S_ISREG(st.st_mode))
        return 0;

    FILE *file = fopen(path, "r");
    if (file == NULL)
        return 0;

    fclose(file);
    return ;
}

1. Confusing “exists” with “can be opened”

This code checks more than existence:

FILE *file = fopen(path, "r");

If it fails, the reason may be:

• file does not exist
• permission denied
• path is a directory
• too many open files

How to avoid it

Choose the function based on your actual question.

• Use fopen() if you want to open the file
• Use stat() if you want to know whether the path exists

2. Forgetting to close the file

Broken code:

int file_exists(const char *path)
{
    FILE *file = fopen(path, "r");
    if (file != NULL)
    {
        return 1;
    }
    return 0;
}

This leaks a file handle.

Fix

int file_exists(  *path)
{
    FILE *file = fopen(path, );
     (file != )
    {
        fclose(file);
         ;
    }
     ;
}

fopen() vs stat()

Quick reference

Check whether a file can be opened

FILE *file = fopen(path, "r");
if (file != NULL)
{
    fclose(file);
}

Check whether a path exists

#include <sys/stat.h>

struct stat st;
if (stat(path, &st) == 0)
{
    /* path exists */
}

Check whether it is a regular file

if (stat(path, &st) == 0 && S_ISREG(st.st_mode))
{
    /* regular file */
}

Rules of thumb

• If you need to use the file, try the real operation with fopen().
• If you need to inspect the path, use stat().
• Always fclose() a file you successfully opened.
• Do not assume a file still exists after a separate check.
• fopen() failure can mean many things, not just “missing file”.

Common return patterns

Is using fopen() to check if a file exists okay in C?

Yes, if your real goal is to open the file for reading. It is simple, standard C, and often the most practical option.

What is the difference between fopen() and stat()?

fopen() checks whether the file can be opened in a specific mode. stat() checks whether a path exists and provides metadata such as file type and size.

Can fopen() fail even if the file exists?

Yes. It can fail because of permissions, file descriptor limits, path issues, or because the path refers to something that is not a normal file.

How do I check if a path is a directory or a regular file?

Use stat() and test st_mode with macros such as S_ISREG() and S_ISDIR().

Should I check existence before opening a file?

Usually no. If you plan to open the file anyway, open it directly and handle failure. This avoids race conditions and extra work.

Is access() portable in C?

No. It is common on POSIX systems, but it is not part of standard C, so it may not be available everywhere.

What should I use in portable C code?

• fopen — The standard C function for opening files, central to reading and writing.
• fclose — Required to release file handles after successful fopen calls.
• stat — Used to inspect whether a path exists and what kind of file system object it is.
• errno — Helps explain why file operations failed.
• File permissions — Important because a file may exist but still be unreadable.
• Guard clauses — Common pattern for handling file-related failures early.
• Race conditions — Relevant because a file can change between checking and using it.
• Standard I/O in C — Broader topic covering FILE *, streams, and file operations.