1. | If the path is empty, stop. |
2. | |
3. | [Note 4: The generic pathname grammar defines directory-separator as one or more slashes and preferred-separators. — end note] |
4. | Remove each dot filename and any immediately following directory-separator. |
5. | As long as any appear, remove a non-dot-dot filename immediately followed by a directory-separator and a dot-dot filename, along with any immediately following directory-separator. |
6. | If there is a root-directory, remove all dot-dot filenames and any directory-separators immediately following them. |
7. | If the last filename is dot-dot, remove any trailing directory-separator. |
8. | If the path is empty, add a dot. |
path() noexcept;
path(const path& p);
path(path&& p) noexcept;
path(string_type&& source, format fmt = auto_format);
template<class Source>
path(const Source& source, format fmt = auto_format);
template<class InputIterator>
path(InputIterator first, InputIterator last, format fmt = auto_format);
template<class Source>
path(const Source& source, const locale& loc, format fmt = auto_format);
template<class InputIterator>
path(InputIterator first, InputIterator last, const locale& loc, format fmt = auto_format);
path& operator=(const path& p);
path& operator=(path&& p) noexcept;
path& operator=(string_type&& source);
path& assign(string_type&& source);
template<class Source>
path& operator=(const Source& source);
template<class Source>
path& assign(const Source& source);
template<class InputIterator>
path& assign(InputIterator first, InputIterator last);
path& operator/=(const path& p);
template<class Source>
path& operator/=(const Source& source);
template<class Source>
path& append(const Source& source);
template<class InputIterator>
path& append(InputIterator first, InputIterator last);
path& operator+=(const path& x);
path& operator+=(const string_type& x);
path& operator+=(basic_string_view<value_type> x);
path& operator+=(const value_type* x);
template<class Source>
path& operator+=(const Source& x);
template<class Source>
path& concat(const Source& x);
path& operator+=(value_type x);
template<class EcharT>
path& operator+=(EcharT x);
template<class InputIterator>
path& concat(InputIterator first, InputIterator last);
void clear() noexcept;
path& make_preferred();
path& remove_filename();
path& replace_filename(const path& replacement);
path& replace_extension(const path& replacement = path());
void swap(path& rhs) noexcept;
const string_type& native() const noexcept;
const value_type* c_str() const noexcept;
operator string_type() const;
template<class EcharT, class traits = char_traits<EcharT>,
class Allocator = allocator<EcharT>>
basic_string<EcharT, traits, Allocator>
string(const Allocator& a = Allocator()) const;
std::string string() const;
std::wstring wstring() const;
std::u8string u8string() const;
std::u16string u16string() const;
std::u32string u32string() const;
template<class EcharT, class traits = char_traits<EcharT>,
class Allocator = allocator<EcharT>>
basic_string<EcharT, traits, Allocator>
generic_string(const Allocator& a = Allocator()) const;
std::string generic_string() const;
std::wstring generic_wstring() const;
std::u8string generic_u8string() const;
std::u16string generic_u16string() const;
std::u32string generic_u32string() const;
int compare(const path& p) const noexcept;
int compare(const string_type& s) const;
int compare(basic_string_view<value_type> s) const;
int compare(const value_type* s) const;
path root_name() const;
path root_directory() const;
path root_path() const;
path relative_path() const;
path parent_path() const;
path filename() const;
path stem() const;
path extension() const;
[[nodiscard]] bool empty() const noexcept;
bool has_root_path() const;
bool has_root_name() const;
bool has_root_directory() const;
bool has_relative_path() const;
bool has_parent_path() const;
bool has_filename() const;
bool has_stem() const;
bool has_extension() const;
bool is_absolute() const;
bool is_relative() const;
path lexically_normal() const;
path lexically_relative(const path& base) const;
path lexically_proximate(const path& base) const;
iterator begin() const;
iterator end() const;
template<class charT, class traits>
friend basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const path& p);
template<class charT, class traits>
friend basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, path& p);
void swap(path& lhs, path& rhs) noexcept;
size_t hash_value(const path& p) noexcept;
friend bool operator==(const path& lhs, const path& rhs) noexcept;
friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
friend path operator/(const path& lhs, const path& rhs);
filesystem_error(const string& what_arg, error_code ec);
filesystem_error(const string& what_arg, const path& p1, error_code ec);
filesystem_error(const string& what_arg, const path& p1, const path& p2, error_code ec);
const path& path1() const noexcept;
const path& path2() const noexcept;
const char* what() const noexcept override;
Name | Meaning | |
native_format | The native pathname format. | |
generic_format | The generic pathname format. | |
auto_format | The interpretation of the format of the character sequence is
implementation-defined. The implementation may inspect the content of the character sequence to
determine the format. Recommended practice: For POSIX-based systems, native and generic formats are equivalent
and the character sequence should always be interpreted in the same way. |
Constant | Meaning | |
none | The type of the file has not been determined or an error occurred while
trying to determine the type. | |
not_found | ||
regular | Regular file | |
directory | Directory file | |
symlink | Symbolic link file | |
block | Block special file | |
character | Character special file | |
fifo | FIFO or pipe file | |
socket | Socket file | |
unknown | The file exists but the type cannot be determined |
Option group controlling copy_file function effects for existing target files | ||
Constant | Meaning | |
none | (Default) Error; file already exists. | |
skip_existing | Do not overwrite existing file, do not report an error. | |
overwrite_existing | Overwrite the existing file. | |
update_existing | Overwrite the existing file if it is older than the replacement file. | |
Option group controlling copy function effects for subdirectories | ||
Constant | Meaning | |
none | (Default) Do not copy subdirectories. | |
recursive | Recursively copy subdirectories and their contents. | |
Option group controlling copy function effects for symbolic links | ||
Constant | Meaning | |
none | (Default) Follow symbolic links. | |
copy_symlinks | Copy symbolic links as symbolic links rather than copying the files that
they point to. | |
skip_symlinks | Ignore symbolic links. | |
Option group controlling copy function effects for choosing the form of copying | ||
Constant | Meaning | |
none | (Default) Copy content. | |
directories_only | Copy directory structure only, do not copy non-directory files. | |
create_symlinks | ||
create_hard_links | Make hard links instead of copies of files. |
Name | Value | POSIX | Definition or notes | |
(octal) | macro | |||
none | 0 | There are no permissions set for the file. | ||
owner_read | 0400 | S_IRUSR | Read permission, owner | |
owner_write | 0200 | S_IWUSR | Write permission, owner | |
owner_exec | 0100 | S_IXUSR | Execute/search permission, owner | |
owner_all | 0700 | S_IRWXU | Read, write, execute/search by owner; owner_read | owner_write | owner_exec | |
group_read | 040 | S_IRGRP | Read permission, group | |
group_write | 020 | S_IWGRP | Write permission, group | |
group_exec | 010 | S_IXGRP | Execute/search permission, group | |
group_all | 070 | S_IRWXG | Read, write, execute/search by group; group_read | group_write | group_exec | |
others_read | 04 | S_IROTH | Read permission, others | |
others_write | 02 | S_IWOTH | Write permission, others | |
others_exec | 01 | S_IXOTH | Execute/search permission, others | |
others_all | 07 | S_IRWXO | Read, write, execute/search by others; others_read | others_write | others_exec | |
all | 0777 | owner_all | group_all | others_all | ||
set_uid | 04000 | S_ISUID | Set-user-ID on execution | |
set_gid | 02000 | S_ISGID | Set-group-ID on execution | |
sticky_bit | 01000 | S_ISVTX | Operating system dependent. | |
mask | 07777 | all | set_uid | set_gid | sticky_bit | ||
unknown | 0xFFFF | The permissions are not known, such as when a file_status object
is created without specifying the permissions |
Name | Meaning | |
replace | permissions shall replace the file's permission bits with perm | |
add | permissions shall replace the file's permission bits with
the bitwise or of perm and the file's current permission bits. | |
remove | permissions shall replace the file's permission bits with
the bitwise and of the complement of perm and the file's current permission bits. | |
nofollow | permissions shall change the permissions of a symbolic link itself
rather than the permissions of the file the link resolves to. |
Name | Meaning | |
none | (Default) Skip directory symlinks, permission denied is an error. | |
follow_directory_symlink | Follow rather than skip directory symlinks. | |
skip_permission_denied | Skip directories that would otherwise result in permission denied. |
explicit file_status(file_type ft, perms prms = perms::unknown) noexcept;
file_type type() const noexcept;
perms permissions() const noexcept;
explicit directory_entry(const filesystem::path& p);
directory_entry(const filesystem::path& p, error_code& ec);
void assign(const filesystem::path& p);
void assign(const filesystem::path& p, error_code& ec);
void replace_filename(const filesystem::path& p);
void replace_filename(const filesystem::path& p, error_code& ec);
void refresh();
void refresh(error_code& ec) noexcept;
const filesystem::path& path() const noexcept;
operator const filesystem::path&() const noexcept;
bool exists() const;
bool exists(error_code& ec) const noexcept;
bool is_block_file() const;
bool is_block_file(error_code& ec) const noexcept;
bool is_character_file() const;
bool is_character_file(error_code& ec) const noexcept;
bool is_directory() const;
bool is_directory(error_code& ec) const noexcept;
bool is_fifo() const;
bool is_fifo(error_code& ec) const noexcept;
bool is_other() const;
bool is_other(error_code& ec) const noexcept;
bool is_regular_file() const;
bool is_regular_file(error_code& ec) const noexcept;
bool is_socket() const;
bool is_socket(error_code& ec) const noexcept;
bool is_symlink() const;
bool is_symlink(error_code& ec) const noexcept;
uintmax_t file_size() const;
uintmax_t file_size(error_code& ec) const noexcept;
uintmax_t hard_link_count() const;
uintmax_t hard_link_count(error_code& ec) const noexcept;
file_time_type last_write_time() const;
file_time_type last_write_time(error_code& ec) const noexcept;
file_status status() const;
file_status status(error_code& ec) const noexcept;
file_status symlink_status() const;
file_status symlink_status(error_code& ec) const noexcept;
bool operator==(const directory_entry& rhs) const noexcept;
strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
template<class charT, class traits>
friend basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
directory_iterator() noexcept;
explicit directory_iterator(const path& p);
directory_iterator(const path& p, directory_options options);
directory_iterator(const path& p, error_code& ec);
directory_iterator(const path& p, directory_options options, error_code& ec);
directory_iterator(const directory_iterator& rhs);
directory_iterator(directory_iterator&& rhs) noexcept;
directory_iterator& operator=(const directory_iterator& rhs);
directory_iterator& operator=(directory_iterator&& rhs) noexcept;
directory_iterator& operator++();
directory_iterator& increment(error_code& ec);
recursive_directory_iterator() noexcept;
explicit recursive_directory_iterator(const path& p);
recursive_directory_iterator(const path& p, directory_options options);
recursive_directory_iterator(const path& p, directory_options options, error_code& ec);
recursive_directory_iterator(const path& p, error_code& ec);
recursive_directory_iterator(const recursive_directory_iterator& rhs);
recursive_directory_iterator(recursive_directory_iterator&& rhs) noexcept;
recursive_directory_iterator& operator=(const recursive_directory_iterator& rhs);
recursive_directory_iterator& operator=(recursive_directory_iterator&& rhs) noexcept;
directory_options options() const;
int depth() const;
bool recursion_pending() const;
recursive_directory_iterator& operator++();
recursive_directory_iterator& increment(error_code& ec);
void pop();
void pop(error_code& ec);
void disable_recursion_pending();
recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
recursive_directory_iterator end(recursive_directory_iterator) noexcept;
path filesystem::absolute(const path& p);
path filesystem::absolute(const path& p, error_code& ec);
path filesystem::canonical(const path& p);
path filesystem::canonical(const path& p, error_code& ec);
void filesystem::copy(const path& from, const path& to);
void filesystem::copy(const path& from, const path& to, error_code& ec);
void filesystem::copy(const path& from, const path& to, copy_options options);
void filesystem::copy(const path& from, const path& to, copy_options options,
error_code& ec);
/dir1 file1 file2 dir2 file3
/dir1 file1 file2 dir2 file3 /dir3 file1 file2
/dir1 file1 file2 dir2 file3 /dir3 file1 file2 dir2 file3
bool filesystem::copy_file(const path& from, const path& to);
bool filesystem::copy_file(const path& from, const path& to, error_code& ec);
bool filesystem::copy_file(const path& from, const path& to, copy_options options);
bool filesystem::copy_file(const path& from, const path& to, copy_options options,
error_code& ec);
void filesystem::copy_symlink(const path& existing_symlink, const path& new_symlink);
void filesystem::copy_symlink(const path& existing_symlink, const path& new_symlink,
error_code& ec) noexcept;
bool filesystem::create_directories(const path& p);
bool filesystem::create_directories(const path& p, error_code& ec);
bool filesystem::create_directory(const path& p);
bool filesystem::create_directory(const path& p, error_code& ec) noexcept;
bool filesystem::create_directory(const path& p, const path& existing_p);
bool filesystem::create_directory(const path& p, const path& existing_p, error_code& ec) noexcept;
void filesystem::create_directory_symlink(const path& to, const path& new_symlink);
void filesystem::create_directory_symlink(const path& to, const path& new_symlink,
error_code& ec) noexcept;
void filesystem::create_hard_link(const path& to, const path& new_hard_link);
void filesystem::create_hard_link(const path& to, const path& new_hard_link,
error_code& ec) noexcept;
void filesystem::create_symlink(const path& to, const path& new_symlink);
void filesystem::create_symlink(const path& to, const path& new_symlink,
error_code& ec) noexcept;
path filesystem::current_path();
path filesystem::current_path(error_code& ec);
void filesystem::current_path(const path& p);
void filesystem::current_path(const path& p, error_code& ec) noexcept;
bool filesystem::equivalent(const path& p1, const path& p2);
bool filesystem::equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
bool filesystem::exists(file_status s) noexcept;
bool filesystem::exists(const path& p);
bool filesystem::exists(const path& p, error_code& ec) noexcept;
uintmax_t filesystem::file_size(const path& p);
uintmax_t filesystem::file_size(const path& p, error_code& ec) noexcept;
uintmax_t filesystem::hard_link_count(const path& p);
uintmax_t filesystem::hard_link_count(const path& p, error_code& ec) noexcept;
bool filesystem::is_block_file(file_status s) noexcept;
bool filesystem::is_block_file(const path& p);
bool filesystem::is_block_file(const path& p, error_code& ec) noexcept;
bool filesystem::is_character_file(file_status s) noexcept;
bool filesystem::is_character_file(const path& p);
bool filesystem::is_character_file(const path& p, error_code& ec) noexcept;
bool filesystem::is_directory(file_status s) noexcept;
bool filesystem::is_directory(const path& p);
bool filesystem::is_directory(const path& p, error_code& ec) noexcept;
bool filesystem::is_empty(const path& p);
bool filesystem::is_empty(const path& p, error_code& ec);
bool filesystem::is_fifo(file_status s) noexcept;
bool filesystem::is_fifo(const path& p);
bool filesystem::is_fifo(const path& p, error_code& ec) noexcept;
bool filesystem::is_other(file_status s) noexcept;
bool filesystem::is_other(const path& p);
bool filesystem::is_other(const path& p, error_code& ec) noexcept;
bool filesystem::is_regular_file(file_status s) noexcept;
bool filesystem::is_regular_file(const path& p);
bool filesystem::is_regular_file(const path& p, error_code& ec) noexcept;
bool filesystem::is_socket(file_status s) noexcept;
bool filesystem::is_socket(const path& p);
bool filesystem::is_socket(const path& p, error_code& ec) noexcept;
bool filesystem::is_symlink(file_status s) noexcept;
bool filesystem::is_symlink(const path& p);
bool filesystem::is_symlink(const path& p, error_code& ec) noexcept;
file_time_type filesystem::last_write_time(const path& p);
file_time_type filesystem::last_write_time(const path& p, error_code& ec) noexcept;
void filesystem::last_write_time(const path& p, file_time_type new_time);
void filesystem::last_write_time(const path& p, file_time_type new_time,
error_code& ec) noexcept;
void filesystem::permissions(const path& p, perms prms, perm_options opts=perm_options::replace);
void filesystem::permissions(const path& p, perms prms, error_code& ec) noexcept;
void filesystem::permissions(const path& p, perms prms, perm_options opts, error_code& ec);
path filesystem::proximate(const path& p, error_code& ec);
path filesystem::proximate(const path& p, const path& base = current_path());
path filesystem::proximate(const path& p, const path& base, error_code& ec);
path filesystem::read_symlink(const path& p);
path filesystem::read_symlink(const path& p, error_code& ec);
path filesystem::relative(const path& p, error_code& ec);
path filesystem::relative(const path& p, const path& base = current_path());
path filesystem::relative(const path& p, const path& base, error_code& ec);
bool filesystem::remove(const path& p);
bool filesystem::remove(const path& p, error_code& ec) noexcept;
uintmax_t filesystem::remove_all(const path& p);
uintmax_t filesystem::remove_all(const path& p, error_code& ec);
void filesystem::rename(const path& old_p, const path& new_p);
void filesystem::rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
void filesystem::resize_file(const path& p, uintmax_t new_size);
void filesystem::resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
space_info filesystem::space(const path& p);
space_info filesystem::space(const path& p, error_code& ec) noexcept;
file_status filesystem::status(const path& p);
file_status filesystem::status(const path& p, error_code& ec) noexcept;
bool filesystem::status_known(file_status s) noexcept;
file_status filesystem::symlink_status(const path& p);
file_status filesystem::symlink_status(const path& p, error_code& ec) noexcept;
path filesystem::temp_directory_path();
path filesystem::temp_directory_path(error_code& ec);
path filesystem::weakly_canonical(const path& p);
path filesystem::weakly_canonical(const path& p, error_code& ec);