Namespaces
Variants

std::filesystem:: file_size

From cppreference.net
Definiert im Header <filesystem>
(1) (seit C++17)
(2) (seit C++17)

Wenn p nicht existiert, wird ein Fehler gemeldet.

Für eine reguläre Datei p , gibt die Größe zurück, die bestimmt wird, als ob durch Auslesen des st_size -Members der Struktur, die durch POSIX stat ermittelt wurde (Symlinks werden verfolgt).

Das Ergebnis eines Versuchs, die Größe eines Verzeichnisses (sowie jeder anderen Datei, die keine reguläre Datei oder ein Symlink ist) zu bestimmen, ist implementierungsdefiniert.

Die nicht-werfende Überladung gibt bei Fehlern static_cast < std:: uintmax_t > ( - 1 ) zurück.

Inhaltsverzeichnis

Parameter

p - zu untersuchender Pfad
ec - Out-Parameter für Fehlerberichterstattung in der nicht-werfenden Überladung

Rückgabewert

Die Größe der Datei in Bytes.

Exceptions

Jede Überladung, die nicht als noexcept gekennzeichnet ist, kann std::bad_alloc auslösen, wenn die Speicherallokation fehlschlägt.

1) Wirft std::filesystem::filesystem_error bei zugrundeliegenden OS-API-Fehlern, konstruiert mit p als erstem Pfadargument und dem OS-Fehlercode als Fehlercodeargument.
2) Setzt einen std:: error_code & Parameter auf den OS-API-Fehlercode, falls ein OS-API-Aufruf fehlschlägt, und führt ec. clear ( ) aus, falls keine Fehler auftreten.

Beispiel

#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';
    }
}

Mögliche Ausgabe:

"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

Siehe auch

ändert die Größe einer regulären Datei durch Kürzung oder Auffüllung mit Nullen
(Funktion)
(C++17)
bestimmt den verfügbaren freien Speicherplatz im Dateisystem
(Funktion)
gibt die Größe der Datei zurück, auf die der Verzeichniseintrag verweist
(öffentliche Elementfunktion von std::filesystem::directory_entry )