Partager via

fonctions<filesystem>

  • Article

Ces fonctions gratuites dans l’en-tête <filesystem> effectuent des opérations de modification et de requête sur les chemins, les fichiers, les liens symboliques, les répertoires et les volumes. Pour plus d’informations et pour obtenir des exemples de code, consultez Navigation dans le système de fichiers (C++).

absolute

path absolute(const path& pval, const path& base = current_path());

La fonction retourne le chemin absolu correspondant au pval relatif à l’objet base du chemin :

  1. Si pval.has_root_name() && pval.has_root_directory(), la fonction retourne pval.

  2. Si pval.has_root_name() && !pval.has_root_directory(), la fonction retourne pval.root_name() / absolute(base).root_directory() / absolute(base).relative_path() / pval.relative_path().

  3. Si !pval.has_root_name() && pval.has_root_directory(), la fonction retourne absolute(base).root_name() / pval.

  4. Si !pval.has_root_name() && !pval.has_root_directory(), la fonction retourne absolute(base) / pval.

begin

const directory_iterator& begin(const directory_iterator& iter) noexcept;
const recursive_directory_iterator&
    begin(const recursive_directory_iterator& iter) noexcept;

Les deux fonctions retournent iter.

canonical

path canonical(const path& pval, const path& base = current_path());
path canonical(const path& pval, error_code& ec);
path canonical(const path& pval, const path& base, error_code& ec);

Les fonctions forment tous un chemin pabs = absolute(pval, base) d’accès absolu (ou pabs = absolute(pval) pour la surcharge sans paramètre de base), puis réduisent-les à un formulaire canonique dans la séquence d’étapes suivante :

  1. Chaque composant X de chemin d’accès pour lequel is_symlink(X) est true remplacé par read_symlink(X).

  2. Chaque composant . de chemin (point est le répertoire actif établi par les composants de chemin d’accès précédents) est supprimé.

  3. Chaque paire de composants X/.. de chemin (dot-dot est le répertoire parent établi par les composants de chemin d’accès précédents) est supprimée.

La fonction retourne pabsensuite .

copy

void copy(const path& from, const path& to);
void copy(const path& from, const path& to, error_code& ec) noexcept;
void copy(const path& from, const path& to, copy_options opts);
void copy(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Toutes les fonctions peuvent copier ou lier un ou plusieurs fichiers à partir de vers sous contrôle , optsqui est pris comme copy_options::none pour les surcharges sans opts paramètre. opts contient au maximum un des éléments suivants :

  • skip_existing, overwrite_existingou update_existing

  • copy_symlinks ou skip_symlinks

  • directories_only, create_symlinksou create_hard_links

Les fonctions déterminent d’abord les valeurs f de file_status à partir et t pour :

  • si , en opts & (copy_options::create_symlinks | copy_options::skip_symlinks)appelant symlink_status

  • sinon, en appelant status

  • Sinon, elles signalent une erreur.

Si !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), ils signalent ensuite une erreur (et ne font rien d’autre).

Sinon, si is_symlink(f) c’est le cas :

  • Si options & copy_options::skip_symlinks, alors ne faites rien.

  • Sinon, si !exists(t)&& options & copy_options::copy_symlinks, alors copy_symlink(from, to, opts).

  • Sinon, signalez une erreur.

Sinon, si is_regular_file(f), puis :

  • Si opts & copy_options::directories_only, alors ne faites rien.

  • Sinon, si opts & copy_options::create_symlinks, alors create_symlink(to, from).

  • Sinon, si opts & copy_options::create_hard_links, alors create_hard_link(to, from).

  • Sinon, si is_directory(f), alors / copy_file(from, tofrom.filename(), opts) .

  • Sinon, copy_file(from, to, opts).

Sinon, si is_directory(f) && (opts & copy_options::recursive || !opts), puis :

if (!exists(t))
{  // copy directory contents recursively
    create_directory(to, from, ec);

    for (directory_iterator next(from), end; ec == error_code() && next != end; ++next)
    {
        copy(next->path(), to / next->path().filename(), opts, ec);
    }
}

Sinon, ne rien faire.

copy_file

bool copy_file(const path& from, const path& to);
bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
bool copy_file(const path& from, const path& to, copy_options opts);
bool copy_file(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Toutes les fonctions peuvent copier le fichier à partir de jusqu’au contrôle de opts, qui est pris comme copy_options::none pour les surcharges sans opts paramètre. optsdoit contenir au plus un des skip_existingéléments suivants : ou overwrite_existingupdate_existing.

Si exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), signalez une erreur indiquant que le fichier existe déjà.

Sinon, si !exists(to) || opts & copy_options::overwrite_existing || opts & copy_options::update_existing&& last_write_time(to) < last_write_time(from) || !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options:update_existing)), essayez de copier le contenu et les attributs du fichier du fichier vers celui-ci. Signaler comme erreur si la tentative de copie échoue.

Les fonctions retournent true si la copie est tentée et réussit, sinon false.

void copy_symlink(const path& from, const path& to);
void copy_symlink(const path& from, const path& to, error_code& ec) noexcept;

Si is_directory(from), la fonction appelle create_directory_symlink(from, to). Sinon, il appelle create_symlink(from, to).

create_directories

bool create_directories(const path& pval);
bool create_directories(const path& pval, error_code& ec) noexcept;

Pour un nom de chemin d’accès tel que a\/b\/c, la fonction crée des répertoires a et a\/b , si nécessaire, afin qu’elle puisse créer le répertoire a\/b\/c selon les besoins. Elle ne retourne true que si elle crée réellement le répertoire pval.

create_directory

bool create_directory(const path& pval);

bool create_directory(const path& pval, error_code& ec) noexcept;
bool create_directory(const path& pval, const path& attr);
bool create_directory(const path& pval, const path& attr, error_code& ec) noexcept;

La fonction crée le répertoire pval, si nécessaire. Il ne retourne true que s’il crée réellement le répertoire pval, auquel cas il copie les autorisations à partir du fichier attrexistant, ou utilise perms::all pour les surcharges sans attr paramètre.

void create_directory_symlink(const path& to, const path& link);
void create_directory_symlink(const path& to, const path& link, error_code& ec) noexcept;

La fonction crée un lien en tant que lien symbolique vers le répertoire.

void create_hard_link(const path& to,  const path& link);
void create_hard_link(const path& to, const path& link, error_code& ec) noexcept;

La fonction crée un lien en tant que lien dur vers le répertoire ou le fichier.

void create_symlink(const path& to, const path& link);

void create_symlink(const path& to, const path& link, error_code& ec) noexcept;

La fonction crée link un lien symbolique vers le fichier.

current_path

path current_path();
path current_path(error_code& ec);
void current_path(const path& pval);
void current_path(const path& pval, error_code& ec) noexcept;

Les fonctions sans paramètre pval retournent le chemin du répertoire actuel. Les autres fonctions définissent le répertoire actuel sur pval.

end

directory_iterator& end(const directory_iterator& iter) noexcept;
recursive_directory_iterator& end(const recursive_directory_iterator& iter) noexcept;

La première fonction retourne directory_iterator() et la deuxième fonction retourne recursive_directory_iterator()

equivalent

bool equivalent(const path& left, const path& right);
bool equivalent(const path& left, const path& right, error_code& ec) noexcept;

Les fonctions ne retournent true que si la gauche et la droite choisissent la même entité de système de fichiers.

exists

bool exists(file_status stat) noexcept;
bool exists(const path& pval);
bool exists(const path& pval, error_code& ec) noexcept;

La première fonction retourne status_known && stat.type() != file_not_found. Les deuxième et troisième fonctions retournent exists(status(pval)).

file_size

uintmax_t file_size(const path& pval);
uintmax_t file_size(const path& pval, error_code& ec) noexcept;

Les fonctions retournent la taille en octets du fichier choisi par pval, si exists(pval) && is_regular_file(pval) et la taille du fichier peut être déterminée. Sinon, ils signalent une erreur et retournent uintmax_t(-1).

uintmax_t hard_link_count(const path& pval);
uintmax_t hard_link_count(const path& pval, error_code& ec) noexcept;

La fonction retourne le nombre de liens durs pour pval, ou -1 si une erreur se produit.

hash_value

size_t hash_value(const path& pval) noexcept;

La fonction retourne une valeur de hachage pour pval.native().

is_block_file

bool is_block_file(file_status stat) noexcept;
bool is_block_file(const path& pval);
bool is_block_file(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::block. Les fonctions restantes retournent is_block_file(status(pval)).

is_character_file

bool is_character_file(file_status stat) noexcept;
bool is_character_file(const path& pval);
bool is_character_file(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::character. Les fonctions restantes retournent is_character_file(status(pval)).

is_directory

bool is_directory(file_status stat) noexcept;
bool is_directory(const path& pval);
bool is_directory(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::directory. Les fonctions restantes retournent is_directory_file(status(pval)).

is_empty

bool is_empty(file_status stat) noexcept;
bool is_empty(const path& pval);
bool is_empty(const path& pval, error_code& ec) noexcept;

Si is_directory(pval), alors la fonction retourne directory_iterator(pval) == directory_iterator(); sinon, elle retourne file_size(pval) == 0.

is_fifo

bool is_fifo(file_status stat) noexcept;
bool is_fifo(const path& pval);
bool is_fifo(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::fifo. Les fonctions restantes retournent is_fifo(status(pval)).

is_other

bool is_other(file_status stat) noexcept;
bool is_other(const path& pval);
bool is_other(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::other. Les fonctions restantes retournent is_other(status(pval)).

is_regular_file

bool is_regular_file(file_status stat) noexcept;
bool is_regular_file(const path& pval);
bool is_regular_file(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::regular. Les fonctions restantes retournent is_regular_file(status(pval)).

is_socket

bool is_socket(file_status stat) noexcept;
bool is_socket(const path& pval);
bool is_socket(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::socket. Les fonctions restantes retournent is_socket(status(pval)).

bool is_symlink(file_status stat) noexcept;
bool is_symlink(const path& pval);
bool is_symlink(const path& pval, error_code& ec) noexcept;

La première fonction retourne stat.type() == file_type::symlink. Les fonctions restantes retournent is_symlink(status(pval)).

last_write_time

file_time_type last_write_time(const path& pval);
file_time_type last_write_time(const path& pval, error_code& ec) noexcept;
void last_write_time(const path& pval, file_time_type new_time);
void last_write_time(const path& pval, file_time_type new_time, error_code& ec) noexcept;

Les deux premières fonctions retournent l’heure de la dernière modification des données pour pval, ou file_time_type(-1) si une erreur se produit. Les deux dernières fonctions définissent l’heure de la dernière modification des données pour pval new_time.

permissions

void permissions(const path& pval, perms mask);
void permissions(const path& pval, perms mask, error_code& ec) noexcept;

Les fonctions définissent les autorisations pour le chemin d’accès choisi par pval le mask & perms::mask contrôle de perms & (perms::add_perms | perms::remove_perms). maskdoit contenir au plus un des éléments suivants perms::add_perms :perms::remove_perms

Si mask & perms::add_perms, les fonctions définissent les autorisations sur status(pval).permissions() | mask & perms::mask. Sinon, si mask & perms::remove_perms, les fonctions définissent les autorisations status(pval).permissions() & ~(mask & perms::mask)sur . Sinon, les fonctions définissent les autorisations mask & perms::masksur .

proximate

path proximate(const path& p, error_code& ec);
path proximate(const path& p, const path& base = current_path());
path proximate(const path& p, const path& base, error_code& ec);

path read_symlink(const path& pval);
path read_symlink(const path& pval, error_code& ec);

Les fonctions signalent une erreur et retournent path() si !is_symlink(pval). Sinon, les fonctions retournent un objet de type path contenant le lien symbolique.

relative

path relative(const path& p, error_code& ec);
path relative(const path& p, const path& base = current_path());
path relative(const path& p, const path& base, error_code& ec);

remove

bool remove(const path& pval);
bool remove(const path& pval, error_code& ec) noexcept;

Les fonctions ne retournent true que si exists(symlink_status(pval)) et si le fichier est correctement supprimé. Un lien symbolique est lui-même supprimé, et non le fichier choisi.

remove_all

uintmax_t remove_all(const path& pval);
uintmax_t remove_all(const path& pval, error_code& ec) noexcept;

Si pval est un répertoire, les fonctions suppriment de façon récursive toutes les entrées de répertoire, puis l’entrée elle-même. Sinon, les fonctions appellent remove. Elles retournent un comptage de tous les éléments qui ont été supprimés.

rename

void rename(const path& from, const path& to);
void rename(const path& from, const path& to, error_code& ec) noexcept;

Les fonctions sont renommées vers. Un lien symbolique est lui-même renommé, et non le fichier choisi.

resize_file

void resize(const path& pval, uintmax_t size);
void resize(const path& pval, uintmax_t size, error_code& ec) noexcept;

Les fonctions modifient la taille d’un fichier de sorte que file_size(pval) == size

space

space_info space(const path& pval);
space_info space(const path& pval, error_code& ec) noexcept;

La fonction retourne des informations sur le volume choisi par pval, dans une structure de type space_info. La structure contient uintmax_t(-1) une valeur qui ne peut pas être déterminée.

status

file_status status(const path& pval);
file_status status(const path& pval, error_code& ec) noexcept;

Les fonctions retournent l’état du chemin d’accès, le type de fichier et les autorisations associés à pval. Un lien symbolique n’est pas testé, mais le fichier choisi.

status_known

bool status_known(file_status stat) noexcept;

La fonction retourne stat.type() != file_type::none

swap

void swap(path& left, path& right) noexcept;

La fonction échange le contenu de gauche et de droite.

file_status symlink_status(const path& pval);
file_status symlink_status(const path& pval, error_code& ec) noexcept;

Les fonctions retournent l’état de symlink pathname, le type de fichier et les autorisations associés à pval. Les fonctions se comportent de la même façon que status(pval) si un lien symbolique est lui-même testé, et non le fichier choisi.

system_complete

path system_complete(const path& pval);
path system_complete(const path& pval, error_code& ec);

Les fonctions retournent un nom de chemin absolu qui prend en compte si nécessaire le répertoire actuel associé au nom de sa racine. (Pour POSIX, les fonctions retournent absolute(pval)).

temp_directory_path

path temp_directory_path();
path temp_directory_path(error_code& ec);

Les fonctions retournent un nom de chemin pour un répertoire approprié à des fichiers conteneurs temporaires.

u8path

template <class Source>
path u8path(const Source& source);

template <class InIt>
path u8path(InIt first, InIt last);

La première fonction se comporte de la même façon que path(source) et la deuxième fonction se comporte de la même façon que path(first, last) la source choisie dans chaque cas est prise comme séquence d’éléments char encodés en UTF-8, quel que soit le système de fichiers.

weakly_canonical

path weakly_canonical(const path& p);
path weakly_canonical(const path& p, error_code& ec);