<filesystem> funções

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

Requisitos

Cabeçalho:<filesystem>

Espaço de nomes:std::filesystem

absolute

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

As funções compõem um caminho absoluto que se refere à mesma localização do sistema de ficheiros que pval, de acordo com a semântica do sistema operativo. A sobrecarga que toma ec retorna path() se ocorrer um erro.

begin

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

Ambas as funções retornam iter. Juntamente com end, permitem loops baseados for em intervalos sobre um directory_iterator ou recursive_directory_iterator.

canonical

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

As funções convertem pval, que deve existir, num caminho absoluto que se refere ao mesmo objeto do sistema de ficheiros e não tem elementos simbólicos de ligação, ponto ou ponto-ponto. A sobrecarga que toma ec retorna path() se ocorrer um erro.

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;

Todas as funções possivelmente copiar ou vincular um ou mais arquivos de parasob controle de opts, que é tomado como copy_options::none para as sobrecargas sem opts parâmetro. opts deve conter, no máximo, um dos seguintes elementos:

• 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 fpara de e t para para. 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), eles então relatam um erro (e não fazem mais nada).

Caso contrário, em is_symlink(f) caso afirmativo:

• Se options & copy_options::skip_symlinks, então não faça 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ça 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ça 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 todas possivelmente copiar o arquivo de parasob controle de opts, que é tomado como copy_options::none para as sobrecargas sem opts parâmetro. opts deve conter, no máximo, um dos skip_existing, overwrite_existingou update_existing.

Se exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), informe como um erro que o arquivo 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)), tente copiar o conteúdo e os atributos do arquivo de para o arquivo. Informe como um erro se a tentativa de cópia falhar.

As funções retornam true se a cópia for tentada e for bem-sucedida, caso contrário 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;

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 conforme necessário. Ele retorna true somente se ele realmente cria 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. Ele retorna true somente se ele realmente cria o diretório pval, caso em que ele copia permissões do arquivo attrexistente , ou usa perms::all para as sobrecargas sem attr parâmetro.

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 link como um link simbólico para o diretório para.

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 link como um link físico para o diretório ou arquivo para.

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 link como um link simbólico para o arquivo para.

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 como 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 somente se a esquerda e a direita escolherem a mesma entidade do sistema de arquivos.

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 retorna 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 arquivo escolhido por pval, se exists(pval) && is_regular_file(pval) e o tamanho do arquivo pode ser determinado. Caso contrário, eles relatam um erro e retornam 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 retorna o número de links físicos para pval, ou -1 se ocorrer um erro.

hash_value

size_t hash_value(const path& pval) noexcept;

A função retorna 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 retorna stat.type() == file_type::block. As restantes funções regressam 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 retorna stat.type() == file_type::character. As restantes funções regressam 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 retorna stat.type() == file_type::directory. As restantes funções regressam 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), então a função retorna directory_iterator(pval) == directory_iterator(), caso contrário, ela 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 retorna stat.type() == file_type::fifo. As restantes funções regressam 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 retorna exists(stat) && !is_regular_file(stat) && !is_directory(stat) && !is_symlink(stat). As restantes funções regressam 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 retorna stat.type() == file_type::regular. As restantes funções regressam 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 retorna stat.type() == file_type::socket. As restantes funções regressam 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 retorna stat.type() == file_type::symlink. As restantes funções regressam 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 a hora da última modificação de dados para pval, ou file_time_type(-1) se ocorrer um erro. As duas últimas funções definem a hora da última modificação de dados para 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);

As funções definem as permissões para o nome do caminho escolhido por pval para mask & perms::mask sob controle do opts. opts deve conter exatamente um de perm_options::replace, perm_options::add, ou perm_options::remove, e opcionalmente perm_options::nofollow. As sobrecargas sem parâmetro opts comportam-se como se opts fosse perm_options::replace.

Se opts & perm_options::add, as funções definem as permissões como status(pval).permissions() | (mask & perms::mask). Caso contrário, se opts & perm_options::remove, as funções definem as permissões como status(pval).permissions() & ~(mask & perms::mask). Caso contrário, as funções definem as permissões como mask & perms::mask. Se opts & perm_options::nofollow e pval nomeia uma ligação simbólica, as funções alteram as permissões da ligação simbólica em si, em vez do ficheiro para o qual se resolve.

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

A primeira sobrecarga retorna proximate(p, current_path(), ec). As outras sobrecargas retornam o resultado de aplicar lexically_proximate às formas fracamente canónicas de p e base. A sobrecarga que toma ec retorna path() se ocorrer um erro.

read_symlink

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

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

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

A primeira sobrecarga retorna relative(p, current_path(), ec). As outras sobrecargas retornam o resultado de aplicar lexically_relative às formas fracamente canónicas de p e base. A sobrecarga que toma ec retorna path() se ocorrer um erro.

remove

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

As funções retornam true somente se exists(symlink_status(pval)) e o arquivo for removido com êxito. Um link simbólico é removido, não o arquivo escolhido.

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, então a entrada em si. Caso contrário, as funções chamam remove. Eles retornam uma contagem de todos os elementos removidos com êxito.

rename

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

As funções mudam de nome de para para. Um link simbólico é renomeado, não o arquivo escolhido.

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 retorna informações sobre o volume escolhido por pval, em uma estrutura do 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 status do nome do caminho, o tipo de arquivo e as permissões, associadas ao pval. Um link simbólico em si não é testado, mas o arquivo que ele 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 retornam o status do link simbólico pathname, o tipo de arquivo e as permissões, associadas ao pval. As funções se comportam da mesma forma status(pval) , exceto que um link simbólico é testado, não o arquivo escolhido.

temp_directory_path

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

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

u8path

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

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

A primeira função se comporta da mesma forma path(source) e a segunda função se comporta 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, seja qual for o sistema de arquivos.

weakly_canonical

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

Estas funções devolvem um caminho em forma canónica, como a canonical função, mas o caminho não precisa de existir.

Ver também

de referência de arquivos de cabeçalho
<filesystem>
Navegação do Sistema de Ficheiros (C++)