From Jason Turner

[re.regex.assign]

C++14 → C++17 2.5 KB 34 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game
C++ Weekly: Ep 62

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmplqk4_rb7/{from.md → to.md} +17 -14
tmp/tmplqk4_rb7/{from.md → to.md} RENAMED
@@ -2,67 +2,70 @@
2
 
3
  ``` cpp
4
  basic_regex& operator=(const basic_regex& e);
5
  ```
6
 
7
- *Effects:* returns `assign(e)`.
 
 
 
8
 
9
  ``` cpp
10
  basic_regex& operator=(basic_regex&& e) noexcept;
11
  ```
12
 
13
- *Effects:* returns `assign(std::move(e))`.
 
 
 
 
14
 
15
  ``` cpp
16
  basic_regex& operator=(const charT* ptr);
17
  ```
18
 
19
  *Requires:* `ptr` shall not be a null pointer.
20
 
21
- *Effects:* returns `assign(ptr)`.
22
 
23
  ``` cpp
24
  basic_regex& operator=(initializer_list<charT> il);
25
  ```
26
 
27
- *Effects:* returns `assign(il.begin(), il.end())`.
28
 
29
  ``` cpp
30
  template <class ST, class SA>
31
  basic_regex& operator=(const basic_string<charT, ST, SA>& p);
32
  ```
33
 
34
- *Effects:* returns `assign(p)`.
35
 
36
  ``` cpp
37
  basic_regex& assign(const basic_regex& that);
38
  ```
39
 
40
- *Effects:* copies `that` into `*this` and returns `*this`.
41
 
42
- *Postconditions:* `flags()` and `mark_count()` return `that.flags()` and
43
- `that.mark_count()`, respectively.
44
 
45
  ``` cpp
46
  basic_regex& assign(basic_regex&& that) noexcept;
47
  ```
48
 
49
- *Effects:* move assigns from `that` into `*this` and returns `*this`.
50
 
51
- *Postconditions:* `flags()` and `mark_count()` return the values that
52
- `that.flags()` and `that.mark_count()`, respectively, had before
53
- assignment. `that` is in a valid state with unspecified value.
54
 
55
  ``` cpp
56
  basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
57
  ```
58
 
59
  *Returns:* `assign(string_type(ptr), f)`.
60
 
61
  ``` cpp
62
- basic_regex& assign(const charT* ptr, size_t len,
63
- flag_type f = regex_constants::ECMAScript);
64
  ```
65
 
66
  *Returns:* `assign(string_type(ptr, len), f)`.
67
 
68
  ``` cpp
 
2
 
3
  ``` cpp
4
  basic_regex& operator=(const basic_regex& e);
5
  ```
6
 
7
+ *Effects:* Copies `e` into `*this` and returns `*this`.
8
+
9
+ *Postconditions:* `flags()` and `mark_count()` return `e.flags()` and
10
+ `e.mark_count()`, respectively.
11
 
12
  ``` cpp
13
  basic_regex& operator=(basic_regex&& e) noexcept;
14
  ```
15
 
16
+ *Effects:* Move assigns from `e` into `*this` and returns `*this`.
17
+
18
+ *Postconditions:* `flags()` and `mark_count()` return the values that
19
+ `e.flags()` and `e.mark_count()`, respectively, had before assignment.
20
+ `e` is in a valid state with unspecified value.
21
 
22
  ``` cpp
23
  basic_regex& operator=(const charT* ptr);
24
  ```
25
 
26
  *Requires:* `ptr` shall not be a null pointer.
27
 
28
+ *Effects:* Returns `assign(ptr)`.
29
 
30
  ``` cpp
31
  basic_regex& operator=(initializer_list<charT> il);
32
  ```
33
 
34
+ *Effects:* Returns `assign(il.begin(), il.end())`.
35
 
36
  ``` cpp
37
  template <class ST, class SA>
38
  basic_regex& operator=(const basic_string<charT, ST, SA>& p);
39
  ```
40
 
41
+ *Effects:* Returns `assign(p)`.
42
 
43
  ``` cpp
44
  basic_regex& assign(const basic_regex& that);
45
  ```
46
 
47
+ *Effects:* Equivalent to `*this = that`.
48
 
49
+ *Returns:* `*this`.
 
50
 
51
  ``` cpp
52
  basic_regex& assign(basic_regex&& that) noexcept;
53
  ```
54
 
55
+ *Effects:* Equivalent to `*this = std::move(that)`.
56
 
57
+ *Returns:* `*this`.
 
 
58
 
59
  ``` cpp
60
  basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
61
  ```
62
 
63
  *Returns:* `assign(string_type(ptr), f)`.
64
 
65
  ``` cpp
66
+ basic_regex& assign(const charT* ptr, size_t len, flag_type f = regex_constants::ECMAScript);
 
67
  ```
68
 
69
  *Returns:* `assign(string_type(ptr, len), f)`.
70
 
71
  ``` cpp