FreeBSD Manual Pages
std::filesystem::path(3) C++ Standard Libary std::filesystem::path(3) 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 an- other 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 separa- tor: /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::pre- ferred_separator. 4. Remove each dot and any immediately following directory-separa- tor. 5. Remove each non-dot-dot filename immediately followed by a di- rectory-separator and a dot-dot, along with any immediately following directory- separator. 6. If there is root-directory, remove all dot-dots and any direc- tory-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 deref- erence to an empty element. Calling any non-const member function of a path invalidates all it- erators 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 "de- tected 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 for- mat 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 other file APIs. The stream operators use std::quoted so that spaces do not cause truncation when later read by stream input operator. Decomposition member functions (e.g. extension) return filesys- tem::path objects instead of string objects as other APIs do. 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> a constant LegacyBidirectionalIterator with a value_type of path, const_iterator 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 format native_format native pathname format generic_format generic pathname format auto_format implementation-defined format, auto- detected where possible (enum) Member constants alternative directory separator which may be used in addition constexpr value_type to the portable /. On Windows, this is the backslash character preferred_separator \. On POSIX, this is the same forward slash / as the portable [static] separator (public static member constant) Member functions constructor constructs a path (public member function) destructor destroys a path object (public member function) operator= assigns another path (public member function) assign assigns contents (public member function) Concatenation append appends elements to the path with a directory separator operator/= (public member function) concat concatenates two paths without introducing a directory operator+= separator (public member function) Modifiers clear erases the contents (public member function) make_preferred converts directory separators to preferred di- rectory separator (public member function) remove_filename removes filename path component (public member function) replace_filename replaces the last path component with another path (public member function) replace_extension replaces the extension (public member function) swap swaps two paths (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 con- verted to a u8string string u16string (public member function) u32string generic_string generic_wstring returns the path in generic pathname format converted to a generic_u8string string generic_u16string (public member function) generic_u32string Compare compares the lexical representations of two paths compare lexicographically (public member function) Generation lexically_normal converts path to normal form lexically_relative converts path to relative form lexically_proximate converts path to proximate form (public member function) Decomposition root_name returns the root-name of the path, if present (public member function) root_directory returns the root directory of the path, if present (public member function) root_path returns the root path of the path, if present (public member function) relative_path returns path relative to the root path (public member function) parent_path returns the path of the parent path (public member function) filename returns the filename path component (public member function) returns the stem path component (filename with- out the final stem extension) (public member function) extension returns the file extension path component (public member function) Queries empty checks if the path is empty (public member function) has_root_path has_root_name has_root_directory has_relative_path checks if the corresponding path element is not empty has_parent_path (public member function) has_filename has_stem has_extension is_absolute checks if root_path() uniquely identifies file system location is_relative (public member function) Iterators begin iterator access to the path as a sequence of elements end (public member function) Non-member functions Defined in namespace std::filesystem swap(std::filesystem::path) swaps two paths (C++17) (function) hash_value calculates a hash value for a path ob- ject (function) operator== operator!= operator< operator<= operator> operator>= lexicographically compares two paths operator<=> (function) (until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20) operator/ concatenates two paths with a directory separator (function) operator<< performs stream input and output on a quoted path operator>> (function) u8path creates a path from a UTF-8 encoded source (C++17)(deprecated in C++20) (function) Helper classes Defined in namespace std std::hash<std::filesystem::path> hash support for std::filesys- tem::path (C++17) (class template specialization) Defect reports The following behavior-changing defect reports were applied retroac- tively to previously published C++ standards. DR Applied to Behavior as published Correct behavior LWG 3657 C++17 hash for path was disabled enabled http://cppreference.com 2022.07.31 std::filesystem::path(3)
NAME | Synopsis | Member types and constants | Member constants | Member functions | Modifiers | Generation | Iterators | Non-member functions | Helper classes
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::filesystem::path&sektion=3&manpath=FreeBSD+Ports+15.0>