`<filesystem>`, funkcje

Artykuł
10/12/2023

Te bezpłatne funkcje w nagłówku <filesystem> wykonują operacje modyfikowania i wykonywania zapytań na ścieżkach, plikach, linkach, katalogach i woluminach. Aby uzyskać więcej informacji i przykłady kodu, zobacz Nawigacja systemu plików (C++).

`absolute`

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

Funkcja zwraca bezwzględną nazwę ścieżki odpowiadającą pval wartości względem nazwy pathname base:

Jeśli pval.has_root_name() && pval.has_root_directory() funkcja zwróci pvalwartość .
Jeśli pval.has_root_name() && !pval.has_root_directory() funkcja zwróciabsolute(base).relative_path() / pval.relative_path()pval.root_name()absolute(base).root_directory() / / wartość .
Jeśli !pval.has_root_name() && pval.has_root_directory() funkcja zwróci absolute(base).root_name() / pvalwartość .
Jeśli !pval.has_root_name() && !pval.has_root_directory() funkcja zwróci absolute(base) / pvalwartość .

`begin`

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

Obie funkcje zwracają wartość 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);

Wszystkie funkcje tworzą bezwzględną nazwę pabs = absolute(pval, base) ścieżki (lub pabs = absolute(pval) przeciążenie bez parametru podstawowego), a następnie zmniejsz je do postaci kanonicznej w następującej sekwencji kroków:

Każdy składnik X ścieżki, dla którego is_symlink(X) jest true zastępowany przez read_symlink(X)element .
Każdy składnik . ścieżki (kropka to bieżący katalog ustanowiony przez poprzednie składniki ścieżki) jest usuwany.
Każda para składników X/.. ścieżki (dot-dot to katalog nadrzędny ustanowiony przez poprzednie składniki ścieżki) jest usuwany.

Następnie funkcja zwraca wartość 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;

Wszystkie funkcje mogą kopiować lub łączyć co najmniej jeden plik z do pod kontrolą opts, który jest traktowany jako copy_options::none przeciążenia bez opts parametru. opts zawiera co najwyżej jedną z:

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

Funkcje najpierw określają file_status wartości f od i t dla:

if opts & (copy_options::create_symlinks | copy_options::skip_symlinks), wywołując polecenie symlink_status
w przeciwnym razie przez wywołanie polecenia status
W przeciwnym razie zgłoś błąd.

Jeśli !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), zgłaszają błąd (i nic innego nie robią).

W przeciwnym razie, jeśli is_symlink(f) :

Jeśli options & copy_options::skip_symlinks, nie rób nic.
W przeciwnym razie, jeśli !exists(t)&& options & copy_options::copy_symlinks, to copy_symlink(from, to, opts).
W przeciwnym razie zgłoś błąd.

W przeciwnym razie, jeśli is_regular_file(f), to:

Jeśli opts & copy_options::directories_only, nie rób nic.
W przeciwnym razie, jeśli opts & copy_options::create_symlinks, to create_symlink(to, from).
W przeciwnym razie, jeśli opts & copy_options::create_hard_links, to create_hard_link(to, from).
W przeciwnym razie, jeśli is_directory(f), to / copy_file(from, tofrom.filename(), opts) .
W przeciwnym razie wartość copy_file(from, to, opts).

W przeciwnym razie, jeśli is_directory(f) && (opts & copy_options::recursive || !opts), to:

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

W przeciwnym razie nic nie rób.

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

Wszystkie funkcje mogą kopiować plik z do do pod kontrolą opts, który jest traktowany jako copy_options::none przeciążenia bez opts parametru. opts zawiera co najwyżej jedną z skip_existingwartości , overwrite_existinglub update_existing.

Jeśli exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing))wartość , zgłoś jako błąd, że plik już istnieje.

W przeciwnym razie, jeśli !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)), spróbuj skopiować zawartość i atrybuty pliku z do pliku. Zgłoś błąd, jeśli próba kopiowania nie powiedzie się.

Funkcje zwracają true , jeśli kopia zostanie podjęta i zakończy się powodzeniem, w przeciwnym razie 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;

Jeśli is_directory(from)funkcja wywołuje funkcję create_directory_symlink(from, to). W przeciwnym razie wywołuje metodę create_symlink(from, to).

`create_directories`

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

W przypadku nazwy ścieżki, takiej jak a\/b\/c, funkcja tworzy katalogi i a\/b zgodnie z potrzebamia, aby można było utworzyć katalog a\/b\/c zgodnie z potrzebami. Zwraca tylko true wtedy, gdy faktycznie tworzy katalog 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;

Funkcja tworzy katalog pval zgodnie z potrzebami. Jest zwracany true tylko wtedy, gdy faktycznie tworzy katalog pval, w tym przypadku kopiuje uprawnienia z istniejącego pliku attrlub używa perms::all dla przeciążeń 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;

Funkcja tworzy link jako symlink do katalogu.

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

Funkcja tworzy łącze jako twarde łącze do katalogu lub pliku.

`create_symlink`

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

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

Funkcja tworzy link jako symlink do pliku.

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

Funkcje bez parametru pval zwracają nazwę ścieżki dla bieżącego katalogu. Pozostałe funkcje ustawiają bieżący katalog na pvalwartość .

`end`

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

Pierwsza funkcja zwraca directory_iterator() wartość , a druga funkcja zwraca recursive_directory_iterator()

`equivalent`

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

Funkcje zwracają true tylko wtedy, gdy po lewej i prawej stronie wybierz tę samą jednostkę systemu plików.

`exists`

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

Pierwsza funkcja zwraca wartość status_known && stat.type() != file_not_found. Drugie i trzecie funkcje zwracają wartość exists(status(pval)).

`file_size`

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

Funkcje zwracają rozmiar w bajtach pliku wybranego przez pval, jeśli exists(pval) && is_regular_file(pval) i rozmiar pliku można określić. W przeciwnym razie zgłaszają błąd i zwracają wartość 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;

Funkcja zwraca liczbę twardych łączy dla pval, lub -1, jeśli wystąpi błąd.

`hash_value`

size_t hash_value(const path& pval) noexcept;

Funkcja zwraca wartość skrótu dla pval.native()elementu .

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

Pierwsza funkcja zwraca wartość stat.type() == file_type::block. Pozostałe funkcje zwracają wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::character. Pozostałe funkcje zwracają wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::directory. Pozostałe funkcje zwracają wartość 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;

Jeśli is_directory(pval)funkcja zwraca directory_iterator(pval) == directory_iterator()wartość , w przeciwnym razie zwraca wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::fifo. Pozostałe funkcje zwracają wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::other. Pozostałe funkcje zwracają wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::regular. Pozostałe funkcje zwracają wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::socket. Pozostałe funkcje zwracają wartość 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;

Pierwsza funkcja zwraca wartość stat.type() == file_type::symlink. Pozostałe funkcje zwracają wartość 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;

Pierwsze dwie funkcje zwracają czas ostatniej modyfikacji danych dla pvalelementu lub file_time_type(-1) , jeśli wystąpi błąd. Ostatnie dwie funkcje ustawiają czas ostatniej modyfikacji danych na pval wartość new_time.

`permissions`

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

Funkcje ustawiają uprawnienia dla nazwy pathname wybranej przez pval do mask & perms::mask kontroli nad elementem perms & (perms::add_perms | perms::remove_perms). mask zawiera co najwyżej jeden z perms::add_perms elementów i perms::remove_perms.

Jeśli mask & perms::add_permsfunkcja ustawi uprawnienia na status(pval).permissions() | mask & perms::maskwartość . W przeciwnym razie jeśli mask & perms::remove_permsfunkcje ustawią uprawnienia na status(pval).permissions() & ~(mask & perms::mask)wartość . W przeciwnym razie funkcje ustawiają uprawnienia 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);

Funkcje zgłaszają błąd i zwracają path() wartość , jeśli !is_symlink(pval). W przeciwnym razie funkcje zwracają obiekt typu path zawierającego łącze symboliczne.

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

Funkcje zwracają true tylko wtedy, gdy exists(symlink_status(pval)) plik zostanie pomyślnie usunięty. Sam symlink jest usuwany, a nie wybrany plik.

`remove_all`

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

Jeśli pval jest katalogiem, funkcje rekursywnie usuwają wszystkie wpisy katalogu, a następnie sam wpis. W przeciwnym razie funkcje wywołają metodę remove. Zwracają one liczbę wszystkich elementów pomyślnie usuniętych.

`rename`

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

Nazwa funkcji zmienia się z na. Sama nazwa łącza symlinku jest zmieniana, a nie wybrany plik.

`resize_file`

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

Funkcje zmieniają rozmiar pliku, tak aby file_size(pval) == size

`space`

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

Funkcja zwraca informacje o woluminie wybranym przez pvalelement w strukturze typu space_info. Struktura zawiera uintmax_t(-1) dowolną wartość, która nie może być określona.

`status`

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

Funkcje zwracają stan pathname, typ pliku i uprawnienia skojarzone z elementem pval. Sam symlink nie jest testowany, ale wybrany plik.

`status_known`

bool status_known(file_status stat) noexcept;

Funkcja zwraca stat.type() != file_type::none

`swap`

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

Funkcja wymienia zawartość lewej i prawej.

`symlink_status`

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

Funkcje zwracają stan symlinku pathname, typ pliku i uprawnienia skojarzone z pval. Funkcje zachowują się tak samo, jak status(pval) z tą różnicą, że sam link jest testowany, a nie wybrany plik.

`system_complete`

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

Funkcje zwracają bezwzględną nazwę ścieżki, która uwzględnia, w razie potrzeby, bieżący katalog skojarzony z jego nazwą główną. (W przypadku systemu POSIX funkcje zwracają wartość absolute(pval)).

`temp_directory_path`

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

Funkcje zwracają nazwę ścieżki dla katalogu odpowiedniego do przechowywania plików tymczasowych.

`u8path`

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

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

Pierwsza funkcja zachowuje się tak samo jak path(source) i druga funkcja zachowuje się tak samo, jak path(first, last) to, że wybrane źródło w każdym przypadku jest traktowane jako sekwencja elementów char zakodowanych jako UTF-8, niezależnie od systemu plików.

`weakly_canonical`

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

Udostępnij za pośrednictwem

<filesystem>, funkcje

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

Opinia

Dodatkowe zasoby