Namespaces
Variants

std::filesystem:: space_info

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
Défini dans l'en-tête <filesystem>
struct space_info {

std:: uintmax_t capacity ;
std:: uintmax_t free ;
std:: uintmax_t available ;

} ;
(depuis C++17)

Représente les informations du système de fichiers telles que déterminées par filesystem::space .

Table des matières

Objets membres

capacity
taille totale du système de fichiers, en octets
(objet membre public)
free
espace libre sur le système de fichiers, en octets
(objet membre public)
available
espace libre disponible pour un processus non privilégié (peut être égal ou inférieur à free )
(objet membre public)

Fonctions non membres

operator==
(C++20)
compare deux space_info s
(fonction)

operator== (std::filesystem::space_info)

friend bool operator == ( const space_info & , const space_info & ) = default ;
(depuis C++20)

Vérifie si capacity , free et available des deux arguments sont respectivement égaux.

Cette fonction n'est pas visible par la recherche non qualifiée ordinaire ou la recherche qualifiée , et ne peut être trouvée que par la recherche dépendante des arguments lorsque std::filesystem::space_info est une classe associée des arguments.

L'opérateur != est synthétisé à partir de operator== .

Exemple

Exécuter ce code 
#include <cstdint>
#include <filesystem>
#include <iostream>
#include <locale>
std::uintmax_t disk_usage_percent(const std::filesystem::space_info& si,
                                  bool is_privileged = false) noexcept
{
    if (constexpr std::uintmax_t X(-1);
        si.capacity == 0 || si.free == 0 || si.available == 0 ||
        si.capacity == X || si.free == X || si.available == X
    )
        return 100;
    std::uintmax_t unused_space = si.free, capacity = si.capacity;
    if (!is_privileged)
    {
        const std::uintmax_t privileged_only_space = si.free - si.available;
        unused_space -= privileged_only_space;
        capacity -= privileged_only_space;
    }
    const std::uintmax_t used_space{capacity - unused_space};
    return 100 * used_space / capacity;
}
void print_disk_space_info(auto const& dirs, int width = 14)
{
    (std::cout << std::left).imbue(std::locale("en_US.UTF-8"));
    for (const auto s : {"Capacity", "Free", "Available", "Use%", "Dir"})
        std::cout << "│ " << std::setw(width) << s << ' ';
    for (std::cout << '\n'; auto const& dir : dirs)
    {
        std::error_code ec;
        const std::filesystem::space_info si = std::filesystem::space(dir, ec);
        for (auto x : {si.capacity, si.free, si.available, disk_usage_percent(si)})
            std::cout << "│ " << std::setw(width) << static_cast<std::intmax_t>(x) << ' ';
        std::cout << "│ " << dir << '\n';
    }
}
int main()
{
    const auto dirs = {"/dev/null", "/tmp", "/home", "/proc", "/null"};
    print_disk_space_info(dirs);
}

Sortie possible : 

│ Capacity       │ Free           │ Available      │ Use%           │ Dir            
│ 84,417,331,200 │ 42,732,986,368 │ 40,156,028,928 │ 50             │ /dev/null
│ 84,417,331,200 │ 42,732,986,368 │ 40,156,028,928 │ 50             │ /tmp
│ -1             │ -1             │ -1             │ 100            │ /home
│ 0              │ 0              │ 0              │ 100            │ /proc
│ -1             │ -1             │ -1             │ 100            │ /null

Voir aussi

(C++17)
détermine l'espace libre disponible sur le système de fichiers
(fonction)