Fonctions `<experimental/filesystem>`

Important

L’en-tête <experimental/filesystem> et l’espace std::experimental::filesystem de noms ont fourni une implémentation préstandard de la spécification technique du système de fichiers (TS). Cette documentation est conservée pour le code écrit sur l’implémentation du système de fichiers d’origine de MSVC, qui a été supprimée à partir de MSVC version 14.51. Pour le nouveau code, utilisez l’en-tête C++17 <filesystem> et l’espace de noms à la std::filesystem place. Pour connaître les équivalents standard de ces fonctions, consultez <filesystem> les fonctions.

Ces fonctions gratuites dans l’en-tête <experimental/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 des exemples de code, consultez Navigation dans le système de fichiers (C++).

Spécifications

En-tête :<experimental/filesystem>

Noms:std::experimental::filesystem

`absolute`

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

La fonction retourne le chemin d’accès absolu correspondant à pval la valeur relative au chemin based’accès :

Si pval.has_root_name() && pval.has_root_directory() la fonction retourne pval.
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().
Si !pval.has_root_name() && pval.has_root_directory() la fonction retourne absolute(base).root_name() / pval.
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 :

Remplacez chaque composant X de chemin d’accès pour lequel is_symlink(X) il s’agit trueread_symlink(X)de .
Supprimez chaque composant . de chemin d’accès (point est le répertoire actif établi par les composants de chemin d’accès précédents).
Supprimez chaque paire de composants X/.. de chemin d’accès (point-point est le répertoire parent établi par les composants de chemin d’accès précédents).

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 au fromto contrôle de opts, qui est pris comme copy_options::none pour les surcharges sans opts paramètre. opts doit contenir au maximum l’un des éléments suivants :

skip_existing, overwrite_existing ou update_existing
copy_symlinks ou skip_symlinks
directories_only, create_symlinks ou create_hard_links

Les fonctions déterminent d’abord les file_status valeurs f pour from et t pour to. Ils s’utilisent symlink_status lorsque opts contient copy_options::create_symlinks, copy_options::skip_symlinksou copy_options::copy_symlinks, comme requis pour la source ou la destination. Sinon, ils utilisent status.

Si !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), les fonctions signalent une erreur et s’arrêtent. Sinon, si is_symlink(f), puis :

Si options & copy_options::skip_symlinks, alors ne faites rien.
Sinon, si !exists(t) && options & copy_options::copy_symlinks, alors copy_symlink(from, to).
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(from, to).
Sinon, si opts & copy_options::create_hard_links, alors create_hard_link(from, to).
Sinon, si is_directory(t), alors copy_file(from, to / from.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 faites rien.

`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 sous fromto le 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 dans le fichier fromto. Signalez une erreur si la tentative de copie échoue.

Les fonctions retournent true si la copie réussit et false sinon.

`copy_symlink`

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. 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 en fonction des besoins. Elle ne retourne true que si elle crée réellement le répertoire pval. Si vous spécifiez le attr paramètre, la fonction copie les autorisations du fichier existant. Si vous ne spécifiez pas le attr paramètre, la fonction utilise perms::all.

`create_directory_symlink`

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 link en tant que lien symbolique vers le répertoire to.

`create_hard_link`

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 link en tant que lien dur vers le répertoire ou le fichier to.

`create_symlink`

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 en tant que lien symbolique vers le fichier to.

`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 d’accès du répertoire actif. Les fonctions restantes définissent le répertoire actif sur pval.

`end`

directory_iterator end(const directory_iterator&) noexcept;
recursive_directory_iterator end(const recursive_directory_iterator&) 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 font référence à 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) && stat.type() != file_type::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).

`hard_link_count`

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(status(pval)).

`is_empty`

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

Si is_directory(pval), la fonction retourne directory_iterator(pval) == directory_iterator(). Sinon, la valeur file_size(pval) == 0 est renvoyée.

`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 exists(stat) && !is_regular_file(stat) && !is_directory(stat) && !is_symlink(stat). 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)).

`is_symlink`

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 pvalnew_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). maskcontient au maximum l’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 .

`read_symlink`

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.

`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;

S’il pval s’agit d’un répertoire, les fonctions suppriment de manière récursive toutes les entrées de répertoire, puis l’entrée elle-même. Sinon, les fonctions appellent remove. Ils retournent le nombre de tous les éléments supprimés avec succè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 from en to. Un lien symbolique est lui-même renommé, et non le fichier choisi.

`resize_file`

void resize_file(const path& pval, uintmax_t size);
void resize_file(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.

`symlink_status`

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`

Note

C++17 std::filesystem ne fournit system_completepas . Pour le code actuel, utilisez-le std::filesystem::absolute lorsqu’il fournit le comportement requis.

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

Les fonctions retournent un chemin d’accès absolu qui prend en compte, le cas échéant, le répertoire actif associé à son nom 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 d’accès pour un répertoire approprié pour contenir des fichiers 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.

Voir aussi

<experimental/filesystem>
<experimental/filesystem> énumérations
<experimental/filesystem> opérateurs

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-08-31

Fonctions <experimental/filesystem>

Spécifications

absolute

begin

canonical

copy

copy_file

copy_symlink

create_directories

create_directory

create_directory_symlink

create_hard_link

create_symlink

current_path

end

equivalent

exists

file_size

hard_link_count

hash_value

is_block_file

is_character_file

is_directory

is_empty

is_fifo

is_other

is_regular_file

is_socket

is_symlink

last_write_time

permissions

read_symlink

remove

remove_all

rename

resize_file

space

status

status_known

swap

symlink_status

system_complete

temp_directory_path

u8path