home | help 
std::filesystem::file_size(3)  C++ Standard Libary std::filesystem::file_size(3)

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.

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

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 al-
     location
	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
     // 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)

http://cppreference.com 	   2024.06.10	   std::filesystem::file_size(3)
home | help