<filesystem> funzioni

Queste funzioni gratuite nell'intestazione C++17 <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++)).

Annotazioni

Questo articolo illustra le funzioni C++17 std::filesystem . Per le funzioni prendard cronologiche fornite da MSVC in <experimental/filesystem>, vedere <experimental/filesystem> funzioni.

Requirements

Intestazione:<filesystem>

Spazio dei nomi:std::filesystem

absolute

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

Le funzioni costituiscono un percorso assoluto che fa riferimento allo stesso percorso del file system di pval, in base alla semantica del sistema operativo. Overload che restituisce ecpath() se si verifica un errore.

begin

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

Entrambe le funzioni restituiscono iter. endInsieme a , abilitano cicli basati su for intervalli su un directory_iterator oggetto o recursive_directory_iterator.

canonical

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

Le funzioni convertono pval, che devono esistere, in un percorso assoluto che fa riferimento allo stesso oggetto file system e non dispone di elementi simbolici, punto o punto-punto. Overload che restituisce ecpath() se si verifica un errore.

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 prima di tutto i file_status valori f per etper . Vengono usati symlink_status quando opts contiene copy_options::create_symlinks, copy_options::skip_symlinkso copy_options::copy_symlinks, come richiesto per l'origine o la destinazione. In caso contrario, usano status.

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

  • 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(from, to).

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

  • In caso contrario, se is_directory(t), allora copy_file(from, to / from.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&) noexcept;
recursive_directory_iterator end(const recursive_directory_iterator&) 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) && stat.type() != file_type::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(status(pval)).

is_empty

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

Le funzioni impostano le autorizzazioni per il percorso scelto da pval a sotto mask & perms::mask il controllo di opts. opts deve contenere esattamente uno di perm_options::replace, perm_options::addo e perm_options::removefacoltativamente perm_options::nofollow. Gli overload senza opts parametri si comportano come se opts fosse perm_options::replace.

Se opts & perm_options::add, le funzioni impostano le autorizzazioni su status(pval).permissions() | (mask & perms::mask). In caso contrario, se opts & perm_options::remove, le funzioni impostano le autorizzazioni su status(pval).permissions() & ~(mask & perms::mask). In caso contrario, le funzioni impostano le autorizzazioni su mask & perms::mask. Se opts & perm_options::nofollow e pval assegna un nome a un collegamento simbolico, le funzioni modificano le autorizzazioni del collegamento simbolico stesso anziché il file in cui viene risolto.

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

Il primo overload restituisce proximate(p, current_path(), ec). Gli altri overload restituiscono il risultato dell'applicazione lexically_proximate alle forme canoniche deboli di p e base. Overload che restituisce ecpath() se si verifica un errore.

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

Il primo overload restituisce relative(p, current_path(), ec). Gli altri overload restituiscono il risultato dell'applicazione lexically_relative alle forme canoniche deboli di p e base. Overload che restituisce ecpath() se si verifica un errore.

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

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

Queste funzioni restituiscono un percorso in formato canonico, ad esempio la canonical funzione, ma il percorso non deve esistere.

Vedere anche

Riferimento file di intestazione
<filesystem>
Navigazione nel file system (C++)

  • Last updated on