From Jason Turner

[fs.path.nonmember]

C++14 → C++17 4.7 KB 163 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmphansue9o/{from.md → to.md} +160 -0
tmp/tmphansue9o/{from.md → to.md} RENAMED
@@ -0,0 +1,160 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #### `path` non-member functions <a id="fs.path.nonmember">[[fs.path.nonmember]]</a>
2
+
3
+ ``` cpp
4
+ void swap(path& lhs, path& rhs) noexcept;
5
+ ```
6
+
7
+ *Effects:* Equivalent to: `lhs.swap(rhs);`
8
+
9
+ ``` cpp
10
+ size_t hash_value (const path& p) noexcept;
11
+ ```
12
+
13
+ *Returns:* A hash value for the path `p`. If for two paths, `p1 == p2`
14
+ then `hash_value(p1) == hash_value(p2)`.
15
+
16
+ ``` cpp
17
+ bool operator< (const path& lhs, const path& rhs) noexcept;
18
+ ```
19
+
20
+ *Returns:* `lhs.compare(rhs) < 0`.
21
+
22
+ ``` cpp
23
+ bool operator<=(const path& lhs, const path& rhs) noexcept;
24
+ ```
25
+
26
+ *Returns:* `!(rhs < lhs)`.
27
+
28
+ ``` cpp
29
+ bool operator> (const path& lhs, const path& rhs) noexcept;
30
+ ```
31
+
32
+ *Returns:* `rhs < lhs`.
33
+
34
+ ``` cpp
35
+ bool operator>=(const path& lhs, const path& rhs) noexcept;
36
+ ```
37
+
38
+ *Returns:* `!(lhs < rhs)`.
39
+
40
+ ``` cpp
41
+ bool operator==(const path& lhs, const path& rhs) noexcept;
42
+ ```
43
+
44
+ *Returns:* `!(lhs < rhs) && !(rhs < lhs)`.
45
+
46
+ [*Note 1*:
47
+
48
+ Path equality and path equivalence have different semantics.
49
+
50
+ - Equality is determined by the `path` non-member `operator==`, which
51
+ considers the two path’s lexical representations only.
52
+ \[*Example 1*: `path("foo") == "bar"` is never
53
+ `true`. — *end example*]
54
+ - Equivalence is determined by the `equivalent()` non-member function,
55
+ which determines if two paths resolve ([[fs.def.pathres]]) to the
56
+ same file system entity. \[*Example 2*: `equivalent("foo", "bar")`
57
+ will be `true` when both paths resolve to the same
58
+ file. — *end example*]
59
+
60
+ Programmers wishing to determine if two paths are “the same” must decide
61
+ if “the same” means “the same representation” or “resolve to the same
62
+ actual file”, and choose the appropriate function accordingly.
63
+
64
+ — *end note*]
65
+
66
+ ``` cpp
67
+ bool operator!=(const path& lhs, const path& rhs) noexcept;
68
+ ```
69
+
70
+ *Returns:* `!(lhs == rhs)`.
71
+
72
+ ``` cpp
73
+ path operator/ (const path& lhs, const path& rhs);
74
+ ```
75
+
76
+ *Effects:* Equivalent to: `return path(lhs) /= rhs;`
77
+
78
+ ##### `path` inserter and extractor <a id="fs.path.io">[[fs.path.io]]</a>
79
+
80
+ ``` cpp
81
+ template <class charT, class traits>
82
+ basic_ostream<charT, traits>&
83
+ operator<<(basic_ostream<charT, traits>& os, const path& p);
84
+ ```
85
+
86
+ *Effects:* Equivalent to: `os << quoted(p.string<charT, traits>());`
87
+
88
+ [*Note 2*: The `quoted` function is described
89
+ in  [[quoted.manip]]. — *end note*]
90
+
91
+ *Returns:* `os`.
92
+
93
+ ``` cpp
94
+ template <class charT, class traits>
95
+ basic_istream<charT, traits>&
96
+ operator>>(basic_istream<charT, traits>& is, path& p);
97
+ ```
98
+
99
+ *Effects:* Equivalent to:
100
+
101
+ ``` cpp
102
+ basic_string<charT, traits> tmp;
103
+ is >> quoted(tmp);
104
+ p = tmp;
105
+ ```
106
+
107
+ *Returns:* `is`.
108
+
109
+ ##### `path` factory functions <a id="fs.path.factory">[[fs.path.factory]]</a>
110
+
111
+ ``` cpp
112
+ template <class Source>
113
+ path u8path(const Source& source);
114
+ template <class InputIterator>
115
+ path u8path(InputIterator first, InputIterator last);
116
+ ```
117
+
118
+ *Requires:* The `source` and \[`first`, `last`) sequences are UTF-8
119
+ encoded. The value type of `Source` and `InputIterator` is `char`.
120
+
121
+ *Returns:*
122
+
123
+ - If `value_type` is `char` and the current native narrow
124
+ encoding ([[fs.def.native.encode]]) is UTF-8, return `path(source)`
125
+ or `path(first, last)`; otherwise,
126
+ - if `value_type` is `wchar_t` and the native wide encoding is UTF-16,
127
+ or if `value_type` is `char16_t` or `char32_t`, convert `source` or
128
+ \[`first`, `last`) to a temporary, `tmp`, of type `string_type` and
129
+ return `path(tmp)`; otherwise,
130
+ - convert `source` or \[`first`, `last`) to a temporary, `tmp`, of type
131
+ `u32string` and return `path(tmp)`.
132
+
133
+ *Remarks:* Argument format conversion ([[fs.path.fmt.cvt]]) applies to
134
+ the arguments for these functions. How Unicode encoding conversions are
135
+ performed is unspecified.
136
+
137
+ [*Example 1*:
138
+
139
+ A string is to be read from a database that is encoded in UTF-8, and
140
+ used to create a directory using the native encoding for filenames:
141
+
142
+ ``` cpp
143
+ namespace fs = std::filesystem;
144
+ std::string utf8_string = read_utf8_data();
145
+ fs::create_directory(fs::u8path(utf8_string));
146
+ ```
147
+
148
+ For POSIX-based operating systems with the native narrow encoding set to
149
+ UTF-8, no encoding or type conversion occurs.
150
+
151
+ For POSIX-based operating systems with the native narrow encoding not
152
+ set to UTF-8, a conversion to UTF-32 occurs, followed by a conversion to
153
+ the current native narrow encoding. Some Unicode characters may have no
154
+ native character set representation.
155
+
156
+ For Windows-based operating systems a conversion from UTF-8 to UTF-16
157
+ occurs.
158
+
159
+ — *end example*]
160
+