[basic.start] - C++11 → C++14

Files changed (1) hide show

tmp/tmpjdh5fx2c/{from.md → to.md} +31 -35

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

@@ -10,37 +10,33 @@ function. In a freestanding environment, start-up and termination is
 constructors for objects of namespace scope with static storage
 duration; termination contains the execution of destructors for objects
 with static storage duration.
 An implementation shall not predefine the `main` function. This function
-shall not be overloaded. It shall have a return type of type `int`, but
-otherwise its type is *implementation-defined*. All implementations
-shall allow both of the following definitions of `main`:
-``` cpp
-int main() { /* ... */ }
-```
-and
-``` cpp
-int main(int argc, char* argv[]) { /* ... */ }
-```
-In the latter form `argc` shall be the number of arguments passed to the
-program from the environment in which the program is run. If `argc` is
-nonzero these arguments shall be supplied in `argv[0]` through
-`argv[argc-1]` as pointers to the initial characters of null-terminated
-multibyte strings (NTMBS s) ([[multibyte.strings]]) and `argv[0]` shall
-be the pointer to the initial character of a NTMBSthat represents the
-name used to invoke the program or `""`. The value of `argc` shall be
-non-negative. The value of `argv[argc]` shall be 0. It is recommended
-that any further (optional) parameters be added after `argv`.
 The function `main` shall not be used within a program. The linkage (
 [[basic.link]]) of `main` is *implementation-defined*. A program that
-defines `main` as deleted or that declares `main` to be `inline,`
 `static`, or `constexpr` is ill-formed. The name `main` is not otherwise
 reserved. member functions, classes, and enumerations can be called
 `main`, as can entities in other namespaces.
 Terminating the program without leaving the current block (e.g., by
@@ -70,29 +66,29 @@ initiation. Non-local variables with thread storage duration are
 initialized as a consequence of thread execution. Within each of these
 phases of initiation, initialization occurs as follows.
 Variables with static storage duration ([[basic.stc.static]]) or thread
 storage duration ([[basic.stc.thread]]) shall be zero-initialized (
-[[dcl.init]]) before any other initialization takes place.
-*Constant initialization* is performed:
 - if each full-expression (including implicit conversions) that appears
   in the initializer of a reference with static or thread storage
   duration is a constant expression ([[expr.const]]) and the reference
   is bound to an lvalue designating an object with static storage
-  duration or to a temporary (see  [[class.temporary]]);
 - if an object with static or thread storage duration is initialized by
-  a constructor call, if the constructor is a `constexpr` constructor,
- if all constructor arguments are constant expressions (including
-  conversions), and if, after function invocation substitution (
-  [[dcl.constexpr]]), every constructor call and full-expression in the
-  *mem-initializer*s and in the *brace-or-equal-initializer*s for
-  non-static data members is a constant expression;
 - if an object with static or thread storage duration is not initialized
-  by a constructor call and if every full-expression that appears in its
-  initializer is a constant expression.
 Together, zero-initialization and constant initialization are called
 *static initialization*; all other initialization is *dynamic
 initialization*. Static initialization shall be performed before any
 dynamic initialization takes place. Dynamic initialization of a
@@ -150,11 +146,11 @@ double d1 = fd();   // may be initialized statically or dynamically to 1.0
 It is *implementation-defined* whether the dynamic initialization of a
 non-local variable with static storage duration is done before the first
 statement of `main`. If the initialization is deferred to some point in
 time after the first statement of `main`, it shall occur before the
 first odr-use ([[basic.def.odr]]) of any function or variable defined
-in the same translation unit as the variable to be initialized.[^10]
 ``` cpp
 // - File 1 -
 #include "a.h"
 #include "b.h"

 constructors for objects of namespace scope with static storage
 duration; termination contains the execution of destructors for objects
 with static storage duration.
 An implementation shall not predefine the `main` function. This function
+shall not be overloaded. It shall have a declared return type of type
+`int`, but otherwise its type is *implementation-defined*. An
+implementation shall allow both
+- a function of `()` returning `int` and
+- a function of `(int`, pointer to pointer to `char)` returning `int`
+as the type of `main` ([[dcl.fct]]). In the latter form, for purposes
+of exposition, the first function parameter is called `argc` and the
+second function parameter is called `argv`, where `argc` shall be the
+number of arguments passed to the program from the environment in which
+the program is run. If `argc` is nonzero these arguments shall be
+supplied in `argv[0]` through `argv[argc-1]` as pointers to the initial
+characters of null-terminated multibyte strings (NTMBS s) (
+[[multibyte.strings]]) and `argv[0]` shall be the pointer to the initial
+character of a NTMBSthat represents the name used to invoke the program
+or `""`. The value of `argc` shall be non-negative. The value of
+`argv[argc]` shall be 0. It is recommended that any further (optional)
+parameters be added after `argv`.
 The function `main` shall not be used within a program. The linkage (
 [[basic.link]]) of `main` is *implementation-defined*. A program that
+defines `main` as deleted or that declares `main` to be `inline`,
 `static`, or `constexpr` is ill-formed. The name `main` is not otherwise
 reserved. member functions, classes, and enumerations can be called
 `main`, as can entities in other namespaces.
 Terminating the program without leaving the current block (e.g., by
 initialized as a consequence of thread execution. Within each of these
 phases of initiation, initialization occurs as follows.
 Variables with static storage duration ([[basic.stc.static]]) or thread
 storage duration ([[basic.stc.thread]]) shall be zero-initialized (
+[[dcl.init]]) before any other initialization takes place. A *constant
+initializer* for an object `o` is an expression that is a constant
+expression, except that it may also invoke `constexpr` constructors for
+`o` and its subobjects even if those objects are of non-literal class
+types such a class may have a non-trivial destructor . *Constant
+initialization* is performed:
 - if each full-expression (including implicit conversions) that appears
   in the initializer of a reference with static or thread storage
   duration is a constant expression ([[expr.const]]) and the reference
   is bound to an lvalue designating an object with static storage
+  duration, to a temporary (see  [[class.temporary]]), or to a function;
 - if an object with static or thread storage duration is initialized by
+  a constructor call, and if the initialization full-expression is a
+ constant initializer for the object;
 - if an object with static or thread storage duration is not initialized
+  by a constructor call and if either the object is value-initialized or
+ every full-expression that appears in its initializer is a constant
+  expression.
 Together, zero-initialization and constant initialization are called
 *static initialization*; all other initialization is *dynamic
 initialization*. Static initialization shall be performed before any
 dynamic initialization takes place. Dynamic initialization of a
 It is *implementation-defined* whether the dynamic initialization of a
 non-local variable with static storage duration is done before the first
 statement of `main`. If the initialization is deferred to some point in
 time after the first statement of `main`, it shall occur before the
 first odr-use ([[basic.def.odr]]) of any function or variable defined
+in the same translation unit as the variable to be initialized.[^11]
 ``` cpp
 // - File 1 -
 #include "a.h"
 #include "b.h"

Diff to HTML by rtfpessoa