`<filesystem>` – funkce

Článek
10/12/2023

Tyto bezplatné funkce v <filesystem> hlavičce upravují a dotazují operace s cestami, soubory, symlinky, adresáře a svazky. Další informace a příklady kódu najdete v tématu Navigace v systému souborů (C++).

`absolute`

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

Funkce vrátí absolutní název cesty odpovídající pval relativnímu názvu cesty base:

Pokud pval.has_root_name() && pval.has_root_directory() funkce vrátí pvalhodnotu .
Pokud pval.has_root_name() && !pval.has_root_directory() funkce vrátíabsolute(base).relative_path() / pval.relative_path()pval.root_name()absolute(base).root_directory() / / hodnotu .
Pokud !pval.has_root_name() && pval.has_root_directory() funkce vrátí absolute(base).root_name() / pvalhodnotu .
Pokud !pval.has_root_name() && !pval.has_root_directory() funkce vrátí absolute(base) / pvalhodnotu .

`begin`

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

Obě funkce vrací 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);

Všechny funkce tvoří absolutní název pabs = absolute(pval, base) cesty (nebo pabs = absolute(pval) pro přetížení bez základního parametru) a pak je zmenší na kanonický formulář v následujícím pořadí kroků:

Každá komponenta X cesty, pro kterou is_symlink(X) je true nahrazena read_symlink(X).
Odebere se každá komponenta . cesty (tečka je aktuální adresář vytvořený komponentami předchozí cesty).
Odeberou se všechny dvojice komponent X/.. cesty (dot-dot je nadřazený adresář vytvořený předchozími komponentami cesty).

Funkce pak vrátí pabs.

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

Všechny funkce mohou kopírovat nebo propojit jeden nebo více souborů od do pod kontrolou opts, který se bere jako copy_options::none pro přetížení bez opts parametru. opts musí obsahovat nejvýše jednu z těchto:

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

Funkce nejprve určují file_status hodnoty f z a t do:

if opts & (copy_options::create_symlinks | copy_options::skip_symlinks), voláním symlink_status
jinak zavoláním status
V opačném případě nahlaste chybu.

Pokud !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), pak nahlásí chybu (a nic jiného).

V opačném případě pokud is_symlink(f) pak:

Pokud options & copy_options::skip_symlinks, pak nic nedělejte.
Jinak, pokud !exists(t)&& options & copy_options::copy_symlinks, pak copy_symlink(from, to, opts).
V opačném případě nahlaste chybu.

Jinak pokud is_regular_file(f), pak:

Pokud opts & copy_options::directories_only, pak nic nedělejte.
Jinak, pokud opts & copy_options::create_symlinks, pak create_symlink(to, from).
Jinak, pokud opts & copy_options::create_hard_links, pak create_hard_link(to, from).
Jinak, pokud is_directory(f), pak copy_file(from, to / from.filename(), opts).
V opačném případě hodnota copy_file(from, to, opts).

Jinak pokud is_directory(f) && (opts & copy_options::recursive || !opts), pak:

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

V opačném případě nic nedělejte.

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

Všechny funkce pravděpodobně zkopírují soubor z do pod kontrolou opts, který se bere jako copy_options::none pro přetížení bez opts parametru. opts musí obsahovat nejvýše jeden z skip_existing, overwrite_existingnebo update_existing.

Pokud exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), pak nahlásit jako chybu, že soubor již existuje.

V opačném případě 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))pokuste zkopírovat obsah a atributy souboru z souboru do souboru. Pokud se pokus o kopírování nezdaří, nahlaste jako chybu.

Funkce se vrátí true , pokud dojde k pokusu o kopírování a úspěšně, jinak 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;

If is_directory(from), funkce volá create_directory_symlink(from, to). V opačném případě volá create_symlink(from, to).

`create_directories`

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

Pro název cesty, například a\/b\/c, funkce vytvoří adresáře a a a\/b podle potřeby, aby mohl vytvořit adresář a\/b\/c podle potřeby. Vrátí true pouze v případě, že ve skutečnosti vytvoří adresář 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;

Funkce podle potřeby vytvoří adresář pval . true Vrátí pouze v případě, že skutečně vytvoří adresář pval, v takovém případě zkopíruje oprávnění z existujícího souboru attr, nebo používá perms::all pro přetížení bez attr parametru.

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

Funkce vytvoří odkaz jako symlink k adresáři.

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

Funkce vytvoří odkaz jako pevný odkaz na adresář nebo soubor.

`create_symlink`

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

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

Funkce se vytvoří link jako symlink k souboru.

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

Funkce bez parametru pval vrací název cesty pro aktuální adresář. Zbývající funkce nastavily aktuální adresář na pval.

`end`

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

První funkce se vrátí directory_iterator() a druhá funkce vrátí. recursive_directory_iterator()

`equivalent`

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

Funkce se vrátí true pouze v případě, že vlevo a vpravo zvolí stejnou entitu systému souborů.

`exists`

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

První funkce vrátí status_known && stat.type() != file_not_found. Druhá a třetí funkce vrátí exists(status(pval)).

`file_size`

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

Funkce vrátí velikost v bajtech vybraného souboru pval, pokud exists(pval) && is_regular_file(pval) a velikost souboru lze určit. Jinak nahlásí chybu a vrátí 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;

Funkce vrátí počet pevných propojení pro pval, nebo -1, pokud dojde k chybě.

`hash_value`

size_t hash_value(const path& pval) noexcept;

Funkce vrátí hodnotu hash pro 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;

První funkce vrátí stat.type() == file_type::block. Zbývající funkce vrátí 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;

První funkce vrátí stat.type() == file_type::character. Zbývající funkce vrátí 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;

První funkce vrátí stat.type() == file_type::directory. Zbývající funkce vrátí 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;

Pokud is_directory(pval)funkce vrátí directory_iterator(pval) == directory_iterator()hodnotu , v opačném případě vrátí 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;

První funkce vrátí stat.type() == file_type::fifo. Zbývající funkce vrátí 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;

První funkce vrátí stat.type() == file_type::other. Zbývající funkce vrátí 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;

První funkce vrátí stat.type() == file_type::regular. Zbývající funkce vrátí 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;

První funkce vrátí stat.type() == file_type::socket. Zbývající funkce vrátí 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;

První funkce vrátí stat.type() == file_type::symlink. Zbývající funkce vrátí 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;

První dvě funkce vrátí čas poslední úpravy dat pro pval, nebo file_time_type(-1) pokud dojde k chybě. Poslední dvě funkce nastaví čas poslední úpravy dat na pval new_timehodnotu .

`permissions`

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

Funkce nastavují oprávnění pro název cesty zvolený pval pod mask & perms::mask kontrolou perms & (perms::add_perms | perms::remove_perms). mask musí obsahovat nejvýše jednu z perms::add_perms a perms::remove_perms.

Pokud mask & perms::add_perms, funkce nastaví oprávnění na status(pval).permissions() | mask & perms::mask. V opačném případě funkce mask & perms::remove_permsnastavily oprávnění na status(pval).permissions() & ~(mask & perms::mask). V opačném případě funkce nastavily oprávnění na 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);

`read_symlink`

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

Funkce hlásí chybu a vrátí path() , pokud !is_symlink(pval). V opačném případě funkce vrátí objekt typu path obsahující symbolický odkaz.

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

Funkce vrátí true pouze v případě exists(symlink_status(pval)) , že se soubor úspěšně odebere. Symlink se odebere, ne soubor, který zvolí.

`remove_all`

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

Pokud pval je adresář, funkce rekurzivně odeberou všechny položky adresáře a pak samotnou položku. V opačném případě funkce volají remove. Vrátí počet všech prvků, které byly úspěšně odebrány.

`rename`

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

Funkce přejmenovávat z na. Symlink se sám přejmenuje, ne soubor, který zvolí.

`resize_file`

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

Funkce mění velikost souboru tak, aby file_size(pval) == size

`space`

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

Funkce vrátí informace o svazku zvoleném pvalfunkcí ve struktuře typu space_info. Struktura obsahuje uintmax_t(-1) libovolnou hodnotu, kterou nelze určit.

`status`

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

Funkce vrátí stav názvu cesty, typ souboru a oprávnění přidružená .pval Symlink není sám otestovaný, ale soubor, který zvolí.

`status_known`

bool status_known(file_status stat) noexcept;

Funkce vrátí stat.type() != file_type::none

`swap`

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

Funkce vyměňuje obsah zleva a doprava.

`symlink_status`

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

Funkce vrátí stav pathname symlink, typ souboru a oprávnění přidružená pval. Funkce se chovají stejně jako status(pval) v případě, že se testuje symlink, nikoli soubor, který zvolí.

`system_complete`

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

Funkce vrátí absolutní název cesty, který podle potřeby bere v úvahu aktuální adresář přidružený k jeho kořenovému názvu. (Pro POSIX vrátí absolute(pval)funkce ).

`temp_directory_path`

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

Funkce vrací název cesty pro adresář vhodný pro obsah dočasných souborů.

`u8path`

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

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

První funkce se chová stejně jako path(source) druhá a druhá funkce se chová stejně jako path(first, last) s tím rozdílem, že zvolený zdroj v každém případě se bere jako posloupnost prvků char kódovaných jako UTF-8, bez ohledu na systém souborů.

`weakly_canonical`

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

Sdílet prostřednictvím

<filesystem> – funkce

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

proximate

read_symlink

relative

remove

remove_all

rename

resize_file

space

status

status_known

swap

symlink_status

system_complete

temp_directory_path

u8path

weakly_canonical

Váš názor

Další materiály