[basic.contract] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpg2w3n7mm/{from.md → to.md} +662 -0

tmp/tmpg2w3n7mm/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,662 @@

+## Contract assertions <a id="basic.contract">[[basic.contract]]</a>
+### General <a id="basic.contract.general">[[basic.contract.general]]</a>
+*Contract assertions* allow the programmer to specify properties of the
+state of the program that are expected to hold at certain points during
+execution. Contract assertions are introduced by
+*precondition-specifier*s, *postcondition-specifier*s
+[[dcl.contract.func]], and *assertion-statement*s
+[[stmt.contract.assert]].
+Each contract assertion has a *contract-assertion predicate*, which is
+an expression of type `bool`.
+[*Note 1*: The value of the predicate is used to identify program
+states that are expected. — *end note*]
+An invocation of the macro `va_start` [[cstdarg.syn]] shall not be a
+subexpression of the predicate of a contract assertion, no diagnostic
+required.
+[*Note 2*: Within the predicate of a contract assertion,
+*id-expression*s referring to variables declared outside the contract
+assertion are `const` [[expr.prim.id.unqual]], `this` is a pointer to
+`const` [[expr.prim.this]], and the result object can be named if a
+*result-name-introducer* [[dcl.contract.res]] has been
+specified. — *end note*]
+### Evaluation <a id="basic.contract.eval">[[basic.contract.eval]]</a>
+An evaluation of a contract assertion uses one of the following four
+*evaluation semantics*: *ignore*, *observe*, *enforce*, or
+*quick-enforce*. Observe, enforce, and quick-enforce are *checking
+semantics*; enforce and quick-enforce are *terminating semantics*.
+It is *implementation-defined* which evaluation semantic is used for any
+given evaluation of a contract assertion.
+[*Note 1*: The range and flexibility of available choices of evaluation
+semantics depends on the implementation and need not allow all four
+evaluation semantics as possibilities. The evaluation semantics can
+differ for different evaluations of the same contract assertion,
+including evaluations during constant evaluation. — *end note*]
+*Recommended practice:* An implementation should provide the option to
+translate a program such that all evaluations of contract assertions use
+the ignore semantic as well as the option to translate a program such
+that all evaluations of contract assertions use the enforce semantic. By
+default, evaluations of contract assertions should use the enforce
+semantic.
+The evaluation of a contract assertion using the ignore semantic has no
+effect.
+[*Note 2*: The predicate is potentially evaluated [[basic.def.odr]],
+but not evaluated. — *end note*]
+The evaluation A of a contract assertion using a checking semantic
+determines the value of the predicate. It is unspecified whether the
+predicate is evaluated. Let B be the value that would result from
+evaluating the predicate.
+[*Note 3*:
+To determine whether a predicate would evaluate to `true` or `false`, an
+alternative evaluation that produces the same value as the predicate but
+has no side effects can occur.
+[*Example 1*:
+``` cpp
+struct S {
+  mutable int g = 5;
+} s;
+void f()
+  pre(( s.g++, false ));    // #1
+void g()
+{
+  f();  // Increment of s.g might not occur, even if #1 uses a checking semantic.
+}
+```
+— *end example*]
+— *end note*]
+There is an observable checkpoint [[intro.abstract]] C that happens
+before A such that any other operation O that happens before A also
+happens before C.
+A *contract violation* occurs when
+- B is `false`,
+- the evaluation of the predicate exits via an exception, or
+- the evaluation of the predicate is performed in a context that is
+  manifestly constant-evaluated [[expr.const]] and the predicate is not
+  a core constant expression.
+[*Note 4*: If B is `true`, no contract violation occurs and control
+flow continues normally after the point of evaluation of the contract
+assertion. The evaluation of the predicate can fail to produce a value
+without causing a contract violation, for example, by calling `longjmp`
+[[csetjmp.syn]] or terminating the program. — *end note*]
+If a contract violation occurs in a context that is manifestly
+constant-evaluated [[expr.const]], and the evaluation semantic is a
+terminating semantic, the program is ill-formed.
+[*Note 5*: A diagnostic is produced if the evaluation semantic is
+observe [[intro.compliance]]. — *end note*]
+[*Note 6*:
+Different evaluation semantics chosen for the same contract assertion in
+different translation units can result in violations of the
+one-definition rule [[basic.def.odr]] when a contract assertion has side
+effects that alter the value produced by a constant expression.
+[*Example 2*:
+``` cpp
+constexpr int f(int i)
+{
+  contract_assert((++const_cast<int&>(i), true));
+  return i;
+}
+inline void g()
+{
+  int a[f(1)];  // size dependent on the evaluation semantic of contract_assert above
+}
+```
+— *end example*]
+— *end note*]
+When the program is *contract-terminated*, it is
+*implementation-defined* (depending on context) whether
+- `std::terminate` is called,
+- `std::abort` is called, or
+- execution is terminated. \[*Note 7*: No further execution steps occur
+  [[intro.progress]]. — *end note*]
+[*Note 8*: Performing the actions of `std::terminate` or `std::abort`
+without actually making a library call is a conforming implementation of
+contract-termination [[intro.abstract]]. — *end note*]
+If a contract violation occurs in a context that is not manifestly
+constant-evaluated and the evaluation semantic is quick-enforce, the
+program is contract-terminated.
+If a contract violation occurs in a context that is not manifestly
+constant-evaluated and the evaluation semantic is enforce or observe,
+the contract-violation handler [[basic.contract.handler]] is invoked
+with an lvalue referring to an object `v` of type
+`const std::contracts::contract_violation`
+[[support.contract.violation]] containing information about the contract
+violation. Storage for `v` is allocated in an unspecified manner except
+as noted in [[basic.stc.dynamic.allocation]]. The lifetime of `v`
+persists for the duration of the invocation of the contract-violation
+handler.
+If the contract violation occurred because the evaluation of the
+predicate exited via an exception, the contract-violation handler is
+invoked from within an active implicit handler for that exception
+[[except.handle]]. If the contract-violation handler returns normally
+and the evaluation semantic is observe, that implicit handler is no
+longer considered active.
+[*Note 9*: The exception can be inspected or rethrown within the
+contract-violation handler. — *end note*]
+If the contract-violation handler returns normally and the evaluation
+semantic is enforce, the program is contract-terminated; if violation
+occurred as the result of an uncaught exception from the evaluation of
+the predicate, the implicit handler remains active when contract
+termination occurs.
+[*Note 10*: If the contract-violation handler returns normally and the
+evaluation semantic is observe, control flow continues normally after
+the point of evaluation of the contract assertion. — *end note*]
+There is an observable checkpoint [[intro.abstract]] C that happens
+after the contract-violation handler returns normally such that any
+other operation O that happens after the contract-violation handler
+returns also happens after C.
+[*Note 11*: The terminating semantics terminate the program if
+execution would otherwise continue normally past a contract violation:
+the enforce semantic provides the opportunity to log information about
+the contract violation before terminating the program or to throw an
+exception to avoid termination, and the quick-enforce semantic is
+intended to terminate the program as soon as possible as well as to
+minimize the impact of contract checks on the generated code size.
+Conversely, the observe semantic provides the opportunity to log
+information about the contract violation without having to terminate the
+program. — *end note*]
+If a contract-violation handler invoked from the evaluation of a
+function contract assertion [[dcl.contract.func]] exits via an
+exception, the behavior is as if the function body exits via that same
+exception.
+[*Note 12*: A *function-try-block* [[except.pre]] is the function body
+when present and thus does not have an opportunity to catch the
+exception. If the function has a non-throwing exception specification,
+the function `std::terminate` is invoked
+[[except.terminate]]. — *end note*]
+[*Note 13*: If a contract-violation handler invoked from an
+*assertion-statement* [[stmt.contract.assert]] exits via an exception,
+the search for a handler continues from the execution of that
+statement. — *end note*]
+To *evaluate in sequence* a list R of contract assertions:
+- Construct a list of contract assertions S such that
+  - all elements of R are in S,
+  - each element of R may be repeated an *implementation-defined* number
+    of times within S, and
+  - if a contract assertion A precedes another contract assertion B in
+    R, then the first occurrence of A precedes the first occurrence of B
+    in S.
+- Evaluate each element of S such that, if a contract assertion A
+  precedes a contract assertion B in S, then the evaluation of A is
+  sequenced before the evaluation of B.
+[*Example 3*:
+``` cpp
+void f(int i)
+{
+  contract_assert(i > 0);   // #1
+  contract_assert(i < 10);  // #2
+    // valid sequence of evaluations: #1 #2
+    // valid sequence of evaluations: #1 #1 #2 #2
+    // valid sequence of evaluations: #1 #2 #1 #2
+    // valid sequence of evaluations: #1 #2 #2 #1
+    // invalid sequence of evaluations: #2 #1
+}
+```
+— *end example*]
+*Recommended practice:* An implementation should provide an option to
+perform a specified number of repeated evaluations for contract
+assertions. By default, no repeated evaluations should be performed.
+### Contract-violation handler <a id="basic.contract.handler">[[basic.contract.handler]]</a>
+The *contract-violation handler* of a program is a function named
+`::handle_contract_violation`. The contract-violation handler shall have
+a single parameter of type “lvalue reference to `const`
+`std::contracts::contract_violation`” and shall return `void`. The
+contract-violation handler may have a non-throwing exception
+specification. The implementation shall provide a definition of the
+contract-violation handler, called the
+*default contract-violation handler*.
+[*Note 1*: No declaration for the default contract-violation handler is
+provided by any standard library header. — *end note*]
+*Recommended practice:* The default contract-violation handler should
+produce diagnostic output that suitably formats the most relevant
+contents of the `std::contracts::contract_violation` object,
+rate-limited for potentially repeated violations of observed contract
+assertions, and then return normally.
+It is *implementation-defined* whether the contract-violation handler is
+replaceable [[term.replaceable.function]]. If the contract-violation
+handler is not replaceable, a declaration of a replacement function for
+the contract-violation handler is ill-formed, no diagnostic required.
+<!-- Link reference definitions -->
+[allocator.members]: mem.md#allocator.members
+[atomics]: thread.md#atomics
+[atomics.flag]: thread.md#atomics.flag
+[atomics.lockfree]: thread.md#atomics.lockfree
+[atomics.order]: thread.md#atomics.order
+[bad.alloc]: support.md#bad.alloc
+[basic]: #basic
+[basic.align]: #basic.align
+[basic.compound]: #basic.compound
+[basic.contract]: #basic.contract
+[basic.contract.eval]: #basic.contract.eval
+[basic.contract.general]: #basic.contract.general
+[basic.contract.handler]: #basic.contract.handler
+[basic.def]: #basic.def
+[basic.def.odr]: #basic.def.odr
+[basic.exec]: #basic.exec
+[basic.extended.fp]: #basic.extended.fp
+[basic.fundamental]: #basic.fundamental
+[basic.fundamental.width]: #basic.fundamental.width
+[basic.indet]: #basic.indet
+[basic.life]: #basic.life
+[basic.link]: #basic.link
+[basic.lookup]: #basic.lookup
+[basic.lookup.argdep]: #basic.lookup.argdep
+[basic.lookup.elab]: #basic.lookup.elab
+[basic.lookup.general]: #basic.lookup.general
+[basic.lookup.qual]: #basic.lookup.qual
+[basic.lookup.qual.general]: #basic.lookup.qual.general
+[basic.lookup.udir]: #basic.lookup.udir
+[basic.lookup.unqual]: #basic.lookup.unqual
+[basic.lval]: expr.md#basic.lval
+[basic.memobj]: #basic.memobj
+[basic.namespace]: dcl.md#basic.namespace
+[basic.namespace.general]: dcl.md#basic.namespace.general
+[basic.pre]: #basic.pre
+[basic.scope]: #basic.scope
+[basic.scope.block]: #basic.scope.block
+[basic.scope.class]: #basic.scope.class
+[basic.scope.contract]: #basic.scope.contract
+[basic.scope.enum]: #basic.scope.enum
+[basic.scope.lambda]: #basic.scope.lambda
+[basic.scope.namespace]: #basic.scope.namespace
+[basic.scope.param]: #basic.scope.param
+[basic.scope.pdecl]: #basic.scope.pdecl
+[basic.scope.scope]: #basic.scope.scope
+[basic.scope.temp]: #basic.scope.temp
+[basic.splice]: #basic.splice
+[basic.start]: #basic.start
+[basic.start.dynamic]: #basic.start.dynamic
+[basic.start.main]: #basic.start.main
+[basic.start.static]: #basic.start.static
+[basic.start.term]: #basic.start.term
+[basic.stc]: #basic.stc
+[basic.stc.auto]: #basic.stc.auto
+[basic.stc.dynamic]: #basic.stc.dynamic
+[basic.stc.dynamic.allocation]: #basic.stc.dynamic.allocation
+[basic.stc.dynamic.deallocation]: #basic.stc.dynamic.deallocation
+[basic.stc.dynamic.general]: #basic.stc.dynamic.general
+[basic.stc.general]: #basic.stc.general
+[basic.stc.static]: #basic.stc.static
+[basic.stc.thread]: #basic.stc.thread
+[basic.type.qualifier]: #basic.type.qualifier
+[basic.type.qualifier.rel]: #basic.type.qualifier.rel
+[basic.types]: #basic.types
+[basic.types.general]: #basic.types.general
+[bit.cast]: utilities.md#bit.cast
+[c.malloc]: mem.md#c.malloc
+[class]: class.md#class
+[class.abstract]: class.md#class.abstract
+[class.access]: class.md#class.access
+[class.access.base]: class.md#class.access.base
+[class.base.init]: class.md#class.base.init
+[class.bit]: class.md#class.bit
+[class.cdtor]: class.md#class.cdtor
+[class.conv.fct]: class.md#class.conv.fct
+[class.copy.assign]: class.md#class.copy.assign
+[class.copy.ctor]: class.md#class.copy.ctor
+[class.copy.elision]: class.md#class.copy.elision
+[class.default.ctor]: class.md#class.default.ctor
+[class.derived]: class.md#class.derived
+[class.derived.general]: class.md#class.derived.general
+[class.dtor]: class.md#class.dtor
+[class.free]: class.md#class.free
+[class.friend]: class.md#class.friend
+[class.mem]: class.md#class.mem
+[class.mem.general]: class.md#class.mem.general
+[class.member.lookup]: #class.member.lookup
+[class.name]: class.md#class.name
+[class.pre]: class.md#class.pre
+[class.prop]: class.md#class.prop
+[class.qual]: #class.qual
+[class.spaceship]: class.md#class.spaceship
+[class.static]: class.md#class.static
+[class.static.data]: class.md#class.static.data
+[class.temporary]: #class.temporary
+[class.union]: class.md#class.union
+[class.union.anon]: class.md#class.union.anon
+[class.virtual]: class.md#class.virtual
+[conv]: expr.md#conv
+[conv.array]: expr.md#conv.array
+[conv.func]: expr.md#conv.func
+[conv.integral]: expr.md#conv.integral
+[conv.lval]: expr.md#conv.lval
+[conv.mem]: expr.md#conv.mem
+[conv.prom]: expr.md#conv.prom
+[conv.ptr]: expr.md#conv.ptr
+[conv.qual]: expr.md#conv.qual
+[conv.rank]: #conv.rank
+[conv.rval]: expr.md#conv.rval
+[cpp.predefined]: cpp.md#cpp.predefined
+[csetjmp.syn]: support.md#csetjmp.syn
+[cstdarg.syn]: support.md#cstdarg.syn
+[cstddef.syn]: support.md#cstddef.syn
+[cstring.syn]: strings.md#cstring.syn
+[dcl.align]: dcl.md#dcl.align
+[dcl.array]: dcl.md#dcl.array
+[dcl.attr]: dcl.md#dcl.attr
+[dcl.attr.grammar]: dcl.md#dcl.attr.grammar
+[dcl.attr.indet]: dcl.md#dcl.attr.indet
+[dcl.attr.nouniqueaddr]: dcl.md#dcl.attr.nouniqueaddr
+[dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.contract.func]: dcl.md#dcl.contract.func
+[dcl.contract.res]: dcl.md#dcl.contract.res
+[dcl.decl]: dcl.md#dcl.decl
+[dcl.enum]: dcl.md#dcl.enum
+[dcl.fct]: dcl.md#dcl.fct
+[dcl.fct.def]: dcl.md#dcl.fct.def
+[dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
+[dcl.fct.def.general]: dcl.md#dcl.fct.def.general
+[dcl.fct.default]: dcl.md#dcl.fct.default
+[dcl.init]: dcl.md#dcl.init
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.init.general]: dcl.md#dcl.init.general
+[dcl.init.list]: dcl.md#dcl.init.list
+[dcl.init.ref]: dcl.md#dcl.init.ref
+[dcl.link]: dcl.md#dcl.link
+[dcl.meaning]: dcl.md#dcl.meaning
+[dcl.meaning.general]: dcl.md#dcl.meaning.general
+[dcl.mptr]: dcl.md#dcl.mptr
+[dcl.name]: dcl.md#dcl.name
+[dcl.pre]: dcl.md#dcl.pre
+[dcl.ptr]: dcl.md#dcl.ptr
+[dcl.ref]: dcl.md#dcl.ref
+[dcl.spec]: dcl.md#dcl.spec
+[dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.stc]: dcl.md#dcl.stc
+[dcl.struct.bind]: dcl.md#dcl.struct.bind
+[dcl.type.decltype]: dcl.md#dcl.type.decltype
+[dcl.type.elab]: dcl.md#dcl.type.elab
+[dcl.typedef]: dcl.md#dcl.typedef
+[defns.access]: intro.md#defns.access
+[defns.block]: intro.md#defns.block
+[depr.local]: future.md#depr.local
+[depr.static.constexpr]: future.md#depr.static.constexpr
+[diff.cpp11.basic]: compatibility.md#diff.cpp11.basic
+[enum.udecl]: dcl.md#enum.udecl
+[except.handle]: except.md#except.handle
+[except.pre]: except.md#except.pre
+[except.spec]: except.md#except.spec
+[except.terminate]: except.md#except.terminate
+[except.throw]: except.md#except.throw
+[expr.add]: expr.md#expr.add
+[expr.alignof]: expr.md#expr.alignof
+[expr.arith.conv]: expr.md#expr.arith.conv
+[expr.assign]: expr.md#expr.assign
+[expr.await]: expr.md#expr.await
+[expr.call]: expr.md#expr.call
+[expr.cast]: expr.md#expr.cast
+[expr.comma]: expr.md#expr.comma
+[expr.cond]: expr.md#expr.cond
+[expr.const]: expr.md#expr.const
+[expr.const.cast]: expr.md#expr.const.cast
+[expr.context]: expr.md#expr.context
+[expr.delete]: expr.md#expr.delete
+[expr.dynamic.cast]: expr.md#expr.dynamic.cast
+[expr.eq]: expr.md#expr.eq
+[expr.mptr.oper]: expr.md#expr.mptr.oper
+[expr.new]: expr.md#expr.new
+[expr.pre]: expr.md#expr.pre
+[expr.prim.id]: expr.md#expr.prim.id
+[expr.prim.id.general]: expr.md#expr.prim.id.general
+[expr.prim.id.qual]: expr.md#expr.prim.id.qual
+[expr.prim.id.unqual]: expr.md#expr.prim.id.unqual
+[expr.prim.lambda]: expr.md#expr.prim.lambda
+[expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
+[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
+[expr.prim.splice]: expr.md#expr.prim.splice
+[expr.prim.this]: expr.md#expr.prim.this
+[expr.prop]: expr.md#expr.prop
+[expr.ref]: expr.md#expr.ref
+[expr.reflect]: expr.md#expr.reflect
+[expr.reinterpret.cast]: expr.md#expr.reinterpret.cast
+[expr.rel]: expr.md#expr.rel
+[expr.sizeof]: expr.md#expr.sizeof
+[expr.static.cast]: expr.md#expr.static.cast
+[expr.sub]: expr.md#expr.sub
+[expr.throw]: expr.md#expr.throw
+[expr.type.conv]: expr.md#expr.type.conv
+[expr.typeid]: expr.md#expr.typeid
+[expr.unary.noexcept]: expr.md#expr.unary.noexcept
+[expr.unary.op]: expr.md#expr.unary.op
+[get.new.handler]: support.md#get.new.handler
+[headers]: library.md#headers
+[intro.abstract]: intro.md#intro.abstract
+[intro.compliance]: intro.md#intro.compliance
+[intro.execution]: #intro.execution
+[intro.memory]: #intro.memory
+[intro.multithread]: #intro.multithread
+[intro.multithread.general]: #intro.multithread.general
+[intro.object]: #intro.object
+[intro.progress]: #intro.progress
+[intro.races]: #intro.races
+[lex.charset]: lex.md#lex.charset
+[lex.fcon]: lex.md#lex.fcon
+[lex.name]: lex.md#lex.name
+[lex.phases]: lex.md#lex.phases
+[lex.string]: lex.md#lex.string
+[mem.res.public]: mem.md#mem.res.public
+[meta.define.static]: meta.md#meta.define.static
+[meta.reflection.operators]: meta.md#meta.reflection.operators
+[meta.syn]: meta.md#meta.syn
+[module.context]: module.md#module.context
+[module.global.frag]: module.md#module.global.frag
+[module.interface]: module.md#module.interface
+[module.reach]: module.md#module.reach
+[module.unit]: module.md#module.unit
+[multibyte.strings]: library.md#multibyte.strings
+[namespace.alias]: dcl.md#namespace.alias
+[namespace.def]: dcl.md#namespace.def
+[namespace.qual]: #namespace.qual
+[namespace.udecl]: dcl.md#namespace.udecl
+[namespace.udir]: dcl.md#namespace.udir
+[namespace.unnamed]: dcl.md#namespace.unnamed
+[new.delete.array]: support.md#new.delete.array
+[new.delete.placement]: support.md#new.delete.placement
+[new.delete.single]: support.md#new.delete.single
+[new.handler]: support.md#new.handler
+[new.syn]: support.md#new.syn
+[obj.lifetime]: mem.md#obj.lifetime
+[over]: over.md#over
+[over.literal]: over.md#over.literal
+[over.match]: over.md#over.match
+[over.match.funcs]: over.md#over.match.funcs
+[over.oper]: over.md#over.oper
+[over.over]: over.md#over.over
+[ptr.align]: mem.md#ptr.align
+[ptr.launder]: support.md#ptr.launder
+[special]: class.md#special
+[std.modules]: library.md#std.modules
+[stdfloat.syn]: support.md#stdfloat.syn
+[stmt.block]: stmt.md#stmt.block
+[stmt.contract.assert]: stmt.md#stmt.contract.assert
+[stmt.dcl]: stmt.md#stmt.dcl
+[stmt.expand]: stmt.md#stmt.expand
+[stmt.expr]: stmt.md#stmt.expr
+[stmt.if]: stmt.md#stmt.if
+[stmt.iter]: stmt.md#stmt.iter
+[stmt.iter.general]: stmt.md#stmt.iter.general
+[stmt.pre]: stmt.md#stmt.pre
+[stmt.ranged]: stmt.md#stmt.ranged
+[stmt.return]: stmt.md#stmt.return
+[stmt.select]: stmt.md#stmt.select
+[support.contract.violation]: support.md#support.contract.violation
+[support.dynamic]: support.md#support.dynamic
+[support.runtime]: support.md#support.runtime
+[support.start.term]: support.md#support.start.term
+[support.types]: support.md#support.types
+[temp.alias]: temp.md#temp.alias
+[temp.concept]: temp.md#temp.concept
+[temp.deduct.guide]: temp.md#temp.deduct.guide
+[temp.dep]: temp.md#temp.dep
+[temp.dep.candidate]: temp.md#temp.dep.candidate
+[temp.dep.constexpr]: temp.md#temp.dep.constexpr
+[temp.dep.splice]: temp.md#temp.dep.splice
+[temp.dep.type]: temp.md#temp.dep.type
+[temp.expl.spec]: temp.md#temp.expl.spec
+[temp.explicit]: temp.md#temp.explicit
+[temp.friend]: temp.md#temp.friend
+[temp.local]: temp.md#temp.local
+[temp.names]: temp.md#temp.names
+[temp.over]: temp.md#temp.over
+[temp.over.link]: temp.md#temp.over.link
+[temp.param]: temp.md#temp.param
+[temp.point]: temp.md#temp.point
+[temp.pre]: temp.md#temp.pre
+[temp.res]: temp.md#temp.res
+[temp.spec]: temp.md#temp.spec
+[temp.spec.partial]: temp.md#temp.spec.partial
+[temp.spec.partial.match]: temp.md#temp.spec.partial.match
+[temp.type]: temp.md#temp.type
+[term.implicit.lifetime.type]: #term.implicit.lifetime.type
+[term.incomplete.type]: #term.incomplete.type
+[term.odr.use]: #term.odr.use
+[term.replaceable.function]: dcl.md#term.replaceable.function
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
+[thread]: thread.md#thread
+[thread.jthread.class]: thread.md#thread.jthread.class
+[thread.thread.class]: thread.md#thread.thread.class
+[thread.thread.this]: thread.md#thread.thread.this
+[thread.threads]: thread.md#thread.threads
+[^1]: Appearing inside the brace-enclosed *declaration-seq* in a
+    *linkage-specification* does not affect whether a declaration is a
+    definition.
+[^2]: An implementation is not required to call allocation and
+    deallocation functions from constructors or destructors; however,
+    this is a permissible implementation technique.
+[^3]: An implicit object parameter [[over.match.funcs]] is not part of
+    the parameter-type-list.
+[^4]: Lookups in which function names are ignored include names
+    appearing in a *nested-name-specifier*, an
+    *elaborated-type-specifier*, or a *base-specifier*.
+[^5]: The number of bits in a byte is reported by the macro `CHAR_BIT`
+    in the header `<climits>`.
+[^6]: Under the “as-if” rule an implementation is allowed to store two
+    objects at the same machine address or not store an object at all if
+    the program cannot observe the difference [[intro.execution]].
+[^7]: For example, before the dynamic initialization of an object with
+    static storage duration [[basic.start.dynamic]].
+[^8]: That is, an object for which a destructor will be called
+    implicitly—upon exit from the block for an object with automatic
+    storage duration, upon exit from the thread for an object with
+    thread storage duration, or upon exit from the program for an object
+    with static storage duration.
+[^9]: The intent is to have `operator new()` implementable by calling
+    `std::malloc()` or `std::calloc()`, so the rules are substantially
+    the same. C++ differs from C in requiring a zero request to return a
+    non-null pointer.
+[^10]: The global `operator delete(void*, std::size_t)` precludes use of
+    an allocation function `void operator new(std::size_t, std::size_t)`
+    as a placement allocation function [[diff.cpp11.basic]].
+[^11]: The same rules apply to initialization of an `initializer_list`
+    object [[dcl.init.list]] with its underlying temporary array.
+[^12]: By using, for example, the library functions [[headers]]
+    `std::memcpy` or `std::memmove`.
+[^13]: By using, for example, the library functions [[headers]]
+    `std::memcpy` or `std::memmove`.
+[^14]: The intent is that the memory model of C++ is compatible with
+    that of the C programming language.
+[^15]: The size and layout of an instance of an incompletely-defined
+    object type is unknown.
+[^16]: This is also known as two’s complement representation.
+[^17]: Static class members are objects or functions, and pointers to
+    them are ordinary pointers to objects or functions.
+[^18]: For an object that is not within its lifetime, this is the first
+    byte in memory that it will occupy or used to occupy.
+[^19]: Some implementations might define that copying such a pointer
+    value causes a system-generated runtime fault.
+[^20]: The same representation and alignment requirements are meant to
+    imply interchangeability as arguments to functions, return values
+    from functions, and non-static data members of unions.
+[^21]: As specified in  [[class.temporary]], after a full-expression is
+    evaluated, a sequence of zero or more invocations of destructor
+    functions for temporary objects takes place, usually in reverse
+    order of the construction of each temporary object.
+[^22]: In other words, function executions do not interleave with each
+    other.
+[^23]: An object with automatic or thread storage duration [[basic.stc]]
+    is associated with one specific thread, and can be accessed by a
+    different thread only indirectly through a pointer or reference
+    [[basic.compound]].
+[^24]: A non-block variable with static storage duration having
+    initialization with side effects is initialized in this case, even
+    if it is not itself odr-used [[term.odr.use]], [[basic.stc.static]].

Diff to HTML by rtfpessoa