fonctions`<filesystem>`

Ces fonctions gratuites dans l’en-tête C++17 <filesystem> effectuent des opérations de modification et de requête sur les chemins d’accès, 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++).

Note

Cet article documente les fonctions C++17 std::filesystem . Pour les fonctions préstandard historiques fournies par MSVC, <experimental/filesystem>consultez <experimental/filesystem> les fonctions.

Spécifications

En-tête :<filesystem>

Noms:std::filesystem

`absolute`

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

Les fonctions composent un chemin d’accès absolu qui fait référence au même emplacement de système de fichiers que pvalla sémantique du système d’exploitation. Surcharge qui prend ec des retours path() si une erreur se produit.

`begin`

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

Les deux fonctions retournent iter. endAvec , ils activent des boucles basées sur for des plages sur un directory_iterator ou recursive_directory_iterator.

`canonical`

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

Les fonctions convertissent pval, qui doit exister, en un chemin absolu qui fait référence au même objet de système de fichiers et n’a pas d’éléments symboliques, points ou points. Surcharge qui prend ec des retours path() si une erreur se produit.

`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 file_status valeurs f de ettvers. 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), 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).
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 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 à 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.

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

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

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

`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 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&) 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 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) && 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), 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 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, perm_options opts = perm_options::replace);
void permissions(const path& pval, perms mask, error_code& ec) noexcept;
void permissions(const path& pval, perms mask, perm_options opts, error_code& ec);

Les fonctions définissent les autorisations pour le chemin d’accès choisi par pval le mask & perms::mask contrôle de opts. opts doit contenir exactement l’un des perm_options::replaceéléments , perm_options::addou , et perm_options::removeéventuellement perm_options::nofollow. Les surcharges sans paramètre se opts comportent comme si c’est perm_options::replacele casopts.

Si opts & perm_options::add, les fonctions définissent les autorisations sur status(pval).permissions() | (mask & perms::mask). Sinon, si opts & perm_options::remove, les fonctions définissent les autorisations status(pval).permissions() & ~(mask & perms::mask)sur . Sinon, les fonctions définissent les autorisations mask & perms::masksur . Si opts & perm_options::nofollow et pval nomme un lien symbolique, les fonctions modifient les autorisations du lien symbolique lui-même plutôt que le fichier vers lequel elle est résolue.

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

La première surcharge retourne proximate(p, current_path(), ec). Les autres surcharges retournent le résultat de l’application lexically_proximate aux formes faiblement canoniques de p et base. Surcharge qui prend ec des retours path() si une erreur se produit.

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

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

La première surcharge retourne relative(p, current_path(), ec). Les autres surcharges retournent le résultat de l’application lexically_relative aux formes faiblement canoniques de p et base. Surcharge qui prend ec des retours path() si une erreur se produit.

`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_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.

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

Ces fonctions retournent un chemin d’accès sous forme canonique, comme la canonical fonction, mais le chemin d’accès n’a pas besoin d’exister.

Voir aussi

Informations de référence sur les fichiers d’en-tête
<filesystem>
Navigation dans le système de fichiers (C++)

Commentaires

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

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

fonctions<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

proximate

read_symlink

relative

remove

remove_all

rename

resize_file

space

status

status_known

swap

symlink_status

temp_directory_path

u8path

weakly_canonical