[dcl.init.list] - C++11 → C++14

Files changed (1) hide show

tmp/tmp9vxv5rq3/{from.md → to.md} +82 -64

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

@@ -11,10 +11,11 @@ list-initialization in a copy-initialization context is called
 *copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
 - as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
@@ -36,22 +37,24 @@ A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
 arguments ([[dcl.fct.default]]). Initializer-list constructors are
 favored over other constructors in list-initialization (
-[[over.match.list]]).The template `std::initializer_list` is not
-predefined; if the header `<initializer_list>` is not included prior to
-a use of `std::initializer_list` — even an implicit use in which the
 type is not named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
-- If the initializer list has no elements and `T` is a class type with a
- default constructor, the object is value-initialized.
-- Otherwise, if `T` is an aggregate, aggregate initialization is
-  performed ([[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
@@ -60,13 +63,15 @@ follows:
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
-- Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
- an `initializer_list` object is constructed as described below and
-  used to initialize the object according to the rules for
   initialization of an object from a class of the same type (
   [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
@@ -100,15 +105,25 @@ follows:
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
 - Otherwise, if `T` is a reference type, a prvalue temporary of the type
-  referenced by `T` is list-initialized, and the reference is bound to
- that temporary. As usual, the binding will fail and the program is
- ill-formed if the reference type is an lvalue reference to a non-const
-  type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
@@ -118,18 +133,10 @@ follows:
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
-- Otherwise, if the initializer list has a single element, the object or
-  reference is initialized from that element; if a narrowing conversion
-  (see below) is required to convert the element to `T`, the program is
-  ill-formed.
-  ``` cpp
-  int x1 {2};                         // OK
-  int x2 {2.0};                       // error: narrowing
-  ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
@@ -164,17 +171,19 @@ ordering holds regardless of the semantics of the initialization; for
 example, it applies when the elements of the *initializer-list* are
 interpreted as arguments of a constructor call, even though ordinarily
 there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
-initializer list as if the implementation allocated an array of N
-elements of type `E`, where N is the number of elements in the
 initializer list. Each element of that array is copy-initialized with
 the corresponding element of the initializer list, and the
 `std::initializer_list<E>` object is constructed to refer to that array.
-If a narrowing conversion is required to initialize any of the elements,
-the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
@@ -183,35 +192,47 @@ X x{ 1,2,3 };
 The initialization will be implemented in a way roughly equivalent to
 this:
 ``` cpp
-double __a[3] = {double{1}, double{2}, double{3}};
 X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
-The lifetime of the array is the same as that of the `initializer_list`
-object.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::vector<cmplx> v2{ 1, 2, 3 };
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 ```
-For `v1` and `v2`, the `initializer_list` object and array created for
-`{ 1, 2, 3 }` have full-expression lifetime. For `i3`, the
-`initializer_list` object and array have automatic lifetime. The
-implementation is free to allocate the array in read-only memory if an
-explicit array with the same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
@@ -222,13 +243,12 @@ A *narrowing conversion* is an implicit conversion
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
-  where the source is a constant expression and the actual value after
- conversion will fit into the target type and will produce the original
-  value when converted back to the original type.
 As indicated above, such conversions are not allowed at the top level in
 list-initializations.
 ``` cpp
@@ -266,12 +286,13 @@ int a[] =
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
-[basic.scope.local]: basic.md#basic.scope.local
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
 [basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
@@ -295,11 +316,10 @@ int a[] =
 [class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
-[class.mfct.non-static]: class.md#class.mfct.non-static
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
@@ -307,19 +327,21 @@ int a[] =
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
@@ -357,15 +379,18 @@ int a[] =
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
-[expr.prim]: expr.md#expr.prim
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
@@ -376,19 +401,19 @@ int a[] =
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
 [namespace.memdef]: #namespace.memdef
 [namespace.qual]: basic.md#namespace.qual
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
-[over.ics.rank]: over.md#over.ics.rank
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
@@ -404,11 +429,10 @@ int a[] =
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
-[temp.arg]: temp.md#temp.arg
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
@@ -423,39 +447,35 @@ int a[] =
 [^1]: The “implicit int” rule of C is no longer supported.
 [^2]: The inline keyword has no effect on the linkage of a function.
-[^3]: The resulting converted value will include an lvalue-to-rvalue
-    conversion ([[conv.lval]]) if the corresponding copy-initialization
-    requires one.
-[^4]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
-[^5]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
-[^6]: Although entities in an unnamed namespace might have external
     linkage, they are effectively qualified by a name unique to their
     translation unit and therefore can never be seen from any other
     translation unit.
-[^7]: this implies that the name of the class or function is
     unqualified.
-[^8]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
-[^9]: A declaration with several declarators is usually equivalent to
     the corresponding sequence of declarations each with a single
     declarator. That is
     `T  D1, D2, ... Dn;`
@@ -485,42 +505,40 @@ int a[] =
     `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
     as opposed to
     `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
     `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
-[^10]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
-[^11]: This excludes parameters of type “ `T2`” where `T2` is “pointer
     to array of unknown bound of `T`” and where means any sequence of
     “pointer to” and “array of” derived declarator types. This exclusion
     applies to the parameters of the function, and if a parameter is a
     pointer to function or pointer to member function then to its
     parameters also, etc.
-[^12]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
-[^13]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
-[^14]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
     [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
-[^15]: As specified in  [[conv.ptr]], converting an integral constant
- expression whose value is `0` to a pointer type results in a null
- pointer value.
-[^16]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
-[^17]: Braces cannot be elided in other uses of list-initialization.
-[^18]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

 *copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
 - as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
+- as a *for-range-initializer* ([[stmt.iter]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
 arguments ([[dcl.fct.default]]). Initializer-list constructors are
 favored over other constructors in list-initialization (
+[[over.match.list]]). Passing an initializer list as the argument to the
+constructor template `template<class T> C(T)` of a class `C` does not
+create an initializer-list constructor, because an initializer list
+argument causes the corresponding parameter to be a non-deduced
+context ([[temp.deduct.call]]). The template `std::initializer_list` is
+not predefined; if the header `<initializer_list>` is not included prior
+to a use of `std::initializer_list` — even an implicit use in which the
 type is not named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
+- If `T` is an aggregate, aggregate initialization is performed (
+ [[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
+- Otherwise, if the initializer list has no elements and `T` is a class
+ type with a default constructor, the object is value-initialized.
+- Otherwise, if `T` is a specialization of `std::initializer_list<E>`, a
+  prvalue `initializer_list` object is constructed as described below
+  and used to initialize the object according to the rules for
   initialization of an object from a class of the same type (
   [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
+- Otherwise, if the initializer list has a single element of type `E`
+  and either `T` is not a reference type or its referenced type is
+  reference-related to `E`, the object or reference is initialized from
+  that element; if a narrowing conversion (see below) is required to
+  convert the element to `T`, the program is ill-formed.
+  ``` cpp
+  int x1 {2};                         // OK
+  int x2 {2.0};                       // error: narrowing
+  ```
 - Otherwise, if `T` is a reference type, a prvalue temporary of the type
+  referenced by `T` is copy-list-initialized or direct-list-initialized,
+ depending on the kind of initialization for the reference, and the
+ reference is bound to that temporary. As usual, the binding will fail
+ and the program is ill-formed if the reference type is an lvalue
+  reference to a non-const type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
 example, it applies when the elements of the *initializer-list* are
 interpreted as arguments of a constructor call, even though ordinarily
 there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
+initializer list as if the implementation allocated a temporary array of
+N elements of type `const E`, where N is the number of elements in the
 initializer list. Each element of that array is copy-initialized with
 the corresponding element of the initializer list, and the
 `std::initializer_list<E>` object is constructed to refer to that array.
+A constructor or conversion function selected for the copy shall be
+accessible (Clause  [[class.access]]) in the context of the initializer
+list. If a narrowing conversion is required to initialize any of the
+elements, the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
 The initialization will be implemented in a way roughly equivalent to
 this:
 ``` cpp
+const double __a[3] = {double{1}, double{2}, double{3}};
 X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
+The array has the same lifetime as any other temporary object (
+[[class.temporary]]), except that initializing an `initializer_list`
+object from the array extends the lifetime of the array exactly like
+binding a reference to a temporary.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::vector<cmplx> v2{ 1, 2, 3 };
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
+struct A {
+  std::initializer_list<int> i4;
+  A() : i4{ 1, 2, 3 } {}  // creates an A with a dangling reference
+};
 ```
+For `v1` and `v2`, the `initializer_list` object is a parameter in a
+function call, so the array created for `{ 1, 2, 3 }` has
+full-expression lifetime. For `i3`, the `initializer_list` object is a
+variable, so the array persists for the lifetime of the variable. For
+`i4`, the `initializer_list` object is initialized in a constructor’s
+*ctor-initializer*, so the array persists only until the constructor
+exits, and so any use of the elements of `i4` after the constructor
+exits produces undefined behavior. The implementation is free to
+allocate the array in read-only memory if an explicit array with the
+same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
+  where the source is a constant expression whose value after integral
+ promotions will fit into the target type.
 As indicated above, such conversions are not allowed at the top level in
 list-initializations.
 ``` cpp
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
+[basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
 [basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
 [class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
+[conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
+[dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
 [expr.ass]: expr.md#expr.ass
 [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.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
+[expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
+[lex.string]: lex.md#lex.string
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
 [namespace.memdef]: #namespace.memdef
 [namespace.qual]: basic.md#namespace.qual
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [^1]: The “implicit int” rule of C is no longer supported.
 [^2]: The inline keyword has no effect on the linkage of a function.
+[^3]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
+[^4]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
+[^5]: Although entities in an unnamed namespace might have external
     linkage, they are effectively qualified by a name unique to their
     translation unit and therefore can never be seen from any other
     translation unit.
+[^6]: this implies that the name of the class or function is
     unqualified.
+[^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
+[^8]: A declaration with several declarators is usually equivalent to
     the corresponding sequence of declarations each with a single
     declarator. That is
     `T  D1, D2, ... Dn;`
     `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
     as opposed to
     `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
     `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
+[^9]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
+[^10]: This excludes parameters of type “ `T2`” where `T2` is “pointer
     to array of unknown bound of `T`” and where means any sequence of
     “pointer to” and “array of” derived declarator types. This exclusion
     applies to the parameters of the function, and if a parameter is a
     pointer to function or pointer to member function then to its
     parameters also, etc.
+[^11]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
+[^12]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
+[^13]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
     [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
+[^14]: As specified in  [[conv.ptr]], converting an integer literal
+    whose value is `0` to a pointer type results in a null pointer
+    value.
+[^15]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
+[^16]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

Diff to HTML by rtfpessoa