From Jason Turner

[valarray.sub]

C++14 → C++17 4.5 KB 61 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/tmpxlfdclh6/{from.md → to.md} +45 -13
tmp/tmpxlfdclh6/{from.md → to.md} RENAMED
@@ -9,121 +9,153 @@ the original array, working in conjunction with various overloads of
9
  `operator=` and other assigning operators to allow selective replacement
10
  (slicing) of the controlled sequence. In each case the selected
11
  element(s) must exist.
12
 
13
  ``` cpp
14
- valarray<T> operator[](slice slicearr) const;
15
  ```
16
 
17
- *Returns:* An object of class `valarray<T>` containing those elements of
18
- the controlled sequence designated by `slicearr`.
 
 
19
 
20
  ``` cpp
21
  const valarray<char> v0("abcdefghijklmnop", 16);
22
  // v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)
23
  ```
24
 
 
 
25
  ``` cpp
26
  slice_array<T> operator[](slice slicearr);
27
  ```
28
 
29
  *Returns:* An object that holds references to elements of the controlled
30
  sequence selected by `slicearr`.
31
 
 
 
32
  ``` cpp
33
  valarray<char> v0("abcdefghijklmnop", 16);
34
  valarray<char> v1("ABCDE", 5);
35
  v0[slice(2, 5, 3)] = v1;
36
  // v0 == valarray<char>("abAdeBghCjkDmnEp", 16);
37
  ```
38
 
 
 
39
  ``` cpp
40
- valarray<T> operator[](const gslice& gslicearr) const;
41
  ```
42
 
43
- *Returns:* An object of class `valarray<T>` containing those elements of
44
- the controlled sequence designated by `gslicearr`.
 
 
45
 
46
  ``` cpp
47
  const valarray<char> v0("abcdefghijklmnop", 16);
48
  const size_t lv[] = { 2, 3 };
49
  const size_t dv[] = { 7, 2 };
50
  const valarray<size_t> len(lv, 2), str(dv, 2);
51
  // v0[gslice(3, len, str)] returns
52
  // valarray<char>("dfhkmo", 6)
53
  ```
54
 
 
 
55
  ``` cpp
56
  gslice_array<T> operator[](const gslice& gslicearr);
57
  ```
58
 
59
  *Returns:* An object that holds references to elements of the controlled
60
  sequence selected by `gslicearr`.
61
 
 
 
62
  ``` cpp
63
  valarray<char> v0("abcdefghijklmnop", 16);
64
- valarray<char> v1("ABCDE", 5);
65
  const size_t lv[] = { 2, 3 };
66
  const size_t dv[] = { 7, 2 };
67
  const valarray<size_t> len(lv, 2), str(dv, 2);
68
  v0[gslice(3, len, str)] = v1;
69
  // v0 == valarray<char>("abcAeBgCijDlEnFp", 16)
70
  ```
71
 
 
 
72
  ``` cpp
73
- valarray<T> operator[](const valarray<bool>& boolarr) const;
74
  ```
75
 
76
- *Returns:* An object of class `valarray<T>` containing those elements of
77
- the controlled sequence designated by `boolarr`.
 
 
78
 
79
  ``` cpp
80
  const valarray<char> v0("abcdefghijklmnop", 16);
81
  const bool vb[] = { false, false, true, true, false, true };
82
  // v0[valarray<bool>(vb, 6)] returns
83
  // valarray<char>("cdf", 3)
84
  ```
85
 
 
 
86
  ``` cpp
87
  mask_array<T> operator[](const valarray<bool>& boolarr);
88
  ```
89
 
90
  *Returns:* An object that holds references to elements of the controlled
91
  sequence selected by `boolarr`.
92
 
 
 
93
  ``` cpp
94
  valarray<char> v0("abcdefghijklmnop", 16);
95
  valarray<char> v1("ABC", 3);
96
  const bool vb[] = { false, false, true, true, false, true };
97
  v0[valarray<bool>(vb, 6)] = v1;
98
  // v0 == valarray<char>("abABeCghijklmnop", 16)
99
  ```
100
 
 
 
101
  ``` cpp
102
- valarray<T> operator[](const valarray<size_t>& indarr) const;
103
  ```
104
 
105
- *Returns:* An object of class `valarray<T>` containing those elements of
106
- the controlled sequence designated by `indarr`.
 
 
107
 
108
  ``` cpp
109
  const valarray<char> v0("abcdefghijklmnop", 16);
110
  const size_t vi[] = { 7, 5, 2, 3, 8 };
111
  // v0[valarray<size_t>(vi, 5)] returns
112
  // valarray<char>("hfcdi", 5)
113
  ```
114
 
 
 
115
  ``` cpp
116
  indirect_array<T> operator[](const valarray<size_t>& indarr);
117
  ```
118
 
119
  *Returns:* An object that holds references to elements of the controlled
120
  sequence selected by `indarr`.
121
 
 
 
122
  ``` cpp
123
  valarray<char> v0("abcdefghijklmnop", 16);
124
  valarray<char> v1("ABCDE", 5);
125
  const size_t vi[] = { 7, 5, 2, 3, 8 };
126
  v0[valarray<size_t>(vi, 5)] = v1;
127
  // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
128
  ```
129
 
 
 
 
9
  `operator=` and other assigning operators to allow selective replacement
10
  (slicing) of the controlled sequence. In each case the selected
11
  element(s) must exist.
12
 
13
  ``` cpp
14
+ valarray operator[](slice slicearr) const;
15
  ```
16
 
17
+ *Returns:* A `valarray` containing those elements of the controlled
18
+ sequence designated by `slicearr`.
19
+
20
+ [*Example 1*:
21
 
22
  ``` cpp
23
  const valarray<char> v0("abcdefghijklmnop", 16);
24
  // v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)
25
  ```
26
 
27
+ — *end example*]
28
+
29
  ``` cpp
30
  slice_array<T> operator[](slice slicearr);
31
  ```
32
 
33
  *Returns:* An object that holds references to elements of the controlled
34
  sequence selected by `slicearr`.
35
 
36
+ [*Example 2*:
37
+
38
  ``` cpp
39
  valarray<char> v0("abcdefghijklmnop", 16);
40
  valarray<char> v1("ABCDE", 5);
41
  v0[slice(2, 5, 3)] = v1;
42
  // v0 == valarray<char>("abAdeBghCjkDmnEp", 16);
43
  ```
44
 
45
+ — *end example*]
46
+
47
  ``` cpp
48
+ valarray operator[](const gslice& gslicearr) const;
49
  ```
50
 
51
+ *Returns:* A `valarray` containing those elements of the controlled
52
+ sequence designated by `gslicearr`.
53
+
54
+ [*Example 3*:
55
 
56
  ``` cpp
57
  const valarray<char> v0("abcdefghijklmnop", 16);
58
  const size_t lv[] = { 2, 3 };
59
  const size_t dv[] = { 7, 2 };
60
  const valarray<size_t> len(lv, 2), str(dv, 2);
61
  // v0[gslice(3, len, str)] returns
62
  // valarray<char>("dfhkmo", 6)
63
  ```
64
 
65
+ — *end example*]
66
+
67
  ``` cpp
68
  gslice_array<T> operator[](const gslice& gslicearr);
69
  ```
70
 
71
  *Returns:* An object that holds references to elements of the controlled
72
  sequence selected by `gslicearr`.
73
 
74
+ [*Example 4*:
75
+
76
  ``` cpp
77
  valarray<char> v0("abcdefghijklmnop", 16);
78
+ valarray<char> v1("ABCDEF", 6);
79
  const size_t lv[] = { 2, 3 };
80
  const size_t dv[] = { 7, 2 };
81
  const valarray<size_t> len(lv, 2), str(dv, 2);
82
  v0[gslice(3, len, str)] = v1;
83
  // v0 == valarray<char>("abcAeBgCijDlEnFp", 16)
84
  ```
85
 
86
+ — *end example*]
87
+
88
  ``` cpp
89
+ valarray operator[](const valarray<bool>& boolarr) const;
90
  ```
91
 
92
+ *Returns:* A `valarray` containing those elements of the controlled
93
+ sequence designated by `boolarr`.
94
+
95
+ [*Example 5*:
96
 
97
  ``` cpp
98
  const valarray<char> v0("abcdefghijklmnop", 16);
99
  const bool vb[] = { false, false, true, true, false, true };
100
  // v0[valarray<bool>(vb, 6)] returns
101
  // valarray<char>("cdf", 3)
102
  ```
103
 
104
+ — *end example*]
105
+
106
  ``` cpp
107
  mask_array<T> operator[](const valarray<bool>& boolarr);
108
  ```
109
 
110
  *Returns:* An object that holds references to elements of the controlled
111
  sequence selected by `boolarr`.
112
 
113
+ [*Example 6*:
114
+
115
  ``` cpp
116
  valarray<char> v0("abcdefghijklmnop", 16);
117
  valarray<char> v1("ABC", 3);
118
  const bool vb[] = { false, false, true, true, false, true };
119
  v0[valarray<bool>(vb, 6)] = v1;
120
  // v0 == valarray<char>("abABeCghijklmnop", 16)
121
  ```
122
 
123
+ — *end example*]
124
+
125
  ``` cpp
126
+ valarray operator[](const valarray<size_t>& indarr) const;
127
  ```
128
 
129
+ *Returns:* A `valarray` containing those elements of the controlled
130
+ sequence designated by `indarr`.
131
+
132
+ [*Example 7*:
133
 
134
  ``` cpp
135
  const valarray<char> v0("abcdefghijklmnop", 16);
136
  const size_t vi[] = { 7, 5, 2, 3, 8 };
137
  // v0[valarray<size_t>(vi, 5)] returns
138
  // valarray<char>("hfcdi", 5)
139
  ```
140
 
141
+ — *end example*]
142
+
143
  ``` cpp
144
  indirect_array<T> operator[](const valarray<size_t>& indarr);
145
  ```
146
 
147
  *Returns:* An object that holds references to elements of the controlled
148
  sequence selected by `indarr`.
149
 
150
+ [*Example 8*:
151
+
152
  ``` cpp
153
  valarray<char> v0("abcdefghijklmnop", 16);
154
  valarray<char> v1("ABCDE", 5);
155
  const size_t vi[] = { 7, 5, 2, 3, 8 };
156
  v0[valarray<size_t>(vi, 5)] = v1;
157
  // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
158
  ```
159
 
160
+ — *end example*]
161
+