std::filesystem::path (3) - Linux Man Pages

std::filesystem::path: std::filesystem::path

NAME

std::filesystem::path - std::filesystem::path

Synopsis


Defined in header <filesystem>
class path; (since C++17)


Objects of type path represent paths on a filesystem. Only syntactic aspects of paths are handled: the pathname may represent a non-existing path or even one that is not allowed to exist on the current file system or OS.
The path name has the following syntax:


  1. root-name(optional): identifies the root on a filesystem with multiple roots (such as "C:" or "//myserver"). In case of ambiguity, the longest sequence of characters that forms a valid root-name is treated as the root-name. The standard library may define additional root-names besides the ones understood by the OS API.
  2. root-directory(optional): a directory separator that, if present, marks this path as absolute. If it is missing (and the first element other than the root name is a file name), then the path is relative and requires another path as the starting location to resolve to a file name.
  3. Zero or more of the following:


      * file-name: sequence of characters that aren't directory separators or preferred directory separators (additional limitations may be imposed by the OS or file system). This name may identify a file, a hard link, a symbolic link, or a directory. Two special file-names are recognized:


            * dot: the file name consisting of a single dot character . is a directory name that refers to the current directory
            * dot-dot: the file name consisting of two dot characters .. is a directory name that refers to the parent directory.


      * directory-separators: the forward slash character / or the alternative character provided as path::preferred_separator. If this character is repeated, it is treated as a single directory separator: /usr///////lib is the same as /usr/lib


A path can be normalized by following this algorithm:
1) If the path is empty, stop (normal form of an empty path is an empty path)
2) Replace each directory-separator (which may consist of multiple slashes) with a single path::preferred_separator.
3) Replace each slash character in the root-name with path::preferred_separator.
4) Remove each dot and any immediately following directory-separator.
5) Remove each non-dot-dot filename immediately followed by a directory-separator and a dot-dot, along with any immediately following directory-separator.
6) If there is root-directory, remove all dot-dots 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 (normal form of ./ is .)
The path can be traversed element-wise via iterators returned by the begin() and end() functions, which views the path in generic format and iterates over root name, root directory, and the subsequent file name elements (directory separators are skipped except the one that identifies the root directory). If the very last element in the path is a directory separator, the last iterator will dereference to an empty element.
Calling any non-const member function of a path invalidates all iterators referring to elements of that object.
If the OS uses a native syntax that is different from the portable generic syntax described above, library functions that are defined to accept "detected format" accept path names in both formats: a detected format argument is taken to be in the generic format if and only if it matches the generic format but is not acceptable to the operating system as a native path. On those OS where native format differs between pathnames of directories and pathnames of files, a generic pathname is treated as a directory path if it ends on a directory separator and a regular file otherwise.
In any case, the path class behaves as if it stores a pathname in the native format and automatically converts to generic format as needed (each member function specifies which format it interprets the path as)
On POSIX systems, the generic format is the native format and there is no need to distinguish or convert between them.
Paths are implicitly convertible to and from std::basic_strings, which makes it possible to use them with over files APIs, e.g. as an argument to std::ifstream::open

Member types and constants


Type Definition
value_type character type used by the native encoding of the filesystem: char on POSIX, wchar_t on Windows
string_type std::basic_string<value_type>
const_iterator a constant LegacyBidirectionalIterator with a value_type of path, except that for dereferenceable iterators a and b of type path::iterator with a == b, there is no requirement that *a and *b are bound to the same object
iterator an alias to const_iterator
               determines how to interpret string representations of pathnames
               The following enumerators are also defined:


               Constant Explanation
               native_format native pathname format
format generic_format generic pathname format
               auto_format implementation-defined format, auto-detected where possible


               (enum)

Member constants


constexpr value_type preferred_separator alternative directory separator which may be used in addition to the portable /. On Windows, this is the backslash character \. On POSIX, this is the same forward slash / as the portable separator
                                         (public static member constant)
[static]

Member functions


                     constructs a path
constructor (public member function)
                     destroys a path object
destructor (public member function)
                     assigns another path
operator= (public member function)
                     assigns contents
assign (public member function)


 Concatenation


                     appends elements to the path with a directory separator
append (public member function)
operator/=
                     concatenates two paths without introducing a directory separator
concat (public member function)
operator+=

Modifiers


                     erases the contents
clear (public member function)
                     converts directory separators to preferred directory separator
make_preferred (public member function)
                     removes filename path component
remove_filename (public member function)
                     replaces the last path component with another path
replace_filename (public member function)
                     replaces the extension
replace_extension (public member function)
                     swaps two paths
swap (public member function)


 Format observers


c_str returns the native version of the path
native (public member function)
operator_string_type


string
wstring returns the path in native pathname format converted to a string
u8string (public member function)
u16string
u32string


generic_string
generic_wstring returns the path in generic pathname format converted to a string
generic_u8string (public member function)
generic_u16string
generic_u32string


 Compare


                     compares the lexical representations of two paths lexicographically
compare (public member function)

Generation


                     converts path to normal form
lexically_normal converts path to relative form
lexically_relative converts path to proximate form
lexically_proximate (public member function)


 Decomposition


                     returns the root-name of the path, if present
root_name (public member function)
                     returns the root directory of the path, if present
root_directory (public member function)
                     returns the root path of the path, if present
root_path (public member function)
                     returns path relative to the root path
relative_path (public member function)
                     returns the path of the parent path
parent_path (public member function)
                     returns the filename path component
filename (public member function)
                     returns the stem path component
stem (public member function)
                     returns the file extension path component
extension (public member function)


 Queries


                     checks if the path is empty
empty (public member function)


has_root_path
has_root_name
has_root_directory checks if the corresponding path element is not empty
has_relative_path (public member function)
has_parent_path
has_filename
has_stem
has_extension
                     checks if root_path() uniquely identifies file system location
is_absolute (public member function)
is_relative

Iterators


                     iterator access to the path as a sequence of elements
begin (public member function)
end

Non-member functions


                            swaps two paths
swap(std::filesystem::path) (function)
                            calculates a hash value for a path object
hash_value (function)


operator==
operator!= lexicographically compares two paths
operator< (function)
operator<=
operator>
operator>=
                            concatenates two paths with a directory separator
operator/ (function)
                            performs stream input and output on a path
operator<< (function)
operator>>


u8path creates a path from a UTF-8 encoded source
                            (function)
(C++17)
(deprecated in C++20)