From Jason Turner

[basic.align]

C++14 → C++17 14.4 KB 127 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/tmpcmodyv8u/{from.md → to.md} +72 -41
tmp/tmpcmodyv8u/{from.md → to.md} RENAMED
@@ -14,30 +14,40 @@ equal to the greatest alignment supported by the implementation in all
14
  contexts, which is equal to `alignof(std::max_align_t)` (
15
  [[support.types]]). The alignment required for a type might be different
16
  when it is used as the type of a complete object and when it is used as
17
  the type of a subobject.
18
 
 
 
19
  ``` cpp
20
  struct B { long double d; };
21
- struct D : virtual B { char c; }
22
  ```
23
 
24
  When `D` is the type of a complete object, it will have a subobject of
25
  type `B`, so it must be aligned appropriately for a `long double`. If
26
  `D` appears as a subobject of another object that also has `B` as a
27
  virtual base class, the `B` subobject might be part of a different
28
- subobject, reducing the alignment requirements on the `D` subobject. The
29
- result of the `alignof` operator reflects the alignment requirement of
30
- the type in the complete-object case.
 
 
 
31
 
32
  An *extended alignment* is represented by an alignment greater than
33
- `alignof(std::max_align_t)`. It is implementation-defined whether any
34
  extended alignments are supported and the contexts in which they are
35
  supported ([[dcl.align]]). A type having an extended alignment
36
- requirement is an *over-aligned type*. every over-aligned type is or
37
- contains a class type to which extended alignment applies (possibly
38
- through a non-static data member).
 
 
 
 
 
39
 
40
  Alignments are represented as values of the type `std::size_t`. Valid
41
  alignments include only those values returned by an `alignof` expression
42
  for the fundamental types plus an additional *implementation-defined*
43
  set of values, which may be empty. Every alignment value shall be a
@@ -49,30 +59,30 @@ that satisfies an alignment requirement also satisfies any weaker valid
49
  alignment requirement.
50
 
51
  The alignment requirement of a complete type can be queried using an
52
  `alignof` expression ([[expr.alignof]]). Furthermore, the narrow
53
  character types ([[basic.fundamental]]) shall have the weakest
54
- alignment requirement. This enables the narrow character types to be
55
- used as the underlying type for an aligned memory area ([[dcl.align]]).
 
 
 
56
 
57
  Comparing alignments is meaningful and provides the obvious results:
58
 
59
  - Two alignments are equal when their numeric values are equal.
60
  - Two alignments are different when their numeric values are not equal.
61
  - When an alignment is larger than another it represents a stricter
62
  alignment.
63
 
64
- The runtime pointer alignment function ([[ptr.align]]) can be used to
65
- obtain an aligned pointer within a buffer; the aligned-storage templates
66
- in the library ([[meta.trans.other]]) can be used to obtain aligned
67
- storage.
68
 
69
  If a request for a specific extended alignment in a specific context is
70
  not supported by an implementation, the program is ill-formed.
71
- Additionally, a request for runtime allocation of dynamic storage for
72
- which the requested alignment cannot be honored shall be treated as an
73
- allocation failure.
74
 
75
  <!-- Link reference definitions -->
76
  [bad.alloc]: language.md#bad.alloc
77
  [basic]: #basic
78
  [basic.align]: #basic.align
@@ -101,12 +111,13 @@ allocation failure.
101
  [basic.scope.namespace]: #basic.scope.namespace
102
  [basic.scope.pdecl]: #basic.scope.pdecl
103
  [basic.scope.proto]: #basic.scope.proto
104
  [basic.scope.temp]: #basic.scope.temp
105
  [basic.start]: #basic.start
106
- [basic.start.init]: #basic.start.init
107
  [basic.start.main]: #basic.start.main
 
108
  [basic.start.term]: #basic.start.term
109
  [basic.stc]: #basic.stc
110
  [basic.stc.auto]: #basic.stc.auto
111
  [basic.stc.dynamic]: #basic.stc.dynamic
112
  [basic.stc.dynamic.allocation]: #basic.stc.dynamic.allocation
@@ -118,10 +129,11 @@ allocation failure.
118
  [basic.type.qualifier]: #basic.type.qualifier
119
  [basic.types]: #basic.types
120
  [class]: class.md#class
121
  [class.access]: class.md#class.access
122
  [class.base.init]: special.md#class.base.init
 
123
  [class.cdtor]: special.md#class.cdtor
124
  [class.conv.fct]: special.md#class.conv.fct
125
  [class.copy]: special.md#class.copy
126
  [class.ctor]: special.md#class.ctor
127
  [class.derived]: class.md#class.derived
@@ -148,33 +160,36 @@ allocation failure.
148
  [conv.lval]: conv.md#conv.lval
149
  [conv.mem]: conv.md#conv.mem
150
  [conv.prom]: conv.md#conv.prom
151
  [conv.ptr]: conv.md#conv.ptr
152
  [conv.qual]: conv.md#conv.qual
 
 
 
153
  [dcl.align]: dcl.md#dcl.align
154
  [dcl.array]: dcl.md#dcl.array
155
  [dcl.dcl]: dcl.md#dcl.dcl
156
  [dcl.decl]: dcl.md#dcl.decl
157
  [dcl.enum]: dcl.md#dcl.enum
158
  [dcl.fct]: dcl.md#dcl.fct
159
  [dcl.fct.def]: dcl.md#dcl.fct.def
160
  [dcl.fct.default]: dcl.md#dcl.fct.default
161
- [dcl.fct.spec]: dcl.md#dcl.fct.spec
162
  [dcl.init]: dcl.md#dcl.init
163
  [dcl.init.aggr]: dcl.md#dcl.init.aggr
164
  [dcl.init.ref]: dcl.md#dcl.init.ref
 
165
  [dcl.link]: dcl.md#dcl.link
166
  [dcl.mptr]: dcl.md#dcl.mptr
167
  [dcl.name]: dcl.md#dcl.name
168
  [dcl.ptr]: dcl.md#dcl.ptr
169
  [dcl.ref]: dcl.md#dcl.ref
170
  [dcl.spec]: dcl.md#dcl.spec
171
  [dcl.stc]: dcl.md#dcl.stc
172
- [dcl.type.cv]: dcl.md#dcl.type.cv
173
  [dcl.type.elab]: dcl.md#dcl.type.elab
174
  [dcl.type.simple]: dcl.md#dcl.type.simple
175
  [dcl.typedef]: dcl.md#dcl.typedef
 
176
  [diff.cpp11.basic]: compatibility.md#diff.cpp11.basic
177
  [except]: except.md#except
178
  [except.handle]: except.md#except.handle
179
  [except.spec]: except.md#except.spec
180
  [except.terminate]: except.md#except.terminate
@@ -188,26 +203,35 @@ allocation failure.
188
  [expr.comma]: expr.md#expr.comma
189
  [expr.cond]: expr.md#expr.cond
190
  [expr.const]: expr.md#expr.const
191
  [expr.delete]: expr.md#expr.delete
192
  [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 
193
  [expr.mptr.oper]: expr.md#expr.mptr.oper
194
  [expr.new]: expr.md#expr.new
 
 
195
  [expr.prim]: expr.md#expr.prim
196
- [expr.prim.general]: expr.md#expr.prim.general
 
197
  [expr.pseudo]: expr.md#expr.pseudo
198
  [expr.ref]: expr.md#expr.ref
 
 
199
  [expr.sizeof]: expr.md#expr.sizeof
200
  [expr.static.cast]: expr.md#expr.static.cast
 
201
  [expr.type.conv]: expr.md#expr.type.conv
202
  [expr.typeid]: expr.md#expr.typeid
 
203
  [fig:categories]: #fig:categories
204
  [headers]: library.md#headers
205
  [intro.execution]: intro.md#intro.execution
206
  [intro.memory]: intro.md#intro.memory
207
  [intro.multithread]: intro.md#intro.multithread
208
  [intro.object]: intro.md#intro.object
 
209
  [lex]: lex.md#lex
210
  [lex.name]: lex.md#lex.name
211
  [locale]: localization.md#locale
212
  [meta.trans.other]: utilities.md#meta.trans.other
213
  [multibyte.strings]: library.md#multibyte.strings
@@ -216,10 +240,13 @@ allocation failure.
216
  [namespace.memdef]: dcl.md#namespace.memdef
217
  [namespace.qual]: #namespace.qual
218
  [namespace.udecl]: dcl.md#namespace.udecl
219
  [namespace.udir]: dcl.md#namespace.udir
220
  [new.delete]: language.md#new.delete
 
 
 
221
  [new.handler]: language.md#new.handler
222
  [over]: over.md#over
223
  [over.literal]: over.md#over.literal
224
  [over.load]: over.md#over.load
225
  [over.match]: over.md#over.match
@@ -230,24 +257,25 @@ allocation failure.
230
  [set.new.handler]: language.md#set.new.handler
231
  [stmt.block]: stmt.md#stmt.block
232
  [stmt.dcl]: stmt.md#stmt.dcl
233
  [stmt.expr]: stmt.md#stmt.expr
234
  [stmt.goto]: stmt.md#stmt.goto
 
235
  [stmt.label]: stmt.md#stmt.label
236
  [stmt.return]: stmt.md#stmt.return
237
  [stmt.select]: stmt.md#stmt.select
238
  [support.dynamic]: language.md#support.dynamic
239
  [support.limits]: language.md#support.limits
240
  [support.runtime]: language.md#support.runtime
241
  [support.start.term]: language.md#support.start.term
242
  [support.types]: language.md#support.types
243
  [tab:relations.on.const.and.volatile]: #tab:relations.on.const.and.volatile
244
  [temp]: temp.md#temp
245
- [temp.arg.nontype]: temp.md#temp.arg.nontype
246
- [temp.arg.type]: temp.md#temp.arg.type
247
  [temp.class.spec]: temp.md#temp.class.spec
 
248
  [temp.dep]: temp.md#temp.dep
 
249
  [temp.explicit]: temp.md#temp.explicit
250
  [temp.fct]: temp.md#temp.fct
251
  [temp.local]: temp.md#temp.local
252
  [temp.mem.func]: temp.md#temp.mem.func
253
  [temp.names]: temp.md#temp.names
@@ -286,39 +314,39 @@ allocation failure.
286
  `Y`’s definition or whether `X`’s definition appears in a namespace
287
  scope enclosing `Y`’s definition ([[class.nest]]).
288
 
289
  [^7]: That is, an unqualified name that occurs, for instance, in a type
290
  in the *parameter-declaration-clause* or in the
291
- *exception-specification*.
292
 
293
  [^8]: This lookup applies whether the member function is defined within
294
  the definition of class `X` or whether the member function is
295
  defined in a namespace scope enclosing `X`’s definition.
296
 
297
  [^9]: Lookups in which function names are ignored include names
298
  appearing in a *nested-name-specifier*, an
299
  *elaborated-type-specifier*, or a *base-specifier*.
300
 
301
- [^10]: A class template always has external linkage, and the
302
- requirements of  [[temp.arg.type]] and  [[temp.arg.nontype]] ensure
303
- that the template arguments will also have appropriate linkage.
304
 
305
  [^11]: A non-local variable with static storage duration having
306
- initialization with side-effects must be initialized even if it is
307
- not odr-used ([[basic.def.odr]],  [[basic.stc.static]]).
 
308
 
309
- [^12]: The intent is to have `operator new()` implementable by calling
 
 
 
310
  `std::malloc()` or `std::calloc()`, so the rules are substantially
311
  the same. C++differs from C in requiring a zero request to return a
312
  non-null pointer.
313
 
314
- [^13]: This deallocation function precludes use of an allocation
315
- function `void operator new(std::size_t, std::size_t)` as a
316
- placement allocation function ([[diff.cpp11.basic]]).
317
-
318
- [^14]: Some implementations might define that copying an invalid pointer
319
- value causes a system-generated runtime fault.
320
 
321
  [^15]: This section does not impose restrictions on indirection through
322
  pointers to memory not allocated by `::operator new`. This maintains
323
  the ability of many C++implementations to use binary libraries and
324
  components written in other languages. In particular, this applies
@@ -344,12 +372,12 @@ allocation failure.
344
  of ISO/IEC 9899 Programming Language C.
345
 
346
  [^21]: The size and layout of an instance of an incompletely-defined
347
  object type is unknown.
348
 
349
- [^22]: that is, large enough to contain any value in the range of
350
- `INT_MIN` and `INT_MAX`, as defined in the header `<climits>`.
351
 
352
  [^23]: See  [[dcl.type.simple]] regarding the correspondence between
353
  types and the sequences of *type-specifier*s that designate them.
354
 
355
  [^24]: This implies that unsigned arithmetic does not overflow because a
@@ -357,11 +385,11 @@ allocation failure.
357
  type is reduced modulo the number that is one greater than the
358
  largest value that can be represented by the resulting unsigned
359
  integer type.
360
 
361
  [^25]: Using a `bool` value in ways described by this International
362
- Standard as “undefined,” such as by examining the value of an
363
  uninitialized automatic object, might cause it to behave as if it is
364
  neither `true` nor `false`.
365
 
366
  [^26]: Therefore, enumerations ([[dcl.enum]]) are not integral;
367
  however, enumerations can be promoted to integral types as specified
@@ -375,11 +403,14 @@ allocation failure.
375
  Information Processing Systems*.)
376
 
377
  [^28]: Static class members are objects or functions, and pointers to
378
  them are ordinary pointers to objects or functions.
379
 
380
- [^29]: The same representation and alignment requirements are meant to
 
 
 
381
  imply interchangeability as arguments to functions, return values
382
  from functions, and non-static data members of unions.
383
 
384
- [^30]: The intent of this list is to specify those circumstances in
385
  which an object may or may not be aliased.
 
14
  contexts, which is equal to `alignof(std::max_align_t)` (
15
  [[support.types]]). The alignment required for a type might be different
16
  when it is used as the type of a complete object and when it is used as
17
  the type of a subobject.
18
 
19
+ [*Example 1*:
20
+
21
  ``` cpp
22
  struct B { long double d; };
23
+ struct D : virtual B { char c; };
24
  ```
25
 
26
  When `D` is the type of a complete object, it will have a subobject of
27
  type `B`, so it must be aligned appropriately for a `long double`. If
28
  `D` appears as a subobject of another object that also has `B` as a
29
  virtual base class, the `B` subobject might be part of a different
30
+ subobject, reducing the alignment requirements on the `D` subobject.
31
+
32
+ — *end example*]
33
+
34
+ The result of the `alignof` operator reflects the alignment requirement
35
+ of the type in the complete-object case.
36
 
37
  An *extended alignment* is represented by an alignment greater than
38
+ `alignof(std::max_align_t)`. It is *implementation-defined* whether any
39
  extended alignments are supported and the contexts in which they are
40
  supported ([[dcl.align]]). A type having an extended alignment
41
+ requirement is an *over-aligned type*.
42
+
43
+ [*Note 1*: Every over-aligned type is or contains a class type to which
44
+ extended alignment applies (possibly through a non-static data
45
+ member). — *end note*]
46
+
47
+ A *new-extended alignment* is represented by an alignment greater than
48
+ `__STDCPP_DEFAULT_NEW_ALIGNMENT__` ([[cpp.predefined]]).
49
 
50
  Alignments are represented as values of the type `std::size_t`. Valid
51
  alignments include only those values returned by an `alignof` expression
52
  for the fundamental types plus an additional *implementation-defined*
53
  set of values, which may be empty. Every alignment value shall be a
 
59
  alignment requirement.
60
 
61
  The alignment requirement of a complete type can be queried using an
62
  `alignof` expression ([[expr.alignof]]). Furthermore, the narrow
63
  character types ([[basic.fundamental]]) shall have the weakest
64
+ alignment requirement.
65
+
66
+ [*Note 2*: This enables the narrow character types to be used as the
67
+ underlying type for an aligned memory area (
68
+ [[dcl.align]]). — *end note*]
69
 
70
  Comparing alignments is meaningful and provides the obvious results:
71
 
72
  - Two alignments are equal when their numeric values are equal.
73
  - Two alignments are different when their numeric values are not equal.
74
  - When an alignment is larger than another it represents a stricter
75
  alignment.
76
 
77
+ [*Note 3*: The runtime pointer alignment function ([[ptr.align]]) can
78
+ be used to obtain an aligned pointer within a buffer; the
79
+ aligned-storage templates in the library ([[meta.trans.other]]) can be
80
+ used to obtain aligned storage. — *end note*]
81
 
82
  If a request for a specific extended alignment in a specific context is
83
  not supported by an implementation, the program is ill-formed.
 
 
 
84
 
85
  <!-- Link reference definitions -->
86
  [bad.alloc]: language.md#bad.alloc
87
  [basic]: #basic
88
  [basic.align]: #basic.align
 
111
  [basic.scope.namespace]: #basic.scope.namespace
112
  [basic.scope.pdecl]: #basic.scope.pdecl
113
  [basic.scope.proto]: #basic.scope.proto
114
  [basic.scope.temp]: #basic.scope.temp
115
  [basic.start]: #basic.start
116
+ [basic.start.dynamic]: #basic.start.dynamic
117
  [basic.start.main]: #basic.start.main
118
+ [basic.start.static]: #basic.start.static
119
  [basic.start.term]: #basic.start.term
120
  [basic.stc]: #basic.stc
121
  [basic.stc.auto]: #basic.stc.auto
122
  [basic.stc.dynamic]: #basic.stc.dynamic
123
  [basic.stc.dynamic.allocation]: #basic.stc.dynamic.allocation
 
129
  [basic.type.qualifier]: #basic.type.qualifier
130
  [basic.types]: #basic.types
131
  [class]: class.md#class
132
  [class.access]: class.md#class.access
133
  [class.base.init]: special.md#class.base.init
134
+ [class.bit]: class.md#class.bit
135
  [class.cdtor]: special.md#class.cdtor
136
  [class.conv.fct]: special.md#class.conv.fct
137
  [class.copy]: special.md#class.copy
138
  [class.ctor]: special.md#class.ctor
139
  [class.derived]: class.md#class.derived
 
160
  [conv.lval]: conv.md#conv.lval
161
  [conv.mem]: conv.md#conv.mem
162
  [conv.prom]: conv.md#conv.prom
163
  [conv.ptr]: conv.md#conv.ptr
164
  [conv.qual]: conv.md#conv.qual
165
+ [conv.rval]: conv.md#conv.rval
166
+ [cpp.predefined]: cpp.md#cpp.predefined
167
+ [cstddef.syn]: language.md#cstddef.syn
168
  [dcl.align]: dcl.md#dcl.align
169
  [dcl.array]: dcl.md#dcl.array
170
  [dcl.dcl]: dcl.md#dcl.dcl
171
  [dcl.decl]: dcl.md#dcl.decl
172
  [dcl.enum]: dcl.md#dcl.enum
173
  [dcl.fct]: dcl.md#dcl.fct
174
  [dcl.fct.def]: dcl.md#dcl.fct.def
175
  [dcl.fct.default]: dcl.md#dcl.fct.default
 
176
  [dcl.init]: dcl.md#dcl.init
177
  [dcl.init.aggr]: dcl.md#dcl.init.aggr
178
  [dcl.init.ref]: dcl.md#dcl.init.ref
179
+ [dcl.inline]: dcl.md#dcl.inline
180
  [dcl.link]: dcl.md#dcl.link
181
  [dcl.mptr]: dcl.md#dcl.mptr
182
  [dcl.name]: dcl.md#dcl.name
183
  [dcl.ptr]: dcl.md#dcl.ptr
184
  [dcl.ref]: dcl.md#dcl.ref
185
  [dcl.spec]: dcl.md#dcl.spec
186
  [dcl.stc]: dcl.md#dcl.stc
 
187
  [dcl.type.elab]: dcl.md#dcl.type.elab
188
  [dcl.type.simple]: dcl.md#dcl.type.simple
189
  [dcl.typedef]: dcl.md#dcl.typedef
190
+ [depr.static_constexpr]: future.md#depr.static_constexpr
191
  [diff.cpp11.basic]: compatibility.md#diff.cpp11.basic
192
  [except]: except.md#except
193
  [except.handle]: except.md#except.handle
194
  [except.spec]: except.md#except.spec
195
  [except.terminate]: except.md#except.terminate
 
203
  [expr.comma]: expr.md#expr.comma
204
  [expr.cond]: expr.md#expr.cond
205
  [expr.const]: expr.md#expr.const
206
  [expr.delete]: expr.md#expr.delete
207
  [expr.dynamic.cast]: expr.md#expr.dynamic.cast
208
+ [expr.eq]: expr.md#expr.eq
209
  [expr.mptr.oper]: expr.md#expr.mptr.oper
210
  [expr.new]: expr.md#expr.new
211
+ [expr.post.incr]: expr.md#expr.post.incr
212
+ [expr.pre.incr]: expr.md#expr.pre.incr
213
  [expr.prim]: expr.md#expr.prim
214
+ [expr.prim.id]: expr.md#expr.prim.id
215
+ [expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
216
  [expr.pseudo]: expr.md#expr.pseudo
217
  [expr.ref]: expr.md#expr.ref
218
+ [expr.reinterpret.cast]: expr.md#expr.reinterpret.cast
219
+ [expr.rel]: expr.md#expr.rel
220
  [expr.sizeof]: expr.md#expr.sizeof
221
  [expr.static.cast]: expr.md#expr.static.cast
222
+ [expr.sub]: expr.md#expr.sub
223
  [expr.type.conv]: expr.md#expr.type.conv
224
  [expr.typeid]: expr.md#expr.typeid
225
+ [expr.unary.op]: expr.md#expr.unary.op
226
  [fig:categories]: #fig:categories
227
  [headers]: library.md#headers
228
  [intro.execution]: intro.md#intro.execution
229
  [intro.memory]: intro.md#intro.memory
230
  [intro.multithread]: intro.md#intro.multithread
231
  [intro.object]: intro.md#intro.object
232
+ [intro.races]: intro.md#intro.races
233
  [lex]: lex.md#lex
234
  [lex.name]: lex.md#lex.name
235
  [locale]: localization.md#locale
236
  [meta.trans.other]: utilities.md#meta.trans.other
237
  [multibyte.strings]: library.md#multibyte.strings
 
240
  [namespace.memdef]: dcl.md#namespace.memdef
241
  [namespace.qual]: #namespace.qual
242
  [namespace.udecl]: dcl.md#namespace.udecl
243
  [namespace.udir]: dcl.md#namespace.udir
244
  [new.delete]: language.md#new.delete
245
+ [new.delete.array]: language.md#new.delete.array
246
+ [new.delete.placement]: language.md#new.delete.placement
247
+ [new.delete.single]: language.md#new.delete.single
248
  [new.handler]: language.md#new.handler
249
  [over]: over.md#over
250
  [over.literal]: over.md#over.literal
251
  [over.load]: over.md#over.load
252
  [over.match]: over.md#over.match
 
257
  [set.new.handler]: language.md#set.new.handler
258
  [stmt.block]: stmt.md#stmt.block
259
  [stmt.dcl]: stmt.md#stmt.dcl
260
  [stmt.expr]: stmt.md#stmt.expr
261
  [stmt.goto]: stmt.md#stmt.goto
262
+ [stmt.if]: stmt.md#stmt.if
263
  [stmt.label]: stmt.md#stmt.label
264
  [stmt.return]: stmt.md#stmt.return
265
  [stmt.select]: stmt.md#stmt.select
266
  [support.dynamic]: language.md#support.dynamic
267
  [support.limits]: language.md#support.limits
268
  [support.runtime]: language.md#support.runtime
269
  [support.start.term]: language.md#support.start.term
270
  [support.types]: language.md#support.types
271
  [tab:relations.on.const.and.volatile]: #tab:relations.on.const.and.volatile
272
  [temp]: temp.md#temp
 
 
273
  [temp.class.spec]: temp.md#temp.class.spec
274
+ [temp.deduct.guide]: temp.md#temp.deduct.guide
275
  [temp.dep]: temp.md#temp.dep
276
+ [temp.expl.spec]: temp.md#temp.expl.spec
277
  [temp.explicit]: temp.md#temp.explicit
278
  [temp.fct]: temp.md#temp.fct
279
  [temp.local]: temp.md#temp.local
280
  [temp.mem.func]: temp.md#temp.mem.func
281
  [temp.names]: temp.md#temp.names
 
314
  `Y`’s definition or whether `X`’s definition appears in a namespace
315
  scope enclosing `Y`’s definition ([[class.nest]]).
316
 
317
  [^7]: That is, an unqualified name that occurs, for instance, in a type
318
  in the *parameter-declaration-clause* or in the
319
+ *noexcept-specifier*.
320
 
321
  [^8]: This lookup applies whether the member function is defined within
322
  the definition of class `X` or whether the member function is
323
  defined in a namespace scope enclosing `X`’s definition.
324
 
325
  [^9]: Lookups in which function names are ignored include names
326
  appearing in a *nested-name-specifier*, an
327
  *elaborated-type-specifier*, or a *base-specifier*.
328
 
329
+ [^10]: A class template has the linkage of the innermost enclosing class
330
+ or namespace in which it is declared.
 
331
 
332
  [^11]: A non-local variable with static storage duration having
333
+ initialization with side effects is initialized in this case, even
334
+ if it is not itself odr-used ([[basic.def.odr]], 
335
+ [[basic.stc.static]]).
336
 
337
+ [^12]: Some implementations might define that copying an invalid pointer
338
+ value causes a system-generated runtime fault.
339
+
340
+ [^13]: The intent is to have `operator new()` implementable by calling
341
  `std::malloc()` or `std::calloc()`, so the rules are substantially
342
  the same. C++differs from C in requiring a zero request to return a
343
  non-null pointer.
344
 
345
+ [^14]: The global `operator delete(void*, std::size_t)` precludes use of
346
+ an allocation function `void operator new(std::size_t, std::size_t)`
347
+ as a placement allocation function ([[diff.cpp11.basic]]).
 
 
 
348
 
349
  [^15]: This section does not impose restrictions on indirection through
350
  pointers to memory not allocated by `::operator new`. This maintains
351
  the ability of many C++implementations to use binary libraries and
352
  components written in other languages. In particular, this applies
 
372
  of ISO/IEC 9899 Programming Language C.
373
 
374
  [^21]: The size and layout of an instance of an incompletely-defined
375
  object type is unknown.
376
 
377
+ [^22]: `int` must also be large enough to contain any value in the range
378
+ \[`INT_MIN`, `INT_MAX`\], as defined in the header `<climits>`.
379
 
380
  [^23]: See  [[dcl.type.simple]] regarding the correspondence between
381
  types and the sequences of *type-specifier*s that designate them.
382
 
383
  [^24]: This implies that unsigned arithmetic does not overflow because a
 
385
  type is reduced modulo the number that is one greater than the
386
  largest value that can be represented by the resulting unsigned
387
  integer type.
388
 
389
  [^25]: Using a `bool` value in ways described by this International
390
+ Standard as “undefined”, such as by examining the value of an
391
  uninitialized automatic object, might cause it to behave as if it is
392
  neither `true` nor `false`.
393
 
394
  [^26]: Therefore, enumerations ([[dcl.enum]]) are not integral;
395
  however, enumerations can be promoted to integral types as specified
 
403
  Information Processing Systems*.)
404
 
405
  [^28]: Static class members are objects or functions, and pointers to
406
  them are ordinary pointers to objects or functions.
407
 
408
+ [^29]: For an object that is not within its lifetime, this is the first
409
+ byte in memory that it will occupy or used to occupy.
410
+
411
+ [^30]: The same representation and alignment requirements are meant to
412
  imply interchangeability as arguments to functions, return values
413
  from functions, and non-static data members of unions.
414
 
415
+ [^31]: The intent of this list is to specify those circumstances in
416
  which an object may or may not be aliased.