Namespaces
Variants

std::filesystem:: file_size

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
Défini dans l'en-tête <filesystem>
(1) (depuis C++17)
(2) (depuis C++17)

Si p n'existe pas, signale une erreur.

Pour un fichier régulier p , retourne la taille déterminée comme si en lisant le membre st_size de la structure obtenue par POSIX stat (les liens symboliques sont suivis).

Le résultat de la tentative de déterminer la taille d'un répertoire (ainsi que de tout autre fichier qui n'est pas un fichier régulier ou un lien symbolique) est défini par l'implémentation.

La surcharge non levante retourne static_cast < std:: uintmax_t > ( - 1 ) en cas d'erreurs.

Table des matières

Paramètres

p - chemin à examiner
ec - paramètre de sortie pour le rapport d'erreurs dans la surcharge non-lancante

Valeur de retour

La taille du fichier, en octets.

Exceptions

Toute surcharge non marquée noexcept peut lever std::bad_alloc si l'allocation de mémoire échoue.

1) Lance std::filesystem::filesystem_error en cas d'erreurs de l'API système sous-jacente, construit avec p comme premier argument de chemin et le code d'erreur du système comme argument de code d'erreur.
2) Définit un paramètre std:: error_code & au code d'erreur de l'API du système d'exploitation si un appel d'API système échoue, et exécute ec. clear ( ) si aucune erreur ne survient.

Exemple

Exécuter ce 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';
    }
}

Sortie possible : 

"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

Voir aussi

(C++17)
modifie la taille d'un fichier régulier par troncation ou remplissage par des zéros
(fonction)
(C++17)
détermine l'espace libre disponible sur le système de fichiers
(fonction)
retourne la taille du fichier auquel l'entrée de répertoire fait référence
(fonction membre publique de std::filesystem::directory_entry )