std::filesystem::file_size(3)

💖 std::filesystem::file_size 💖

okay so bestie, this is std::filesystem::file_size from the C++ Standard Library — manual name std::filesystem::file_size(3) — and it is literally the “how big is this file tho” function. It’s giving “I just want the byte count” energy, and I’m obsessed. 🦋

🎀 NAME 🎀

std::filesystem::file_size - std::filesystem::file_size ✨

🌸 Synopsis 🌸

Defined in header <filesystem>
std::uintmax_t file_size( const std::filesystem::path& p ); (1)
(since C++17)
std::uintmax_t file_size( const std::filesystem::path& p,   (2)
(since C++17)
                             std::error_code& ec ) noexcept;

If p does not exist, reports an error. 🚨

For a regular file p, returns the size determined as if by reading the st_size member of the structure obtained by POSIX stat (symlinks are followed). 💅

The result of attempting to determine the size of a directory (as well as any other file that is not a regular file or a symlink) is implementation-defined. So yeah, that part is a little “iykyk.” 🙈

The non-throwing overload returns static_cast<std::uintmax_t>(-1) on errors. 😭

🧚 Parameters 🧚

• p — path to examine
• ec — out-parameter for error reporting in the non-throwing overload

🔥 Return value 🔥

The size of the file, in bytes. 💅

😭 Exceptions 😭

Any overload not marked noexcept may throw std::bad_alloc if memory allocation fails.

1. Throws std::filesystem::filesystem_error on underlying OS API errors, constructed with p as the first path argument and the OS error code as the error code argument.
2. Sets a std::error_code& parameter to the OS API error code if an OS API call fails, and executes ec.clear() if no errors occur.

🌈 Example 🌈

bestie, run this code if you want to see it in action 👑

// Run this code

#include <cmath>
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;

struct HumanReadable
{
    std::uintmax_t size{};

private:
    friend std::ostream& operator<<(std::ostream& os, HumanReadable hr)
    {
        int o{};
        double mantissa = hr.size;
        for (; mantissa >= 1024.; mantissa /= 1024., ++o);
        os << std::ceil(mantissa * 10.) / 10. << "BKMGTPE"[o];
        return o ? os << "B (" << hr.size << ')' : os;
    }
};

int main(int, char const* argv[])
{
    fs::path example = "example.bin";
    fs::path p = fs::current_path() / example;
    std::ofstream(p).put('a'); // create file of size 1
    std::cout << example << " size = " << fs::file_size(p) << '\n';
    fs::remove(p);

    p = argv[0];
    std::cout << p << " size = " << HumanReadable{fs::file_size(p)} <<
       '\n';

    try
    {
        std::cout << "Attempt to get size of a directory:\n";
        [[maybe_unused]] auto x_x = fs::file_size("/dev");
    }
    catch (fs::filesystem_error& e)
    {
        std::cout << e.what() << '\n';
    }

    for (std::error_code ec; fs::path bin : {"cat", "mouse"})
    {
        bin = "/bin"/bin;
        if (const std::uintmax_t size = fs::file_size(bin, ec); ec)
            std::cout << bin << " : " << ec.message() << '\n';
        else
            std::cout << bin << " size = " << HumanReadable{size} <<
       '\n';
    }
}

🍓 Possible output 🍓

"example.bin" size = 1
"./a.out" size = 22KB (22512)
Attempt to get size of a directory:
filesystem error: cannot get file size: Is a directory [/dev]
"/bin/cat" size = 50.9KB (52080)
"/bin/mouse" : No such file or directory

👑 See also 👑

• resize_file — changes the size of a regular file by truncation or zero-fill (C++17) (function)
• space — determines available free space on the file system (C++17) (function)
• file_size — returns the size of the file to which the directory entry refers (public member function of std::filesystem::directory_entry)

---

source/version: http://cppreference.com — date: 2024.06.10 — page: std::filesystem::file_size(3). mwah 💋✨