`<experimental/filesystem>` funções

Importante

O <experimental/filesystem> cabeçalho e o std::experimental::filesystem namespace forneceram uma implementação pré-padrão da Especificação Técnica do Sistema de Ficheiros (TS). Esta documentação é mantida para código escrito contra a implementação original do sistema de ficheiros do MSVC, que foi removida a partir da versão 14.51 do MSVC. Para código novo, use o cabeçalho C++17 <filesystem> e o std::filesystem namespace em vez disso. Para os equivalentes padrão destas funções, veja <filesystem> funções.

Estas funções livres no <experimental/filesystem> cabeçalho realizam operações de modificação e consulta em caminhos, ficheiros, ligações simbólicas, diretórios e volumes. Para mais informações e exemplos de código, consulte Navegação por Sistema de Ficheiros (C++).

Requisitos

Cabeçalho:<experimental/filesystem>

Espaço de nomes:std::experimental::filesystem

`absolute`

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

A função devolve o nome absoluto do caminho correspondente a pval relativo ao nome do caminho base:

Se pval.has_root_name() && pval.has_root_directory() a função devolver pval.
Se pval.has_root_name() && !pval.has_root_directory() a função devolver pval.root_name() / / absolute(base).root_directory()absolute(base).relative_path() / pval.relative_path().
Se !pval.has_root_name() && pval.has_root_directory() a função devolver absolute(base).root_name() / pval.
Se !pval.has_root_name() && !pval.has_root_directory() a função devolver absolute(base) / pval.

`begin`

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

Ambas as funções retornam 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);

As funções formam todas um nome pabs = absolute(pval, base) de caminho absoluto (ou pabs = absolute(pval) para a sobrecarga sem parâmetro base), depois reduzem-no a uma forma canónica na seguinte sequência de passos:

Substitua todos os componentes X do caminho para que is_symlink(X) seja true por read_symlink(X).
Remover todos os componentes . do caminho (o ponto é o diretório atual estabelecido pelos componentes do caminho anteriores).
Remova todos os pares de componentes X/.. do caminho (dot-dot é o diretório principal estabelecido pelos componentes do caminho anteriores).

A função devolve pabsentão .

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

As funções possivelmente copiam ou ligam um ou mais ficheiros em from sob to controlo de opts, o que é tomado como copy_options::none para sobrecargas sem opts parâmetro. opts deve conter, no máximo, um dos:

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

As funções determinam primeiro os file_status valores f para from e t para to. Usam symlink_status quando opts contém copy_options::create_symlinks, copy_options::skip_symlinks, ou copy_options::copy_symlinks, conforme necessário para a origem ou destino. Caso contrário, usam status.

Se !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), as funções reportam um erro e param. Caso contrário, se is_symlink(f), então:

Se options & copy_options::skip_symlinks, então não faças nada.
Caso contrário, se !exists(t) && options & copy_options::copy_symlinks, então copy_symlink(from, to).
Caso contrário, reporte um erro.

Caso contrário, se is_regular_file(f), então:

Se opts & copy_options::directories_only, então não faças nada.
Caso contrário, se opts & copy_options::create_symlinks, então create_symlink(from, to).
Caso contrário, se opts & copy_options::create_hard_links, então create_hard_link(from, to).
Caso contrário, se is_directory(t), então copy_file(from, to / from.filename(), opts).
Caso contrário, copy_file(from, to, opts).

Caso contrário, se is_directory(f) && (opts & copy_options::recursive || !opts), então:

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

Caso contrário, não faças nada.

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

As funções possivelmente copiam o ficheiro em from para to sob controlo de opts, o que é tomado como copy_options::none para sobrecargas sem opts parâmetro. opts deve conter no máximo um de skip_existing, overwrite_existing, ou update_existing.

Se exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), então reporta como erro que o ficheiro já existe.

Caso contrário, se !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)), então tente copiar o conteúdo e os atributos do ficheiro from para o ficheiro to. Reporte como erro se a tentativa de cópia falhar.

As funções retornam true se a cópia for bem-sucedida, e false caso contrário.

`copy_symlink`

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

Se is_directory(from), a função chama create_directory_symlink(from, to). Caso contrário, chama create_symlink(from, to).

`create_directories`

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

Para um nome de caminho como a\/b\/c, a função cria diretórios a e a\/b conforme necessário para que possa criar o diretório a\/b\/c. Só devolve true se realmente criar o diretório 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;

A função cria o diretório pval conforme necessário. Só devolve true se realmente criar o diretório pval. Se especificar o attr parâmetro, a função copia permissões do ficheiro existente. Se não especificar o attr parâmetro, a função usa 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;

A função cria-se link como um link simbólico para o diretório 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;

A função cria-se link como um link rígido para o diretório ou ficheiro 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;

A função cria-se link como um elo simbólico para o ficheiro 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;

As funções sem parâmetro pval retornam o nome do caminho para o diretório atual. As funções restantes definem o diretório atual para pval.

`end`

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

A primeira função devolve directory_iterator() e a segunda função devolve recursive_directory_iterator().

`equivalent`

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

As funções retornam true apenas se esquerda e direita se referirem à mesma entidade do sistema de ficheiros.

`exists`

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

A primeira função devolve status_known(stat) && stat.type() != file_type::not_found. A segunda e terceira funções retornam exists(status(pval)).

`file_size`

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

As funções retornam o tamanho em bytes do ficheiro escolhido por pval, se exists(pval) && is_regular_file(pval) e o tamanho do ficheiro puder ser determinado. Caso contrário, reportam um erro e devolvem 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;

A função devolve o número de ligações fixas para pval, ou -1 se ocorrer um erro.

`hash_value`

size_t hash_value(const path& pval) noexcept;

A função devolve um valor de hash para 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;

A primeira função devolve stat.type() == file_type::block. As funções restantes retornam 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;

A primeira função devolve stat.type() == file_type::character. As funções restantes retornam 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;

A primeira função devolve stat.type() == file_type::directory. As funções restantes retornam is_directory(status(pval)).

`is_empty`

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

Se is_directory(pval), a função devolve directory_iterator(pval) == directory_iterator(). Caso contrário, ele retorna 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;

A primeira função devolve stat.type() == file_type::fifo. As funções restantes retornam 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;

A primeira função devolve exists(stat) && !is_regular_file(stat) && !is_directory(stat) && !is_symlink(stat). As funções restantes retornam 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;

A primeira função devolve stat.type() == file_type::regular. As funções restantes retornam 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;

A primeira função devolve stat.type() == file_type::socket. As funções restantes retornam 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;

A primeira função devolve stat.type() == file_type::symlink. As funções restantes retornam 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;

As duas primeiras funções retornam o tempo da última modificação de dados para pval, ou file_time_type(-1) se ocorrer um erro. As duas últimas funções definem o tempo da última modificação de dados para pvalnew_time.

`permissions`

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

As funções definem as permissões para o nome de caminho escolhido por pval para mask & perms::mask sob controlo de perms & (perms::add_perms | perms::remove_perms). mask contém no máximo um de perms::add_perms e perms::remove_perms.

Se mask & perms::add_perms, as funções definem as permissões para status(pval).permissions() | mask & perms::mask. Caso contrário, se mask & perms::remove_perms, as funções definem as permissões para status(pval).permissions() & ~(mask & perms::mask). Caso contrário, as funções definem as permissões para mask & perms::mask.

`read_symlink`

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

As funções reportam um erro e retornam path() se !is_symlink(pval). Caso contrário, as funções retornam um objeto do tipo path que contém a ligação simbólica.

`remove`

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

As funções retornam true apenas se exists(symlink_status(pval)) e o ficheiro for removido com sucesso. Um symlink é removido, não o ficheiro que escolhe.

`remove_all`

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

Se pval for um diretório, as funções removem recursivamente todas as entradas do diretório, e depois a própria entrada. Caso contrário, as funções chamam remove. Eles retornam uma contagem de todos os elementos removidos com sucesso.

`rename`

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

As funções são renomeadas from para to. Um symlink é ele próprio renomeado, não o ficheiro que escolhe.

`resize_file`

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

As funções alteram o tamanho de um ficheiro de modo que file_size(pval) == size.

`space`

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

A função devolve informação sobre o volume escolhido por pval, numa estrutura de tipo space_info. A estrutura contém uintmax_t(-1) para qualquer valor que não pode ser determinado.

`status`

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

As funções retornam o estado do nome do caminho, o tipo de ficheiro e as permissões, associadas a pval. Um symlink em si não é testado, mas sim o ficheiro que escolhe.

`status_known`

bool status_known(file_status stat) noexcept;

A função retorna stat.type() != file_type::none

`swap`

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

A função troca o conteúdo da esquerda e da direita.

`symlink_status`

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

As funções devolvem o estado do nome do caminho, o tipo de ficheiro e as permissões, associadas a pval. As funções comportam-se da mesma forma, status(pval) exceto que um symlink é ele próprio testado, não o ficheiro que escolhe.

`system_complete`

Note

C++17 std::filesystem não fornece system_complete. Para código atual, use std::filesystem::absolute quando fornece o comportamento necessário.

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

As funções retornam um nome de caminho absoluto que tem em conta, conforme necessário, o diretório atual associado ao seu nome raiz. Para POSIX, as funções retornam absolute(pval).

`temp_directory_path`

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

As funções devolvem um nome de caminho para um diretório adequado para conter ficheiros temporários.

`u8path`

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

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

A primeira função comporta-se da mesma forma e path(source) a segunda função comporta-se da mesma forma, path(first, last) exceto que a fonte escolhida em cada caso é tomada como uma sequência de elementos char codificados como UTF-8, independentemente do sistema de ficheiros.

Ver também

<experimental/filesystem>
<experimental/filesystem> Enumerações
<experimental/filesystem> Operadores

Comentários

Esta página foi útil?

Última atualização a 2026-08-31

<experimental/filesystem> funções

Requisitos

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