From Jason Turner

[intro.defs]

C++17 → C++20 12.9 KB 212 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmptqhdbke5/{from.md → to.md} +148 -61
tmp/tmptqhdbke5/{from.md → to.md} RENAMED
@@ -5,133 +5,220 @@ ISO/IEC 2382-1:1993, the terms, definitions, and symbols given in ISO
5
  80000-2:2009, and the following apply.
6
 
7
  ISO and IEC maintain terminological databases for use in standardization
8
  at the following addresses:
9
 
 
10
  - IEC Electropedia: available at <http://www.electropedia.org/>
11
- - ISO Online browsing platform: available at <http://www.iso.org/obp>
12
 
13
- [[definitions]] defines additional terms that are used only in Clauses 
14
- [[library]] through  [[thread]] and Annex  [[depr]].
15
 
16
  Terms that are used only in a small portion of this document are defined
17
  where they are used and italicized where they are defined.
18
 
19
- to read or modify the value of an object
20
 
21
- expression in the comma-separated list bounded by the parentheses (
22
- [[expr.call]])
23
 
24
- sequence of preprocessing tokens in the comma-separated list bounded by
25
- the parentheses ([[cpp.replace]])
 
 
 
26
 
27
- the operand of `throw` ([[expr.throw]])
28
 
29
- *constant-expression*, *type-id*, or *id-expression* in the
30
- comma-separated list bounded by the angle brackets ([[temp.arg]])
31
 
32
- a thread of execution that blocks is waiting for some condition (other
33
- than for the implementation to execute its execution steps) to be
34
- satisfied before it can continue execution past the blocking operation
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
35
 
36
  program construct that an implementation is not required to support
37
 
38
- [*Note 1*: Each implementation documents all conditionally-supported
39
- constructs that it does not support. — *end note*]
 
 
 
40
 
41
  message belonging to an *implementation-defined* subset of the
42
  implementation’s output messages
43
 
44
- type of the most derived object ([[intro.object]]) to which the glvalue
45
- refers
46
 
47
- [*Example 1*: If a pointer ([[dcl.ptr]]) `p` whose static type is
 
 
 
48
  “pointer to class `B`” is pointing to an object of class `D`, derived
49
- from `B` (Clause  [[class.derived]]), the dynamic type of the expression
50
- `*p` is “`D`”. References ([[dcl.ref]]) are treated
51
- similarly. — *end example*]
52
 
53
- static type of the prvalue expression
54
 
55
- program that is not well-formed ([[defns.well.formed]])
 
 
 
 
 
 
56
 
57
  behavior, for a well-formed program construct and correct data, that
58
  depends on the implementation and that each implementation documents
59
 
 
 
60
  restrictions imposed upon programs by the implementation
61
 
 
 
62
  behavior that depends on local conventions of nationality, culture, and
63
  language that each implementation documents
64
 
 
 
65
  sequence of one or more bytes representing a member of the extended
66
  character set of either the source or the execution environment
67
 
68
- [*Note 2*: The extended character set is a superset of the basic
69
- character set ([[lex.charset]]). — *end note*]
70
 
71
- object or reference declared as part of a function declaration or
72
- definition or in the catch clause of an exception handler that acquires
73
- a value on entry to the function or handler
74
 
75
- identifier from the comma-separated list bounded by the parentheses
76
- immediately following the macro name
 
 
77
 
78
- member of a *template-parameter-list*
79
 
80
- name, parameter type list ([[dcl.fct]]), and enclosing namespace (if
81
- any)
82
 
83
- [*Note 3*: Signatures are used as a basis for name mangling and
84
- linking. — *end note*]
85
 
86
- name, parameter type list ([[dcl.fct]]), enclosing namespace (if any),
87
- return type, and template parameter list
88
 
89
- signature of the template of which it is a specialization and its
90
- template arguments (whether explicitly specified or deduced)
91
 
92
- name, parameter type list ([[dcl.fct]]), class of which the function is
93
- a member, cv-qualifiers (if any), and *ref-qualifier* (if any)
94
 
95
- name, parameter type list ([[dcl.fct]]), class of which the function is
96
- a member, cv-qualifiers (if any), *ref-qualifier* (if any), return type
97
- (if any), and template parameter list
98
 
99
- signature of the member function template of which it is a
100
- specialization and its template arguments (whether explicitly specified
101
- or deduced)
102
 
103
- type of an expression ([[basic.types]]) resulting from analysis of the
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
104
  program without considering execution semantics
105
 
106
- [*Note 4*: The static type of an expression depends only on the form of
107
- the program in which the expression appears, and does not change while
108
- the program is executing. — *end note*]
 
 
109
 
110
  satisfy a condition that one or more blocked threads of execution are
111
  waiting for
112
 
113
- behavior for which this International Standard imposes no requirements
114
 
115
- [*Note 5*: Undefined behavior may be expected when this International
116
- Standard omits any explicit definition of behavior or when a program
 
 
117
  uses an erroneous construct or erroneous data. Permissible undefined
118
  behavior ranges from ignoring the situation completely with
119
  unpredictable results, to behaving during translation or program
120
  execution in a documented manner characteristic of the environment (with
121
  or without the issuance of a diagnostic message), to terminating a
122
  translation or execution (with the issuance of a diagnostic message).
123
  Many erroneous program constructs do not engender undefined behavior;
124
  they are required to be diagnosed. Evaluation of a constant expression
125
- never exhibits behavior explicitly specified as undefined (
126
- [[expr.const]]). — *end note*]
 
 
127
 
128
  behavior, for a well-formed program construct and correct data, that
129
  depends on the implementation
130
 
131
- [*Note 6*: The implementation is not required to document which
132
- behavior occurs. The range of possible behaviors is usually delineated
133
- by this International Standard. — *end note*]
 
 
134
 
135
  C++ program constructed according to the syntax rules, diagnosable
136
- semantic rules, and the one-definition rule ([[basic.def.odr]]).
137
 
 
5
  80000-2:2009, and the following apply.
6
 
7
  ISO and IEC maintain terminological databases for use in standardization
8
  at the following addresses:
9
 
10
+ - ISO Online browsing platform: available at <https://www.iso.org/obp>
11
  - IEC Electropedia: available at <http://www.electropedia.org/>
 
12
 
13
+ [[definitions]] defines additional terms that are used only in
14
+ [[library]] through [[thread]] and [[depr]].
15
 
16
  Terms that are used only in a small portion of this document are defined
17
  where they are used and italicized where they are defined.
18
 
19
+ #### 1 access <a id="defns.access">[[defns.access]]</a>
20
 
21
+ ⟨execution-time action⟩ read [[conv.lval]] or modify ([[expr.ass]],
22
+ [[expr.post.incr]], [[expr.pre.incr]]) the value of an object
23
 
24
+ [*Note 1 to entry*: Only objects of scalar type can be accessed.
25
+ Attempts to read or modify an object of class type typically invoke a
26
+ constructor [[class.ctor]] or assignment operator [[class.copy.assign]];
27
+ such invocations do not themselves constitute accesses, although they
28
+ may involve accesses of scalar subobjects. — *end note*]
29
 
30
+ #### 2 argument <a id="defns.argument">[[defns.argument]]</a>
31
 
32
+ ⟨function call expression⟩ expression in the comma-separated list
33
+ bounded by the parentheses [[expr.call]]
34
 
35
+ #### 3 argument <a id="defns.argument.macro">[[defns.argument.macro]]</a>
36
+
37
+ ⟨function-like macro⟩ sequence of preprocessing tokens in the
38
+ comma-separated list bounded by the parentheses [[cpp.replace]]
39
+
40
+ #### 4 argument <a id="defns.argument.throw">[[defns.argument.throw]]</a>
41
+
42
+ ⟨throw expression⟩ operand of `throw` [[expr.throw]]
43
+
44
+ #### 5 argument <a id="defns.argument.templ">[[defns.argument.templ]]</a>
45
+
46
+ ⟨template instantiation⟩ *constant-expression*, *type-id*, or
47
+ *id-expression* in the comma-separated list bounded by the angle
48
+ brackets [[temp.arg]]
49
+
50
+ #### 6 block <a id="defns.block">[[defns.block]]</a>
51
+
52
+ ⟨execution⟩ wait for some condition (other than for the implementation
53
+ to execute the execution steps of the thread of execution) to be
54
+ satisfied before continuing execution past the blocking operation
55
+
56
+ #### 7 block <a id="defns.block.stmt">[[defns.block.stmt]]</a>
57
+
58
+ ⟨statement⟩ compound statement [[stmt.block]]
59
+
60
+ #### 8 conditionally-supported <a id="defns.cond.supp">[[defns.cond.supp]]</a>
61
 
62
  program construct that an implementation is not required to support
63
 
64
+ [*Note 1 to entry*: Each implementation documents all
65
+ conditionally-supported constructs that it does not
66
+ support. — *end note*]
67
+
68
+ #### 9 diagnostic message <a id="defns.diagnostic">[[defns.diagnostic]]</a>
69
 
70
  message belonging to an *implementation-defined* subset of the
71
  implementation’s output messages
72
 
73
+ #### 10 dynamic type <a id="defns.dynamic.type">[[defns.dynamic.type]]</a>
 
74
 
75
+ ⟨glvalue⟩ type of the most derived object [[intro.object]] to which the
76
+ glvalue refers
77
+
78
+ [*Example 1*: If a pointer [[dcl.ptr]] `p` whose static type is
79
  “pointer to class `B`” is pointing to an object of class `D`, derived
80
+ from `B` [[class.derived]], the dynamic type of the expression `*p` is
81
+ “`D`”. References [[dcl.ref]] are treated similarly. — *end example*]
 
82
 
83
+ #### 11 dynamic type <a id="defns.dynamic.type.prvalue">[[defns.dynamic.type.prvalue]]</a>
84
 
85
+ ⟨prvalue⟩ static type of the prvalue expression
86
+
87
+ #### 12 ill-formed program <a id="defns.ill.formed">[[defns.ill.formed]]</a>
88
+
89
+ program that is not well-formed [[defns.well.formed]]
90
+
91
+ #### 13 implementation-defined behavior <a id="defns.impl.defined">[[defns.impl.defined]]</a>
92
 
93
  behavior, for a well-formed program construct and correct data, that
94
  depends on the implementation and that each implementation documents
95
 
96
+ #### 14 implementation limits <a id="defns.impl.limits">[[defns.impl.limits]]</a>
97
+
98
  restrictions imposed upon programs by the implementation
99
 
100
+ #### 15 locale-specific behavior <a id="defns.locale.specific">[[defns.locale.specific]]</a>
101
+
102
  behavior that depends on local conventions of nationality, culture, and
103
  language that each implementation documents
104
 
105
+ #### 16 multibyte character <a id="defns.multibyte">[[defns.multibyte]]</a>
106
+
107
  sequence of one or more bytes representing a member of the extended
108
  character set of either the source or the execution environment
109
 
110
+ [*Note 1 to entry*: The extended character set is a superset of the
111
+ basic character set [[lex.charset]]. — *end note*]
112
 
113
+ #### 17 parameter <a id="defns.parameter">[[defns.parameter]]</a>
 
 
114
 
115
+ ⟨function or catch clause⟩ object or reference declared as part of a
116
+ function declaration or definition or in the catch clause of an
117
+ exception handler that acquires a value on entry to the function or
118
+ handler
119
 
120
+ #### 18 parameter <a id="defns.parameter.macro">[[defns.parameter.macro]]</a>
121
 
122
+ ⟨function-like macro⟩ identifier from the comma-separated list bounded
123
+ by the parentheses immediately following the macro name
124
 
125
+ #### 19 parameter <a id="defns.parameter.templ">[[defns.parameter.templ]]</a>
 
126
 
127
+ ⟨template⟩ member of a *template-parameter-list*
 
128
 
129
+ #### 20 signature <a id="defns.signature">[[defns.signature]]</a>
 
130
 
131
+ ⟨function⟩ name, parameter-type-list [[dcl.fct]], and enclosing
132
+ namespace (if any)
133
 
134
+ [*Note 1 to entry*: Signatures are used as a basis for name mangling
135
+ and linking. — *end note*]
 
136
 
137
+ #### 21 signature <a id="defns.signature.friend">[[defns.signature.friend]]</a>
 
 
138
 
139
+ ⟨non-template friend function with trailing *requires-clause*⟩ name,
140
+ parameter-type-list [[dcl.fct]], enclosing class, and trailing
141
+ *requires-clause* [[dcl.decl]]
142
+
143
+ #### 22 signature <a id="defns.signature.templ">[[defns.signature.templ]]</a>
144
+
145
+ ⟨function template⟩ name, parameter-type-list [[dcl.fct]], enclosing
146
+ namespace (if any), return type, *template-head*, and trailing
147
+ *requires-clause* [[dcl.decl]] (if any)
148
+
149
+ #### 23 signature <a id="defns.signature.templ.friend">[[defns.signature.templ.friend]]</a>
150
+
151
+ ⟨friend function template with constraint involving enclosing template parameters⟩
152
+ name, parameter-type-list [[dcl.fct]], return type, enclosing class,
153
+ *template-head*, and trailing *requires-clause* [[dcl.decl]] (if any)
154
+
155
+ #### 24 signature <a id="defns.signature.spec">[[defns.signature.spec]]</a>
156
+
157
+ ⟨function template specialization⟩ signature of the template of which it
158
+ is a specialization and its template arguments (whether explicitly
159
+ specified or deduced)
160
+
161
+ #### 25 signature <a id="defns.signature.member">[[defns.signature.member]]</a>
162
+
163
+ ⟨class member function⟩ name, parameter-type-list [[dcl.fct]], class of
164
+ which the function is a member, cv-qualifiers (if any), *ref-qualifier*
165
+ (if any), and trailing *requires-clause* [[dcl.decl]] (if any)
166
+
167
+ #### 26 signature <a id="defns.signature.member.templ">[[defns.signature.member.templ]]</a>
168
+
169
+ ⟨class member function template⟩ name, parameter-type-list [[dcl.fct]],
170
+ class of which the function is a member, cv-qualifiers (if any),
171
+ *ref-qualifier* (if any), return type (if any), *template-head*, and
172
+ trailing *requires-clause* [[dcl.decl]] (if any)
173
+
174
+ #### 27 signature <a id="defns.signature.member.spec">[[defns.signature.member.spec]]</a>
175
+
176
+ ⟨class member function template specialization⟩ signature of the member
177
+ function template of which it is a specialization and its template
178
+ arguments (whether explicitly specified or deduced)
179
+
180
+ #### 28 static type <a id="defns.static.type">[[defns.static.type]]</a>
181
+
182
+ type of an expression [[basic.types]] resulting from analysis of the
183
  program without considering execution semantics
184
 
185
+ [*Note 1 to entry*: The static type of an expression depends only on
186
+ the form of the program in which the expression appears, and does not
187
+ change while the program is executing. — *end note*]
188
+
189
+ #### 29 unblock <a id="defns.unblock">[[defns.unblock]]</a>
190
 
191
  satisfy a condition that one or more blocked threads of execution are
192
  waiting for
193
 
194
+ #### 30 undefined behavior <a id="defns.undefined">[[defns.undefined]]</a>
195
 
196
+ behavior for which this document imposes no requirements
197
+
198
+ [*Note 1 to entry*: Undefined behavior may be expected when this
199
+ document omits any explicit definition of behavior or when a program
200
  uses an erroneous construct or erroneous data. Permissible undefined
201
  behavior ranges from ignoring the situation completely with
202
  unpredictable results, to behaving during translation or program
203
  execution in a documented manner characteristic of the environment (with
204
  or without the issuance of a diagnostic message), to terminating a
205
  translation or execution (with the issuance of a diagnostic message).
206
  Many erroneous program constructs do not engender undefined behavior;
207
  they are required to be diagnosed. Evaluation of a constant expression
208
+ never exhibits behavior explicitly specified as undefined in [[intro]]
209
+ through [[cpp]] of this document [[expr.const]]. — *end note*]
210
+
211
+ #### 31 unspecified behavior <a id="defns.unspecified">[[defns.unspecified]]</a>
212
 
213
  behavior, for a well-formed program construct and correct data, that
214
  depends on the implementation
215
 
216
+ [*Note 1 to entry*: The implementation is not required to document
217
+ which behavior occurs. The range of possible behaviors is usually
218
+ delineated by this document. — *end note*]
219
+
220
+ #### 32 well-formed program <a id="defns.well.formed">[[defns.well.formed]]</a>
221
 
222
  C++ program constructed according to the syntax rules, diagnosable
223
+ semantic rules, and the one-definition rule [[basic.def.odr]]
224