Condividi tramite

<filesystem> funzioni

  • Articolo

Queste funzioni libere nell'intestazione <filesystem> eseguono operazioni di modifica e query su percorsi, file, collegamenti simbolici, directory e volumi. Per altre informazioni ed esempi di codice, vedere File System Navigation (C++) (Esplorazione del file system (C++)).

absolute

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

La funzione restituisce il percorso assoluto corrispondente a pval relativo al percorso base:

  1. Se pval.has_root_name() && pval.has_root_directory(), la funzione restituisce pval.

  2. Se pval.has_root_name() && !pval.has_root_directory(), la funzione restituisce pval.root_name() / absolute(base).root_directory() / absolute(base).relative_path() / pval.relative_path().

  3. Se !pval.has_root_name() && pval.has_root_directory(), la funzione restituisce absolute(base).root_name() / pval.

  4. Se !pval.has_root_name() && !pval.has_root_directory(), la funzione restituisce absolute(base) / pval.

begin

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

Entrambe le funzioni restituiscono 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);

Tutte le funzioni formano un percorso pabs = absolute(pval, base) assoluto (o pabs = absolute(pval) per l'overload senza parametro di base), quindi ridurlo a una forma canonica nella sequenza di passaggi seguente:

  1. Ogni componente X di percorso per il quale is_symlink(X) viene true sostituito da read_symlink(X).

  2. Ogni componente . del percorso (punto è la directory corrente stabilita dai componenti di percorso precedenti) viene rimosso.

  3. Ogni coppia di componenti X/.. di percorso (dot-dot è la directory padre stabilita dai componenti di percorso precedenti) viene rimossa.

La funzione restituisce pabsquindi .

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;

Tutte le funzioni possono copiare o collegare uno o più file da a a sotto controllo di opts, che viene preso come copy_options::none per gli overload senza opts parametri. opts conterrà al massimo uno di:

  • skip_existing, overwrite_existing o update_existing

  • copy_symlinks oppure skip_symlinks

  • directories_only, create_symlinks o create_hard_links

Le funzioni determinano innanzitutto i valori f di file_status da e t per:

  • se opts & (copy_options::create_symlinks | copy_options::skip_symlinks), chiamando symlink_status

  • in caso contrario, chiamando status

  • In caso contrario, segnalare un errore.

Se !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), segnalano un errore (e non fanno altro).

In caso contrario, se is_symlink(f) :

  • Se options & copy_options::skip_symlinks, non eseguire alcuna operazione.

  • In caso contrario, se !exists(t)&& options & copy_options::copy_symlinks, allora copy_symlink(from, to, opts).

  • In caso contrario, segnalare un errore.

In caso contrario, se is_regular_file(f), allora:

  • Se opts & copy_options::directories_only, non eseguire alcuna operazione.

  • In caso contrario, se opts & copy_options::create_symlinks, allora create_symlink(to, from).

  • In caso contrario, se opts & copy_options::create_hard_links, allora create_hard_link(to, from).

  • In caso contrario, se is_directory(f), allora / copy_file(from, tofrom.filename(), opts) .

  • In caso contrario, copy_file(from, to, opts).

In caso contrario, se is_directory(f) && (opts & copy_options::recursive || !opts), allora:

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

In caso contrario, non eseguire alcuna azione.

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;

Tutte le funzioni copiano il file da a a sotto controllo di opts, che viene considerato come copy_options::none per gli overload senza opts parametri. opts deve contenere al massimo uno di skip_existing, overwrite_existingo update_existing.

Se exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), segnalare come errore che il file esiste già.

In caso contrario, 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)), tentare di copiare il contenuto e gli attributi del file da al file in . Segnalare come errore se il tentativo di copia non riesce.

Le funzioni restituiscono true se la copia viene tentata e ha esito positivo; in caso contrario false, .

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), la funzione chiama create_directory_symlink(from, to). In caso contrario, chiama create_symlink(from, to).

create_directories

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

Per un percorso come a\/b\/c, la funzione crea directory a e a\/b in base alle esigenze in modo che possa creare la directory a\/b\/c in base alle esigenze. Restituisce true solo se crea effettivamente la directory 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 funzione crea la directory pval come necessario. Restituisce true solo se crea effettivamente la directory pval, nel qual caso copia le autorizzazioni dal file attresistente o usa perms::all per gli overload senza attr parametri.

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 funzione crea un collegamento come collegamento simbolico alla directory a.

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 funzione crea un collegamento come collegamento rigido alla directory o al file.

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

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

La funzione crea link come collegamento simbolico al file.

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;

Le funzioni senza parametro pval restituiscono il percorso della directory corrente. Le funzioni rimanenti impostano la directory corrente su pval.

end

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

La prima funzione restituisce directory_iterator() e la seconda funzione restituisce recursive_directory_iterator()

equivalent

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

Le funzioni restituiscono true solo se sinistra e destra scelgono la stessa entità del file system.

exists

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

La prima funzione restituisce status_known && stat.type() != file_not_found. La seconda e la terza funzione restituiscono exists(status(pval)).

file_size

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

Le funzioni restituiscono le dimensioni in byte del file scelto da pval, se exists(pval) && is_regular_file(pval) e le dimensioni del file possono essere determinate. In caso contrario, segnalano un errore e restituiscono uintmax_t(-1).

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

La funzione restituisce il numero di collegamenti rigidi per pvalo -1 se si verifica un errore.

hash_value

size_t hash_value(const path& pval) noexcept;

La funzione restituisce un valore hash per 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 prima funzione restituisce stat.type() == file_type::block. Le funzioni rimanenti restituiscono 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 prima funzione restituisce stat.type() == file_type::character. Le funzioni rimanenti restituiscono 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 prima funzione restituisce stat.type() == file_type::directory. Le funzioni rimanenti restituiscono 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;

Se is_directory(pval), la funzione restituisce directory_iterator(pval) == directory_iterator(). In caso contrario, restituisce 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 prima funzione restituisce stat.type() == file_type::fifo. Le funzioni rimanenti restituiscono 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 prima funzione restituisce stat.type() == file_type::other. Le funzioni rimanenti restituiscono 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 prima funzione restituisce stat.type() == file_type::regular. Le funzioni rimanenti restituiscono 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 prima funzione restituisce stat.type() == file_type::socket. Le funzioni rimanenti restituiscono 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 prima funzione restituisce stat.type() == file_type::symlink. Le funzioni rimanenti restituiscono 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;

Le prime due funzioni restituiscono l'ora dell'ultima modifica dei dati per pvalo file_time_type(-1) se si verifica un errore. Le ultime due funzioni impostano l'ora dell'ultima modifica dei dati per pval su new_time.

permissions

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

Le funzioni impostano le autorizzazioni per il percorso scelto da pval a sotto mask & perms::mask il controllo di perms & (perms::add_perms | perms::remove_perms). mask deve contenere al massimo uno di perms::add_perms e perms::remove_perms.

Se mask & perms::add_perms, le funzioni impostano le autorizzazioni su status(pval).permissions() | mask & perms::mask. In caso contrario, se mask & perms::remove_perms, le funzioni impostano le autorizzazioni su status(pval).permissions() & ~(mask & perms::mask). In caso contrario, le funzioni impostano le autorizzazioni su mask & perms::mask.

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

Le funzioni segnalano un errore e restituiscono path() se !is_symlink(pval). In caso contrario, le funzioni restituiscono un oggetto di tipo path che contiene il collegamento simbolico.

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;

Le funzioni restituiscono true solo se exists(symlink_status(pval)) e il file viene rimosso correttamente. Un collegamento simbolico viene rimosso, non il file scelto.

remove_all

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

Se pval è una directory, le funzioni rimuovono in modo ricorsivo tutte le voci di directory, quindi la voce stessa. In caso contrario, le funzioni chiamano remove. Restituiscono un conteggio di tutti gli elementi rimossi correttamente.

rename

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

Le funzioni rinominano da a a. Un collegamento simbolico viene rinominato, non il file scelto.

resize_file

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

Le funzioni modificano le dimensioni di un file in modo che file_size(pval) == size

space

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

La funzione restituisce informazioni sul volume scelto da pval, in una struttura di tipo space_info. La struttura contiene uintmax_t(-1) per qualsiasi valore che non può essere determinato.

status

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

Le funzioni restituiscono lo stato del percorso, il tipo di file e le autorizzazioni associate a pval. Un collegamento simbolico non viene testato, ma il file scelto.

status_known

bool status_known(file_status stat) noexcept;

La funzione restituisce stat.type() != file_type::none

swap

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

La funzione scambia il contenuto di sinistra e destra.

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

Le funzioni restituiscono lo stato del collegamento simbolico pathname, il tipo di file e le autorizzazioni associate a pval. Le funzioni si comportano allo stesso modo, status(pval) ad eccezione del fatto che un collegamento simbolico viene testato, non il file scelto.

system_complete

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

Le funzioni restituiscono un percorso assoluto che tiene conto, se necessario, della directory corrente associata con il nome radice. Per POSIX, le funzioni restituiscono absolute(pval).

temp_directory_path

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

Le funzioni restituiscono un percorso per una directory appropriata per contenere i file temporanei.

u8path

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

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

La prima funzione si comporta come e la seconda funzione si comporta allo stesso path(source) modo, path(first, last) ad eccezione del fatto che l'origine scelta in ogni caso viene considerata come una sequenza di elementi char codificati come UTF-8, indipendentemente dal file system.

weakly_canonical

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