# std::filesystem::file_size

From cppreference.com
< cpp‎ | filesystem

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

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.

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

The overload that does not take a std::error_code& parameter throws `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. The overload taking a std::error_code& parameter sets it to the OS API error code if an OS API call fails, and executes ec.clear() if no errors occur. Any overload not marked `noexcept` may throw std::bad_alloc if memory allocation fails.

### Example

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 i{};
            double mantissa = hr.size;
            for (; mantissa >= 1024.; mantissa /= 1024., ++i) { }
            mantissa = std::ceil(mantissa * 10.) / 10.;
            os << mantissa << "BKMGTPE"[i];
            return i == 0 ? os : os << "B (" << hr.size << ')';
        }
    };

    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";
            fs::file_size("/dev");
        } catch(fs::filesystem_error& e) {
            std::cout << e.what() << '\n';
        }

        std::error_code ec;
        for (fs::path bin: {"cat", "mouse"}) {
            bin = "/bin"/bin;
            std::uintmax_t size = fs::file_size(bin, ec);
            if (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 (C++17) | changes the size of a regular file by truncation or zero-fill (function)
space (C++17) | determines available free space on the file system (function)
file_size | returns the size of the file to which the directory entry refers (public member function of `std::filesystem::directory_entry`)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/filesystem/file_size&oldid=136331"