<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="pandoc" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <title>P3501R0: The ad-dressing of cats</title>
  <style>
    html {
      color: #1a1a1a;
      background-color: #fdfdfd;
    }
    body {
      margin: 0 auto;
      max-width: 36em;
      padding-left: 50px;
      padding-right: 50px;
      padding-top: 50px;
      padding-bottom: 50px;
      hyphens: auto;
      overflow-wrap: break-word;
      text-rendering: optimizeLegibility;
      font-kerning: normal;
    }
    @media (max-width: 600px) {
      body {
        font-size: 0.9em;
        padding: 12px;
      }
      h1 {
        font-size: 1.8em;
      }
    }
    @media print {
      html {
        background-color: white;
      }
      body {
        background-color: transparent;
        color: black;
        font-size: 12pt;
      }
      p, h2, h3 {
        orphans: 3;
        widows: 3;
      }
      h2, h3, h4 {
        page-break-after: avoid;
      }
    }
    p {
      margin: 1em 0;
    }
    a {
      color: #0645ad;
    }
    a:visited {
      color: #0645ad;
    }
    img {
      max-width: 100%;
    }
    svg {
      height: auto;
      max-width: 100%;
    }
    h1, h2, h3, h4, h5, h6 {
      margin-top: 1.4em;
    }
    h5, h6 {
      font-size: 1em;
      font-style: italic;
    }
    h6 {
      font-weight: normal;
    }
    ol, ul {
      padding-left: 1.7em;
      margin-top: 1em;
    }
    li > ol, li > ul {
      margin-top: 0;
    }
    blockquote {
      margin: 1em 0 1em 1.7em;
      padding-left: 1em;
      border-left: 2px solid #e6e6e6;
      color: #606060;
    }
    code {
      font-family: Menlo, Monaco, Consolas, 'Lucida Console', monospace;
      font-size: 85%;
      margin: 0;
      hyphens: manual;
    }
    pre {
      margin: 1em 0;
      overflow: auto;
    }
    pre code {
      padding: 0;
      overflow: visible;
      overflow-wrap: normal;
    }
    .sourceCode {
     background-color: transparent;
     overflow: visible;
    }
    hr {
      background-color: #1a1a1a;
      border: none;
      height: 1px;
      margin: 1em 0;
    }
    table {
      margin: 1em 0;
      border-collapse: collapse;
      width: 100%;
      overflow-x: auto;
      display: block;
      font-variant-numeric: lining-nums tabular-nums;
    }
    table caption {
      margin-bottom: 0.75em;
    }
    tbody {
      margin-top: 0.5em;
      border-top: 1px solid #1a1a1a;
      border-bottom: 1px solid #1a1a1a;
    }
    th {
      border-top: 1px solid #1a1a1a;
      padding: 0.25em 0.5em 0.25em 0.5em;
    }
    td {
      padding: 0.125em 0.5em 0.25em 0.5em;
    }
    header {
      margin-bottom: 4em;
      text-align: center;
    }
    #TOC li {
      list-style: none;
    }
    #TOC ul {
      padding-left: 1.3em;
    }
    #TOC > ul {
      padding-left: 0;
    }
    #TOC a:not(:hover) {
      text-decoration: none;
    }
    code{white-space: pre-wrap;}
    span.smallcaps{font-variant: small-caps;}
    div.columns{display: flex; gap: min(4vw, 1.5em);}
    div.column{flex: auto; overflow-x: auto;}
    div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
    /* The extra [class] is a hack that increases specificity enough to
       override a similar rule in reveal.js */
    ul.task-list[class]{list-style: none;}
    ul.task-list li input[type="checkbox"] {
      font-size: inherit;
      width: 0.8em;
      margin: 0 0.8em 0.2em -1.6em;
      vertical-align: middle;
    }
    .display.math{display: block; text-align: center; margin: 0.5rem auto;}
  </style>
  <style type="text/css">
  div.del, section.del { background: #fdd; }
  div.ins, section.ins { background: #cfb; }
  .mv { background: #ddf; }
  s, .del { background: #faa; margin-right: 0.15ch; }
  u, .ins { background: #afa; }
  /* from https://stackoverflow.com/a/32456613 */
  div > blockquote, body > blockquote {
      display: list-item;
      list-style-type: "- ";
  }
  /* With a 3 em gutter and two columns, ANSI letter is 127 characters wide. */
  pre {
  		margin-left: 1.2em;
  }
  .tony {
    border-collapse: collapse;
  }
  .tony > tbody > tr {
    vertical-align: top;
  }
  tr.hr, tr.hr {
    border-bottom: thin solid #60a0b0;  /* relies on collapse */
  }
  </style>
</head>
<body>
<header id="title-block-header">
<h1 class="title">P3501R0: The ad-dressing of
cats<!-- -*- c++-md -*- --></h1>
</header>
<p><em>Audience</em>: EWG, CWG, LWG<br />
S. Davis Herring &lt;<a href="mailto:herring@lanl.gov"
class="email">herring@lanl.gov</a>&gt;<br />
Los Alamos National Laboratory<br />
January 10, 2025</p>
<h1 id="introduction">Introduction</h1>
<p>The word “address” is used with several different meanings in the
standard, each given merely implicit definitions. [intro.memory]/1 tells
us “Every byte has a unique address.”, and pointers are said to
“represent the address” of bytes of memory ([basic.compound]/3);
[expr.delete]/5 and [class.mem.general]/22 (and some places in the
library) refer to an order on such addresses, and [basic.align]/1 even
talks about a number of bytes between addresses. There is also some sort
of order invoked for bytes in [basic.compound]/3 and [intro.object]/8.
However, no further use of those order and/or arithmetic structures is
made: in particular, the integers resulting from
<code>reinterpret_cast</code> are not described as addresses, except in
the note in [expr.reinterpret.cast]/4 about the conversion being
“unsurprising”.</p>
<p>Furthermore, the word is sometimes used to just refer to any use of
the unary <code>&amp;</code> operator (<em>e.g.</em>,
[basic.lookup.argdep]/3 and [dcl.ptr]/4) or to any pointer
(<em>e.g.</em>, [expr.delete]/11, [atomics.ref.pointer]/6, and
[util.smartptr.atomic.shared]/2). Finally, sometimes it refers to the
identity of an entity (<em>e.g.</em>, [dcl.inline]/6,
[temp.constr.order]/2.2, or [temp.explicit]/12).</p>
<p>There is also one significant defect where the word should be used
but is not: [defns.order.ptr] refers to a total order over pointer
values that <code>std::less</code> and company cannot possibly produce
with real implementations. In particular,
<code>std::less&lt;void*&gt;</code> cannot distinguish the pointer
values of a pointer to an array and a pointer to its first element
(which are not even pointer-interconvertible). Neither can
<code>std::less&lt;int*&gt;</code> distinguish a pointer past one
<code>int</code> (<code>&amp;x+1</code>) with a pointer to another
<code>int</code> (<code>&amp;y</code>) that happens to be stored
immediately after it.</p>
<p>This paper clarifies that addresses are totally ordered opaque labels
for bytes of memory, rewriting [expr.eq] to use that order (as does
[comparisons]) and [expr.rel] to use the appropriate subset of that
order. ([expr.rel] results must continue to be otherwise unspecified
because it is desirable that the result of <code>&lt;</code> be able to
differ between its usage directly and via <code>std::less</code>, whose
total order must be unavailable during constant evaluation even if
<code>&lt;</code> provides it at runtime.) It changes the usages with
other meanings, continuing in the <a
href="https://github.com/cplusplus/draft/pull/6174">direction</a>
already established there. It also clarifies the relationships between
addresses, bytes, and objects.</p>
<h1 id="proposal">Proposal</h1>
<p>Associate an address with every pointer value, even pointers to
functions and null pointers. Establish a total order on these addresses,
retaining the possibility that objects are not contiguous in it to
support either interleaving or concatenating segments in the
<code>std::less</code> order. Define equality operators on pointers and
all [comparisons] function objects in terms of this order. Introduce the
term “ordered” for pointers where <code>&lt;</code> is available during
constant evaluation.</p>
<p>Do not alter the general implementation-defined support for any
operation on pointers not valid in the context of that operation; note
that such an alteration has been <a
href="https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2024/p3347r0.pdf">separately
proposed</a>. Nor alter the description of <code>void*</code> values
used with <code>operator new</code> and company strictly in terms of
their addresses (and suitable created objects).</p>
<p>Additionally, correct the separate defective claim in
[comparisons.general] that <code>std::less&lt;void&gt;</code> produces
an ordered result for distinct arguments even though, if they have
different types, the conversion to their composite pointer
type ([expr.rel]/3) can cause them to become equal.</p>
<p>Use strictly “take the address” for the operation of
<code>&amp;</code>, but formally define “address of an overload set”
(whose evaluation is deferred until after overload resolution). Avoid
using “address of <em>E</em>” when “pointer to <em>E</em>” or
“<em>E</em>” is correct.</p>
<h2 id="consequences">Consequences</h2>
<p>The only change of semantics (beyond the alignment of the library
facilities with real implementations) is that comparisons involving
one-past pointers are no longer unspecified (but still cannot be used in
constant expressions). These changes to [expr.eq] merge cleanly with
those from <a
href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2434r2.html">P2434R2</a>.</p>
<h1 id="wording">Wording</h1>
<p>Relative to N5001.</p>
<section id="defns.order.ptr" class="del">
<h2>#[defns.order.ptr]</h2>
</section>
<p>Remove subclause. Forward its stable name to [intro.memory].</p>
<h2 id="basic">#[basic]</h2>
<h3 id="basic.memobj">#[basic.memobj]</h3>
<h4 id="intro.memory">#[intro.memory]</h4>
<p>Change paragraph 1:</p>
<blockquote>
<p>[…] The memory available to a C++ program consists <s>of one or
more</s><u>a</u> sequence<s>s</s> of <s>contiguous </s>bytes. Every byte
has a unique <s>address</s><u><em>address</em>, which is a label drawn
from a larger set equipped with an implementation-defined total
order</u>.</p>
<p><u>[<em>Note</em>: The order is independent of the sequence order of
the bytes except as specified ([intro.object],
[basic.stc.dynamic.allocation]). — <em>end note</em>]</u></p>
</blockquote>
<h4 id="intro.object">#[intro.object]</h4>
<p>Change paragraph 8:</p>
<blockquote>
<p>[…] Unless it is a bit-field ([class.bit]), an object with nonzero
size shall occupy one or more bytes of storage, including every byte
that is occupied in full or in part by any of its subobjects. An object
of trivially copyable or standard-layout type ([basic.types.general])
shall occupy contiguous bytes of storage. <u>The order of the addresses
of the bytes occupied by any object is consistent with that of the
bytes ([intro.memory]).</u></p>
<p><u>[<em>Note</em>: The address of a byte occupied by one complete
object can intervene between those of the bytes occupied by another
complete object. — <em>end note</em>]</u></p>
</blockquote>
<h4 id="basic.align">#[basic.align]</h4>
<p>Change paragraph 1:</p>
<blockquote>
<p>Object types have <em>alignment
requirements</em> ([basic.fundamental,basic.compound]) which place
restrictions on the addresses at which an object of that type may be
allocated. An <em>alignment</em> is an implementation-defined integer
value representing the <s>number</s><u>spacing</u> of <u>successive
</u>bytes <s>between successive</s><u>at whose</u> addresses <s>at which
</s>a given object can be allocated. […]</p>
</blockquote>
<h4 id="basic.life">#[basic.life]</h4>
<p>Change paragraph 7:</p>
<blockquote>
<p>Before the lifetime of an object has started but after the storage
which the object will occupy has been allocated<sup>[…]</sup> or, after
the lifetime of an object has ended and before the storage which the
object occupied is reused or released, <s>any</s><u>a</u> pointer
<s>that represents the address of the storage location
where</s><u>to</u> the object<s> will be or was located</s> may be used
but only in limited ways. […]</p>
</blockquote>
<p>Change paragraph 9:</p>
<blockquote>
<p>[…]</p>
<p>[<em>Note</em>: If these conditions are not met, a pointer to the new
object can be obtained from a pointer <s>that represents the</s><u>with
its</u> address<s> of its storage</s> by calling
<code>std::launder</code> ([ptr.launder]). — <em>end note</em>]</p>
</blockquote>
<h4
id="basic.stc.dynamic.allocation">#[basic.stc.dynamic.allocation]</h4>
<p>Insert before paragraph 2:</p>
<div class="ins">
<blockquote>
<p>The address of a block of storage is the address of the first byte in
it. The addresses of the bytes in any block of storage are in increasing
order ([intro.memory]).</p>
</blockquote>
</div>
<p>Change paragraph 2:</p>
<blockquote>
<p>An allocation function attempts to allocate the requested amount of
storage. If it is successful, it returns the address of <s>the start of
</s>a block of storage whose length in bytes is at least as large as the
requested size. The order, contiguity, and initial value of storage
allocated by successive calls to an allocation function are unspecified.
[…] Furthermore, for the library allocation functions
in [new.delete.single] and [new.delete.array], <u>the address of
</u><code>p0</code> <s>represents the address</s><u>is that</u> of a
block of storage disjoint from the storage for any other object
accessible to the caller.</p>
</blockquote>
<p>Change paragraph 3:</p>
<blockquote>
<p>For an allocation function other than a reserved placement allocation
function ([new.delete.placement]), the pointer returned on a successful
call shall <s>represent the</s><u>have as its</u> address <u>that </u>of
storage that is aligned as follows:</p>
</blockquote>
<h3 id="basic.compound">#[basic.compound]</h3>
<p>Change and split paragraph 3:</p>
<blockquote>
<p>[…]what can be done with them ([basic.types.general]).</p>
</blockquote>
<blockquote>
<p><u>Every value of pointer type holds an address ([intro.memory]) that
is not in general unique.</u> A value of a pointer type that is a
pointer to or past the end of an object <s><em>represents the
address</em></s><u>holds the address</u> of <s>the first byte in
memory ([intro.memory]) occupied by </s>the object[<em>Footnote</em>:
For an object that is not within its lifetime, this is <u>the address of
</u>the first byte in memory that it will occupy or used to occupy.
— <em>end footnote</em>] or <u>of </u>the first byte in memory after the
end of the storage occupied by the object, respectively.</p>
<p>[<em>Note</em>: A pointer past the end of an object ([expr.add]) is
not considered to point to an unrelated object of the object’s type,
even if the unrelated object is located at that address. — <em>end
note</em>]</p>
<p><u>Every pointer value that points to a function holds a unique
address. All null pointer values hold a single unique address. Every
invalid pointer value holds a unique address. These addresses are not
associated with any byte.</u></p>
</blockquote>
<blockquote>
<p>For purposes of pointer arithmetic ([expr.add])<s> and
comparison ([expr.rel,expr.eq])</s>, a pointer past the end of the last
element of an array <code>x</code> of <em>n</em> elements […]</p>
</blockquote>
<h2 id="expr">#[expr]</h2>
<h3 id="expr.compound">#[expr.compound]</h3>
<h4 id="expr.static.cast">#[expr.static.cast]</h4>
<p>Change paragraph 13:</p>
<blockquote>
<p>[…] If the original pointer value <s>represents the</s><u>points to
or past an object and holds an</u> address <s><code>A</code> of a byte
in memory and <code>A</code></s><u>that</u> does not satisfy the
alignment requirement of <code>T</code>, then the resulting pointer
value ([basic.compound]) is unspecified. […]</p>
</blockquote>
<h4 id="expr.unary">#[expr.unary]</h4>
<h5 id="expr.unary.op">#[expr.unary.op]</h5>
<p>Change paragraph 3:</p>
<blockquote>
<p>The operand of the unary <code>&amp;</code> operator shall be an
lvalue of some type <code>T</code>. <u>The <em>unary-expression</em> is
said to <em>take the address</em> of its operand.</u></p>
<p>[…]</p>
</blockquote>
<p>Change paragraph 6:</p>
<blockquote>
<p><u>An <em>address of an overload set</em> is a
<em>unary-expression</em> that takes the address of an
<em>id-expression</em> whose terminal name refers to an overload
set.</u> [<em>Note</em>: The address of an overload set<s> ([over])</s>
can be taken only in a context that uniquely determines which function
is referred to (<s>see </s><u>[over.match.call.general],
</u>[over.over]). Since the context can affect whether the operand is a
static or non-static member function, the context can also affect
whether the expression has type “pointer to function” or “pointer to
member function”. — <em>end note</em>]</p>
</blockquote>
<h5 id="expr.new">#[expr.new]</h5>
<p>Change paragraph 17:</p>
<blockquote>
<p>[…] For arrays of <code>char</code>, <code>unsigned char</code>, and
<code>std::byte</code>, the difference between the result of the
<em>new-expression</em> and the <s>address</s><u>value</u> returned by
the allocation function<u> (converted to the same type)</u> shall be an
integral multiple of the strictest fundamental alignment
requirement ([basic.align]) of any object type whose size is no greater
than the size of the array being created.</p>
</blockquote>
<h5 id="expr.delete">#[expr.delete]</h5>
<p>Change paragraph 10:</p>
<blockquote>
<p>[…] When a <em>delete-expression</em> is executed, the selected
deallocation function shall be called with <s>the address of</s><u>a
pointer to</u> the deleted object in a single-object delete expression,
or <s>the address of the deleted object</s><u>such a pointer</u>
suitably adjusted for the array allocation overhead ([expr.new]) in an
array delete expression, as its first argument.</p>
<p>[<em>Note</em>: […] — <em>end note</em>]</p>
</blockquote>
<h4 id="expr.spaceship">#[expr.spaceship]</h4>
<p>Change paragraph 6:</p>
<blockquote>
<p>[…]</p>
<p>In this case, <code>p &lt;=&gt; q</code> is of type
<code>std::strong_ordering</code> and the result is defined by the
following rules:</p>
<ol type="1">
<li>If <s>two pointer operands </s><code>p</code> and <code>q</code>
compare equal ([expr.eq]), <code>p &lt;=&gt; q</code> yields
<code>std::strong_ordering::equal</code>;</li>
<li>otherwise, if <code>p</code> and <code>q</code> <s>compare
unequal</s><u>are ordered ([expr.rel])</u>, <code>p &lt;=&gt; q</code>
yields <code>std::strong_ordering::less</code> if <s><code>q</code>
compares greater than <code>p</code></s><u><code>p &lt; q</code> is
<code>true</code></u> and <code>std::strong_ordering::greater</code>
<s>if <code>p</code> compares greater than
<code>q</code> ([expr.rel])</s><u>otherwise</u>;</li>
<li>otherwise, the result is unspecified.</li>
</ol>
</blockquote>
<h4 id="expr.rel">#[expr.rel]</h4>
<p>Replace paragraphs 4–6:</p>
<div class="del">
<blockquote>
<p>The result of comparing unequal pointers to objects<sup>[…]</sup> is
defined in terms of a partial order consistent with the following
rules:</p>
<p>[…]</p>
</blockquote>
<blockquote>
<p>If two operands <code>p</code> and <code>q</code> compare
equal ([expr.eq]), […]</p>
</blockquote>
<blockquote>
<p>If both operands (after conversions) are of arithmetic or enumeration
type, […]</p>
</blockquote>
</div>
<div class="ins">
<blockquote>
<p><code>p &gt; q</code> yields <code>q &lt; p</code>,
<code>p &lt;= q</code> yields <code>!(p &gt; q)</code>, and
<code>p &gt;= q</code> yields <code>!(p &lt; q)</code>.</p>
</blockquote>
<blockquote>
<p>If their operands <code>p</code> and <code>q</code> are pointers:</p>
<ol type="1">
<li><code>p</code> and <code>q</code> are <em>ordered</em> if an object
<em>O</em> exists such that <code>p</code> and <code>q</code> each point
to or past an object that is or is nested within <em>O</em>. In that
case, <code>p &lt; q</code> yields <code>true</code> if the address held
by <code>p</code> precedes that held by <code>q</code> and
<code>false</code> otherwise.</li>
<li>Otherwise, if <code>p</code> and <code>q</code> hold the same
address, <code>p &lt; q</code> yields <code>false</code>.</li>
<li>Otherwise, the result of <code>p &lt; q</code> is unspecified.</li>
</ol>
</blockquote>
<blockquote>
<p>Otherwise, <code>p &lt; q</code> yields <code>true</code> if the
(converted) value of <code>p</code> is less than that of <code>q</code>
and <code>false</code> otherwise.</p>
</blockquote>
</div>
<h4 id="expr.eq">#[expr.eq]</h4>
<p>Change paragraph 3:</p>
<blockquote>
<p>If at least one of the converted operands is a pointer, pointer
conversions ([conv.ptr]), function pointer conversions ([conv.fctptr]),
and qualification conversions ([conv.qual]) are performed on both
operands to bring them to their composite pointer type ([expr.type]).
<u>If the pointer values hold the same address, they compare equal;
otherwise</u> <s>Comparing pointers is defined as follows:</s></p>
<ol type="1">
<li><s>If one pointer represents the address of a complete object, and
another pointer represents the address one past the last element of a
different complete object,<sup>[…]</sup> the result of the comparison is
unspecified.</s></li>
<li><s>Otherwise, if the pointers are both null, both point to the same
function, or both represent the same address ([basic.compound]), they
compare equal.</s></li>
<li><s>Otherwise</s>, <s>the pointers</s><u>they</u> compare
unequal.</s></li>
</ol>
</blockquote>
<h3 id="expr.const">#[expr.const]</h3>
<p>Change and split bullet (10.25):</p>
<blockquote>
<p>a three-way comparison ([expr.spaceship])<s>,</s><u> or</u>
relational ([expr.rel])<s>, or</s><u> operator whose (pointer) operands
are unordered;</u></p>
</blockquote>
<blockquote>
<p><u>an </u>equality ([expr.eq]) operator <s>where the result is
unspecified</s><u>whose (pointer) operands hold the address of one
complete object and the address held by a pointer past another complete
object</u>;</p>
</blockquote>
<h2 id="dcl.dcl">#[dcl.dcl]</h2>
<h3 id="dcl.inline">#[dcl.inline]</h3>
<p>Change paragraph 6:</p>
<blockquote>
<p>[<em>Note</em>: An inline function or variable with external or
module linkage can be defined in multiple translation
units ([basic.def.odr]), but is <s>one</s><u>a single</u> entity<s> with
one address</s>. A type or <code>static</code> variable defined in the
body of such a function is therefore a single entity. — <em>end
note</em>]</p>
</blockquote>
<h3 id="dcl.array">#[dcl.array]</h3>
<p>Change paragraph 6:</p>
<blockquote>
<p>An object of type “array of <code>N</code> <code>U</code>” consists
of a <s>contiguously allocated </s>non-empty <s>set</s><u>sequence</u>
of <code>N</code> subobjects of type <code>U</code>, known as the
<em>elements</em> of the array, and numbered <code>0</code> to
<code>N-1</code>. <u>The first element has the same address as the
array; each other element occupies the bytes immediately following the
previous.</u></p>
<p><u>[<em>Note</em>: Because the array is an object, the addresses of
the elements are in the same order as the elements. — <em>end
note</em>]</u></p>
</blockquote>
<h3 id="dcl.fct.def.coroutine">#[dcl.fct.def.coroutine]</h3>
<p>Change paragraph 12:</p>
<blockquote>
<p>[…] The selected deallocation function shall be called with the
<s>address of the block of storage to be reclaimed</s><u>value returned
by the allocation function</u> as its first argument. If a deallocation
function with a parameter of type <code>std::size_t</code> is used, the
size of the block is passed as the corresponding argument.</p>
</blockquote>
<h2 id="class.mem.general">#[class.mem.general]</h2>
<p>Change paragraph 22:</p>
<blockquote>
<p><s>[<em>Note</em>:</s><u>Among</u> <s>N</s><u>n</u>on-variant
non-static data members of non-zero size ([intro.object])<s> are
allocated so that</s><u>,</u> later members <s>have higher
addresses</s><u>occupy later bytes</u> within a class
object<s> ([expr.rel])</s>.</p>
<p><u>[<em>Note</em>: </u>Implementation alignment requirements can
cause two adjacent members not to be allocated immediately after each
other; so can requirements for space for managing virtual
functions ([class.virtual]) and virtual base classes ([class.mi]).
— <em>end note</em>]</p>
</blockquote>
<h2 id="temp">#[temp]</h2>
<h3 id="temp.param">#[temp.param]</h3>
<p>Change the example in paragraph 8:</p>
<pre class="cpp">
  &i;                           // error: <u>taking the </u>address of non-reference template-parameter
</pre>
<h3 id="temp.constr.order">#[temp.constr.order]</h3>
<p>Change bullet (2.2):</p>
<blockquote>
<p>the <s>address of a </s>non-template function<u> selected from an
overload set</u> ([over.over]),</p>
</blockquote>
<h3 id="temp.func.order">#[temp.func.order]</h3>
<p>Change paragraph 1:</p>
<blockquote>
<p>If multiple function templates share a name, the use of that name can
be ambiguous because template argument deduction ([temp.deduct]) may
identify a specialization for more than one function template.
<em>Partial ordering</em> of overloaded function template declarations
is used in the following contexts to select the function template to
which a function template specialization refers:</p>
<ol type="1">
<li>during overload resolution for <u>(</u>a call to<u>)</u> a function
template specialization ([over.match.best]<u>, [over.over]</u>);</li>
<li><s>when the address of a function template specialization is
taken;</s></li>
<li>when a placement operator delete that is a function template
specialization is selected to match a placement operator
new ([basic.stc.dynamic.deallocation,expr.new]);</li>
<li>when a friend function declaration ([temp.friend]), an explicit
instantiation ([temp.explicit]) or an explicit
specialization ([temp.expl.spec]) refers to a function template
specialization.</li>
</ol>
</blockquote>
<h3 id="temp.deduct">#[temp.deduct]</h3>
<h4
id="deducing-template-arguments-taking-the-address-offor-a-named-function-template-temp.deduct.funcaddr">Deducing
template arguments <s>taking the address of</s><u>for</u> a <u>named
</u>function template #[temp.deduct.funcaddr]</h4>
<p>Change the section title.</p>
<p>Change paragraph 1:</p>
<blockquote>
<p>Template arguments can be deduced from the type specified when
<s>taking the address of</s><u>resolving</u> an overload
set ([over.over]). […]</p>
</blockquote>
<h4 id="temp.deduct.type">#[temp.deduct.type]</h4>
<p>Change paragraph 10:</p>
<blockquote>
<p>[…] If <code>P</code> and <code>A</code> are function types that
originated from deduction when <s>taking the address of</s><u>naming</u>
a function template ([temp.deduct.funcaddr]) or when deducing template
arguments from a function declaration ([temp.deduct.decl]) and
<code>P</code><sub><em>i</em></sub> and
<code>A</code><sub><em>i</em></sub>_ are parameters of the top-level
parameter-type-list of <code>P</code> and <code>A</code>, respectively,
[…]</p>
</blockquote>
<h2 id="library">#[library]</h2>
<h3 id="byte.strings">#[byte.strings]</h3>
<p>Change paragraph 1:</p>
<blockquote>
<p>A <em>null-terminated byte string</em>, or <span
class="smallcaps">NTBS</span>, is a character sequence whose
<s>highest-addressed</s><u>last</u> element with defined content has the
value zero (the <em>terminating null character</em>); no other element
in the sequence has the value zero.<sup>[…]</sup></p>
</blockquote>
<h3 id="res.on.arguments">#[res.on.arguments]</h3>
<p>Change bullet (1.2):</p>
<blockquote>
<p>If a function argument is described as being an array, the pointer
actually passed to the function shall have a value such that all
<s>address</s><u>pointer</u> computations and accesses to objects (that
would be valid if the pointer did point to the first element of such an
array) are in fact valid.</p>
</blockquote>
<h2 id="support">#[support]</h2>
<h3 id="support.dynamic">#[support.dynamic]</h3>
<h4 id="new.delete">#[new.delete]</h4>
<h5 id="new.delete.single">#[new.delete.single]</h5>
<p>Change paragraphs 10 and 18 identically:</p>
<blockquote>
<p><em>Preconditions</em>: <code>ptr</code> is a null pointer or <s>its
value represents</s><u>it holds</u> the address of a block of memory
allocated by an earlier call to a (possibly replaced)
<code>operator new(std::size_t)</code> or
<code>operator new(std::size_t, std::align_val_t)</code> which has not
been invalidated by an intervening call to
<code>operator delete</code>.</p>
</blockquote>
<h5 id="new.delete.array">#[new.delete.array]</h5>
<p>Change paragraphs 9 and 15 identically:</p>
<blockquote>
<p><em>Preconditions</em>: <code>ptr</code> is a null pointer or <s>its
value represents</s><u>it holds</u> the address of a block of memory
allocated by an earlier call to a (possibly replaced)
<code>operator new[](std::size_t)</code> or
<code>operator new[](std::size_t, std::align_val_t)</code> which has not
been invalidated by an intervening call to
<code>operator delete[]</code>.</p>
</blockquote>
<h4 id="ptr.launder">#[ptr.launder]</h4>
<p>Change paragraph 2:</p>
<blockquote>
<p><em>Preconditions</em>: <s><code>p</code> represents the address
<em>A</em> of a byte in memory.</s> An object <em>X</em> that is within
its lifetime ([basic.life]) and whose type is similar ([conv.qual]) to
<code>T</code> <s>is located at</s><u>has</u> the address
<s><em>A</em></s><u>held by <code>p</code></u>. All bytes of storage
that would be reachable through ([basic.compound]) the result are
reachable through <code>p</code>.</p>
</blockquote>
<h3 id="coroutine.handle.general">#[coroutine.handle.general]</h3>
<p>Change paragraph 1:</p>
<blockquote>
<p>An object of type <code>coroutine_handle&lt;T&gt;</code> is called a
<em>coroutine handle</em> and can be used to refer to a suspended or
executing coroutine. A <code>coroutine_handle</code> object whose member
<code>address()</code> returns a null pointer value does not refer to
any coroutine. Two <code>coroutine_handle</code> objects refer to the
same coroutine if and only if their member <code>address()</code>
returns <s>the same </s>non-null value<u>s that compare equal</u>.</p>
</blockquote>
<h2 id="syserr.errcat.nonvirtuals">#[syserr.errcat.nonvirtuals]</h2>
<p>Change paragraph 2:</p>
<blockquote>
<p><em>Returns</em>:
<code>compare_three_way()(this, &amp;rhs)</code>.</p>
</blockquote>
<p>[<em>Note</em>:
<code>compare_three_way</code> ([comparisons.three.way]) provides a
total ordering for <s>pointers</s><u>addresses</u>. — <em>end
note</em>]</p>
<h2 id="mem">#[mem]</h2>
<h3 id="memory">#[memory]</h3>
<h4 id="ptr.align">#[ptr.align]</h4>
<p>Change bullet (1.2):</p>
<blockquote>
<p><code>ptr</code> <s>represents</s><u>holds</u> the address of
contiguous storage of at least <code>space</code> bytes</p>
</blockquote>
<p>Change paragraph 2:</p>
<blockquote>
<p><em>Effects</em>: If it is possible to fit <code>size</code> bytes of
storage aligned by <code>alignment</code> into the buffer pointed to by
<code>ptr</code> with length <code>space</code>, the function
<s>updates</s><u>assigns to</u> <code>ptr</code> <s>to represent</s><u>a
pointer that holds</u> the first possible address of such storage and
decreases <code>space</code> by the number of bytes used for alignment.
Otherwise, the function does nothing.</p>
</blockquote>
<h4 id="specialized.addressof">#[specialized.addressof]</h4>
<p>Change paragraph 1:</p>
<blockquote>
<p><em>Returns</em>: <s>The actual address of</s><u>A pointer to</u> the
object or function referenced by <code>r</code>, even in the presence of
an overloaded <code>operator&amp;</code>.</p>
</blockquote>
<h3 id="util.smartptr.shared.create">#[util.smartptr.shared.create]</h3>
<p>Change paragraph 5:</p>
<blockquote>
<p><em>Returns</em>: A <code>shared_ptr</code> instance that stores and
owns <s>the address of</s><u>a pointer to</u> the newly constructed
object.</p>
</blockquote>
<p>Change paragraph 10:</p>
<blockquote>
<p><em>Remarks</em>: The <code>shared_ptr</code> constructors called by
these functions enable <code>shared_from_this</code> with <s>the address
of</s><u>a pointer to</u> the newly constructed object of type
<code>T</code>.</p>
</blockquote>
<h3 id="mem.res">#[mem.res]</h3>
<h4 id="mem.poly.allocator.mem">#[mem.poly.allocator.mem]</h4>
<p>Change paragraph 15:</p>
<blockquote>
<p><em>Effects</em>: Construct a <code>T</code> object in the storage
whose address is <s>represented by</s><u>that held by</u> <code>p</code>
by uses-allocator construction with allocator <code>*this</code> and
constructor arguments
<code>std::forward&lt;Args&gt;(args)...</code>.</p>
</blockquote>
<h4 id="mem.res.pool.ctor">#[mem.res.pool.ctor]</h4>
<p>Change paragraph 1:</p>
<blockquote>
<p><em>Preconditions</em>: <code>upstream</code> <s>is the address
of</s><u>points to</u> a valid memory resource.</p>
</blockquote>
<h4
id="mem.res.monotonic.buffer.ctor">#[mem.res.monotonic.buffer.ctor]</h4>
<p>Change paragraph 1:</p>
<blockquote>
<p><em>Preconditions</em>: <code>upstream</code> <s>is the address
of</s><u>points to</u> a valid memory resource.
<code>initial_size</code>, if specified, is greater than zero.</p>
</blockquote>
<p>Change paragraph 3:</p>
<blockquote>
<p><em>Preconditions</em>: <code>upstream</code> <s>is the address
of</s><u>points to</u> a valid memory resource. <code>buffer_size</code>
is no larger than the number of bytes in <code>buffer</code>.</p>
</blockquote>
<h2 id="utilities">#[utilities]</h2>
<h3 id="comparisons">#[comparisons]</h3>
<h4 id="comparisons.general">#[comparisons.general]</h4>
<p>Change paragraph 2:</p>
<blockquote>
<p>For templates <code>less</code>, <code>greater</code>,
<code>less_equal</code>, and <code>greater_equal</code>, the
specializations for any pointer type yield a result <s>consistent
with</s><u>based on</u> the implementation-defined strict total order
over
<s>pointers</s><u>addresses</u> ([<s>defns.order.ptr</s><u>intro.memory</u>]).</p>
<p>[<em>Note</em>: If <s><code>a &lt; b</code> is well-defined for
</s>pointers <code>a</code> and <code>b</code> of type <code>P</code><u>
are ordered ([expr.rel])</u>, then
<code>(a &lt; b) == less&lt;P&gt;()(a, b)</code>,
<code>(a &gt; b) == greater&lt;P&gt;()(a, b)</code>, and so forth.
— <em>end note</em>]</p>
<p>For template specializations <code>less&lt;void&gt;</code>,
<code>greater&lt;void&gt;</code>, <code>less_equal&lt;void&gt;</code>,
and <code>greater_equal&lt;void&gt;</code>, if the call operator calls a
built-in operator comparing pointers, the call operator yields a result
<s>consistent with</s><u>based on</u> the implementation-defined strict
total order over <s>pointers</s><u>the addresses held by the arguments
after conversion to their composite pointer type</u>.</p>
</blockquote>
<h4 id="comparisons.three.way">#[comparisons.three.way]</h4>
<p>Change bullet (3.1):</p>
<blockquote>
<p>If the expression
<code>std::forward&lt;T&gt;(t) &lt;=&gt; std::forward&lt;U&gt;(u)</code>
results in a call to a built-in operator <code>&lt;=&gt;</code>
comparing pointers<s> of type <code>P</code></s>, returns
<code>strong_ordering::less</code> if (the converted value of)
<code>t</code> precedes <code>u</code> in the implementation-defined
strict total order over
<s>pointers</s><u>addresses</u> ([<s>defns.order.ptr</s><u>intro.memory</u>]),
<code>strong_ordering::greater</code> if <code>u</code> precedes
<code>t</code>, and otherwise <code>strong_ordering::equal</code>.</p>
</blockquote>
<h4 id="range.cmp">#[range.cmp]</h4>
<p>Change paragraph 1:</p>
<blockquote>
<p><em>Constraints</em>: <code>T</code> and <code>U</code>
<s>satisfy</s><u>model</u> <code>equality_comparable_with</code>.</p>
</blockquote>
<p>Remove paragraph 2:</p>
<div class="del">
<blockquote>
<p><em>Preconditions</em>: If the expression
<code>std::forward&lt;T&gt;(t) == std::forward&lt;U&gt;(u)</code>
results in a call to a built-in operator <code>==</code> comparing
pointers of type <code>P</code>, the conversion sequences from both
<code>T</code> and <code>U</code> to <code>P</code> are
equality-preserving ([concepts.equality]); otherwise, <code>T</code> and
<code>U</code> model <code>equality_comparable_with</code>.</p>
</blockquote>
</div>
<p>Change paragraph 3:</p>
<blockquote>
<p><em>Effects</em>:</p>
<ol type="1">
<li><s>If the expression
<code>std::forward&lt;T&gt;(t) == std::forward&lt;U&gt;(u)</code>
results in a call to a built-in operator <code>==</code> comparing
pointers: returns <code>false</code> if either (the converted value of)
<code>t</code> precedes <code>u</code> or <code>u</code> precedes
<code>t</code> in the implementation-defined strict total order over
pointers ([defns.order.ptr]) and otherwise <code>true</code>.</s></li>
<li><s>Otherwise, e</s><u>E</u>quivalent to:
<code>return std::forward&lt;T&gt;(t) == std::forward&lt;U&gt;(u);</code></li>
</ol>
</blockquote>
<p>Change bullet (10.1):</p>
<blockquote>
<p>If the expression
<code>std::forward&lt;T&gt;(t) &lt; std::forward&lt;U&gt;(u)</code>
results in a call to a built-in operator <code>&lt;</code> comparing
pointers: returns <code>true</code> if (the converted value of)
<code>t</code> precedes <code>u</code> in the implementation-defined
strict total order over
<s>pointers</s><u>addresses</u> ([<s>defns.order.ptr</s><u>intro.memory</u>])
and otherwise <code>false</code>.</p>
</blockquote>
<h3 id="func.wrap.ref.ctor">#[func.wrap.ref.ctor]</h3>
<p>Change paragraph 4:</p>
<blockquote>
<p><em>Effects</em>: Initializes <em><code>bound-entity</code></em> with
<code>f</code>, and <em><code>thunk-ptr</code></em> with <s>the address
of</s><u>a pointer to</u> a function <em><code>thunk</code></em> such
that <code><em>thunk</em>(<em>bound-entity</em>,
<em>call-args</em>...)</code> is
expression-equivalent ([defns.expression.equivalent]) to
<code>invoke_r&lt;R&gt;(f, <em>call-args</em>...)</code>.</p>
</blockquote>
<p>Change paragraph 7:</p>
<blockquote>
<p><em>Effects</em>: Initializes <em><code>bound-entity</code></em> with
<code>addressof(f)</code>, and <em><code>thunk-ptr</code></em> with
<s>the address of</s><u>a pointer to</u> a function
<em><code>thunk</code></em> such that
<code><em>thunk</em>(<em>bound-entity</em>,
<em>call-args</em>...)</code> is
expression-equivalent ([defns.expression.equivalent]) to
<code>invoke_r&lt;R&gt;(static_cast&lt;<em>cv</em> T&amp;&gt;(f),
<em>call-args</em>...)</code>.</p>
</blockquote>
<p>Change paragraph 11:</p>
<blockquote>
<p><em>Effects</em>: Initializes <em><code>bound-entity</code></em> with
a pointer to an unspecified object or null pointer value, and
<em><code>thunk-ptr</code></em> with <s>the address of</s><u>a pointer
to</u> a function <em><code>thunk</code></em> such that
<code><em>thunk</em>(<em>bound-entity</em>,
<em>call-args</em>...)</code> is
expression-equivalent ([defns.expression.equivalent]) to
<code>invoke_r&lt;R&gt;(f, <em>call-args</em>...)</code>.</p>
</blockquote>
<p>Change paragraph 15:</p>
<blockquote>
<p><em>Effects</em>: Initializes <em><code>bound-entity</code></em> with
<code>addressof(obj)</code>, and <em><code>thunk-ptr</code></em> with
<s>the address of</s><u>a pointer to</u> a function
<em><code>thunk</code></em> such that
<code><em>thunk</em>(<em>bound-entity</em>,
<em>call-args</em>...)</code> is
expression-equivalent ([defns.expression.equivalent]) to
<code>invoke_r&lt;R&gt;(f, static_cast&lt;<em>cv</em> T&amp;&gt;(obj),
<em>call-args</em>...)</code>.</p>
</blockquote>
<p>Change paragraph 20:</p>
<blockquote>
<p><em>Effects</em>: Initializes <em><code>bound-entity</code></em> with
<code>obj</code>, and <em><code>thunk-ptr</code></em> with <s>the
address of</s><u>a pointer to</u> a function <em><code>thunk</code></em>
such that <code><em>thunk</em>(<em>bound-entity</em>,
<em>call-args</em>...)</code> is
expression-equivalent ([defns.expression.equivalent]) to
<code>invoke_r&lt;R&gt;(f, obj, <em>call-args</em>...)</code>.</p>
</blockquote>
<h2 id="container.alloc.reqmts">#[container.alloc.reqmts]</h2>
<p>Change bullet (2.2):</p>
<blockquote>
<p>[…]</p>
<p>where <code>p</code> <s>is</s><u>holds</u> the address of the
uninitialized storage for the element allocated within
<code>X</code>.</p>
</blockquote>
<h2 id="text">#[text]</h2>
<h3 id="locale.time.get.virtuals">#[locale.time.get.virtuals]</h3>
<p>Change paragraph 15:</p>
<blockquote>
<p><em>Remarks</em>: It is unspecified whether multiple calls to
<code>do_get()</code> with <s>the address of </s>the same
<code>tm</code> object will update the current contents of the object or
simply overwrite its members. Portable programs should zero out the
object before invoking the function.</p>
</blockquote>
<h3 id="re.tokiter">#[re.tokiter]</h3>
<h4 id="re.tokiter.cnstr">#[re.tokiter.cnstr]</h4>
<p>Change paragraph 4:</p>
<blockquote>
<p>Each constructor then sets <code>N</code> to 0, and
<code>position</code> to <code>position_iterator(a, b, re, m)</code>. If
<code>position</code> is not an end-of-sequence iterator the constructor
sets <code>result</code> to <s>the address</s><u>a pointer to the
beginning</u> of the current match. Otherwise if any of the values
stored in <code>subs</code> is equal to −1 the constructor sets
<code>*this</code> to a suffix iterator that points to the range
[<code>a</code>,<code>b</code>), otherwise the constructor sets
<code>*this</code> to an end-of-sequence iterator.</p>
</blockquote>
<h4 id="re.tokiter.incr">#[re.tokiter.incr]</h4>
<p>Change paragraphs 3 and 4:</p>
<blockquote>
<p>Otherwise, if <code>N + 1 &lt; subs.size()</code>, increments
<code>N</code> and sets <code>result</code> to <s>the address</s><u>a
pointer to the beginning</u> of the current match.</p>
</blockquote>
<blockquote>
<p>Otherwise, sets <code>N</code> to 0 and increments
<code>position</code>. If <code>position</code> is not an
end-of-sequence iterator the operator sets <code>result</code> to <s>the
address</s><u>a pointer to the beginning</u> of the current match.</p>
</blockquote>
<h2 id="class.gslice.overview">#[class.gslice.overview]</h2>
<p>Change paragraph 4:</p>
<blockquote>
<p>It is possible to have degenerate generalized slices in which an
<s>address</s><u>element</u> is repeated.</p>
</blockquote>
<h2 id="streambuf.reqts">#[streambuf.reqts]</h2>
<p>Change paragraph 2:</p>
<blockquote>
<p>[…] The three pointers are:</p>
<ol type="1">
<li>the <em>beginning pointer</em>, <s>or lowest</s><u>to the first</u>
element<s> address</s> in the array (called <code>xbeg</code>
here);</li>
<li>the <em>next pointer</em>, <s>or</s><u>to the</u> next element<s>
address</s> that is a current candidate for reading or writing (called
<code>xnext</code> here);</li>
<li>the <em>end pointer</em>, <s>or first element address
beyond</s><u>to</u> the end of the array (called <code>xend</code>
here).</li>
</ol>
</blockquote>
<h2 id="atomics">#[atomics]</h2>
<p>[<em>Drafting note</em>: While there is of course no normative
wording on the subject of memory mapping or multiple processes, the use
of “address” in [atomics.lockfree]/5 is otherwise consistent with the
definitions here. — <em>end drafting note</em>]</p>
<h3 id="atomics.ref.pointer">#[atomics.ref.pointer]</h3>
<p>Change paragraph 9:</p>
<blockquote>
<p><em>Remarks</em>: The result may be an <s>undefined
address</s><u>invalid pointer value</u>, but the operations otherwise
have no undefined behavior.</p>
</blockquote>
<h3 id="atomics.types.generic">#[atomics.types.generic]</h3>
<h4 id="atomics.types.operations">#[atomics.types.operations]</h4>
<p>Change paragraph 3:</p>
<blockquote>
<p><em>Effects</em>: Initializes the object with the value
<code>desired</code>. Initialization is not an atomic
operation ([intro.multithread]). [<em>Note</em>: It is possible to have
an access to an atomic object <code>A</code> race with its construction,
for example by communicating <s>the address of</s><u>a pointer to</u>
the just-constructed object <code>A</code> to another thread via
<code>memory_order::relaxed</code> operations on a suitable atomic
pointer variable, and then immediately accessing <code>A</code> in the
receiving thread. This results in undefined behavior. — <em>end
note</em>]</p>
</blockquote>
<h4 id="atomics.types.pointer">#[atomics.types.pointer]</h4>
<p>Change paragraph 8:</p>
<blockquote>
<p><em>Remarks</em>: The result may be an <s>undefined
address</s><u>invalid pointer value</u>, but the operations otherwise
have no undefined behavior.</p>
</blockquote>
<h4 id="util.smartptr.atomic">#[util.smartptr.atomic]</h4>
<h5 id="util.smartptr.atomic.shared">#[util.smartptr.atomic.shared]</h5>
<p>Change paragraph 2:</p>
<blockquote>
<p><em>Effects</em>: Initializes the object with the value
<code>desired</code>. Initialization is not an atomic
operation ([intro.multithread]). [<em>Note</em>: It is possible to have
an access to an atomic object <code>A</code> race with its construction,
for example, by communicating <s>the address of</s><u>a pointer to</u>
the just-constructed object <code>A</code> to another thread via
<code>memory_order::relaxed</code> operations on a suitable atomic
pointer variable, and then immediately accessing <code>A</code> in the
receiving thread. This results in undefined behavior. — <em>end
note</em>]</p>
</blockquote>
<h5 id="util.smartptr.atomic.weak">#[util.smartptr.atomic.weak]</h5>
<p>Change paragraph 2:</p>
<blockquote>
<p><em>Effects</em>: Initializes the object with the value
<code>desired</code>. Initialization is not an atomic
operation ([intro.multithread]). [<em>Note</em>: It is possible to have
an access to an atomic object <code>A</code> race with its construction,
for example, by communicating <s>the address of</s><u>a pointer to</u>
the just-constructed object <code>A</code> to another thread via
<code>memory_order::relaxed</code> operations on a suitable atomic
pointer variable, and then immediately accessing <code>A</code> in the
receiving thread. This results in undefined behavior. — <em>end
note</em>]</p>
</blockquote>
<h2 id="diff">#[diff]</h2>
<h3 id="diff.cpp23.expr">#[diff.cpp23.expr]</h3>
<p>Change paragraph 2:</p>
<blockquote>
<p><strong>Affected subclauses:</strong> [expr.rel] and [expr.eq]<br />
<strong>Change:</strong> Comparing two objects of array type is no
longer valid.<br />
<strong>Rationale:</strong> The old behavior was confusing since it
compared not the contents of the two arrays, but <u>pointers to
</u>their <s>addresses</s><u>first elements</u>.<br />
<strong>Effect on original feature:</strong> A valid C++2023 program
directly comparing two array objects is rejected as ill-formed in this
document. [<em>Example</em>:</p>
<pre class="cpp">
int arr1[5];
int arr2[5];
bool same = arr1 == arr2;       // ill-formed; previously well-formed
bool idem = arr1 == +arr2;      // compare <s>addresses</s><u>pointers</u>
bool less = arr1 < +arr2;       // compare <s>addresses</s><u>pointers</u>, unspecified result
</pre>
<p>— <em>end example</em>]</p>
</blockquote>
<h3 id="diff.expr">#[diff.expr]</h3>
<p>Change paragraph 5:</p>
<blockquote>
<p><strong>Affected subclauses:</strong> [expr.rel] and [expr.eq]<br />
<strong>Change:</strong> C allows directly comparing two objects of
array type; C++ does not.<br />
<strong>Rationale:</strong> The behavior is confusing because it
compares not the contents of the two arrays, but <u>pointers to
</u>their <s>addresses</s><u>first elements</u>.<br />
<strong>Effect on original feature:</strong> Deletion of semantically
well-defined feature that had unspecified behavior in common use
cases.<br />
[…]</p>
</blockquote>
</body>
</html>
