funzioni <experimental/filesystem>

Importante

L'intestazione <experimental/filesystem> e lo std::experimental::filesystem spazio dei nomi hanno fornito un'implementazione prendard della specifica tecnica del file system . Questa documentazione viene conservata per il codice scritto nell'implementazione originale del file system di MSVC, che è stata rimossa a partire da MSVC versione 14.51. Per il nuovo codice, usare invece l'intestazione C++17 <filesystem> e lo std::filesystem spazio dei nomi . Per gli equivalenti standard di queste funzioni, vedere <filesystem> Funzioni.

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

Requirements

Intestazione:<experimental/filesystem>

Spazio dei nomi:std::experimental::filesystem

absolute

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

La funzione restituisce il pathname assoluto corrispondente a pval relativo al pathname 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 restituiscepval.relative_path()absolute(base).relative_path()absolute(base).root_directory() / pval.root_name() / / .

  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. Sostituire ogni componente X di percorso per il quale is_symlink(X) è true con read_symlink(X).

  2. Rimuovere ogni componente . del percorso (punto è la directory corrente stabilita dai componenti del percorso precedenti).

  3. Rimuovere ogni coppia di componenti X/.. del percorso (dot-dot è la directory padre stabilita dai componenti di percorso precedenti).

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 al from controllo to di opts, che viene considerato come copy_options::none per gli overload senza opts parametri. opts deve contenere al massimo uno dei seguenti elementi:

  • 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 file_status valori f per from e t per to. 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), le funzioni segnalano un errore e si arresta. In caso contrario, se is_symlink(f), allora:

  • 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 fare nulla.

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 possono copiare il file in in fromto 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 from nel file to. Segnalare come errore se il tentativo di copia ha esito negativo.

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

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. 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 in base alle esigenze. Restituisce true solo se crea effettivamente la directory pval. Se si specifica il attr parametro , la funzione copia le autorizzazioni dal file esistente. Se non si specifica il attr parametro , la funzione usa perms::all.

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 link come collegamento simbolico alla directory to.

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 link come collegamento rigido alla directory o al file to.

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

Le funzioni senza parametro pval restituiscono il pathname per la 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 fanno riferimento alla 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);
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 contiene 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.

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 contenente il collegamento simbolico.

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 from in to. 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.

system_complete

Annotazioni

C++17 std::filesystem non fornisce system_complete. Per il codice corrente, usare std::filesystem::absolute quando fornisce il comportamento richiesto.

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

Le funzioni restituiscono un percorso assoluto che prende in considerazione, se necessario, la directory corrente associata al 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 adatta per contenere 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.

Vedere anche

<experimental/filesystem>
<experimental/filesystem> enumerazioni
<experimental/filesystem> operatori

  • Last updated on