[class.copy] - C++11 → C++14

Files changed (1) hide show

tmp/tmprkcfuupw/{from.md → to.md} +81 -99

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

@@ -87,59 +87,35 @@ If the class definition does not explicitly declare a copy constructor,
 one is declared *implicitly*. If the class definition declares a move
 constructor or move assignment operator, the implicitly declared copy
 constructor is defined as deleted; otherwise, it is defined as
 defaulted ([[dcl.fct.def]]). The latter case is deprecated if the class
 has a user-declared copy assignment operator or a user-declared
-destructor. Thus, for the class definition
-``` cpp
-struct X {
-  X(const X&, int);
-};
-```
-a copy constructor is implicitly-declared. If the user-declared
-constructor is later defined as
-``` cpp
-X::X(const X& x, int i =0) { /* ... */ }
-```
-then any use of `X`’s copy constructor is ill-formed because of the
-ambiguity; no diagnostic is required.
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
-if
-- each direct or virtual base class `B` of `X` has a copy constructor
-  whose first parameter is of type `const` `B&` or `const` `volatile`
-  `B&`, and
-- for all the non-static data members of `X` that are of a class type
-  `M` (or array thereof), each such class type has a copy constructor
-  whose first parameter is of type `const` `M&` or `const` `volatile`
-  `M&`.[^4]
-Otherwise, the implicitly-declared copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 If the definition of a class `X` does not explicitly declare a move
 constructor, one will be implicitly declared as defaulted if and only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared copy assignment operator,
-- `X` does not have a user-declared move assignment operator,
-- `X` does not have a user-declared destructor, and
-- the move constructor would not be implicitly defined as deleted.
 When the move constructor is not implicitly declared or explicitly
 supplied, expressions that otherwise would have invoked the move
 constructor may instead invoke a copy constructor.
@@ -154,56 +130,54 @@ An implicitly-declared copy/move constructor is an `inline` `public`
 member of its class. A defaulted copy/move constructor for a class `X`
 is defined as deleted ([[dcl.fct.def.delete]]) if `X` has:
 - a variant member with a non-trivial corresponding constructor and `X`
   is a union-like class,
-- a non-static data member of class type `M` (or array thereof) that
   cannot be copied/moved because overload resolution ([[over.match]]),
   as applied to `M`’s corresponding constructor, results in an ambiguity
   or a function that is deleted or inaccessible from the defaulted
   constructor,
-- a direct or virtual base class `B` that cannot be copied/moved because
- overload resolution ([[over.match]]), as applied to `B`’s
-  corresponding constructor, results in an ambiguity or a function that
-  is deleted or inaccessible from the defaulted constructor,
-- any direct or virtual base class or non-static data member of a type
-  with a destructor that is deleted or inaccessible from the defaulted
-  constructor,
 - for the copy constructor, a non-static data member of rvalue reference
-  type, or
-- for the move constructor, a non-static data member or direct or
-  virtual base class with a type that does not have a move constructor
-  and is not trivially copyable.
 A copy/move constructor for class `X` is trivial if it is not
-user-provided and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
 - the constructor selected to copy/move each direct base class subobject
   is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 A copy/move constructor that is defaulted and not defined as deleted is
-*implicitly defined* if it is odr-used ([[basic.def.odr]]) to
-initialize an object of its class type from a copy of an object of its
-class type or of a class type derived from its class type[^5] or when it
 is explicitly defaulted after its first declaration. The copy/move
 constructor is implicitly defined even if the implementation elided its
 odr-use ([[basic.def.odr]], [[class.temporary]]). If the
 implicitly-defined constructor would satisfy the requirements of a
 `constexpr` constructor ([[dcl.constexpr]]), the implicitly-defined
 constructor is `constexpr`.
 Before the defaulted copy/move constructor for a class is implicitly
-defined, all non-user-provided copy/move constructors for its direct and
-virtual base classes and its non-static data members shall have been
-implicitly defined. An implicitly-declared copy/move constructor has an
 *exception-specification* ([[except.spec]]).
 The implicitly-defined copy/move constructor for a non-union class `X`
 performs a memberwise copy/move of its bases and members.
 *brace-or-equal-initializer*s of non-static data members are ignored.
@@ -229,11 +203,11 @@ The implicitly-defined copy/move constructor for a union `X` copies the
 object representation ([[basic.types]]) of `X`.
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
 parameter of type `X`, `X&`, `const` `X&`, `volatile` `X&` or `const`
-`volatile` `X&`.[^6] An overloaded assignment operator must be declared
 to have only one parameter; see  [[over.ass]]. More than one form of
 copy assignment operator may be declared for a class. If a class `X`
 only has a copy assignment operator with a parameter of type `X&`, an
 expression of type const `X` cannot be assigned to an object of type
 `X`.
@@ -268,11 +242,11 @@ if
 - each direct base class `B` of `X` has a copy assignment operator whose
   parameter is of type `const` `B&`, `const` `volatile` `B&` or `B`, and
 - for all the non-static data members of `X` that are of a class type
   `M` (or array thereof), each such class type has a copy assignment
   operator whose parameter is of type `const` `M&`, `const` `volatile`
-  `M&` or `M`.[^7]
 Otherwise, the implicitly-declared copy assignment operator will have
 the form
 ``` cpp
@@ -290,14 +264,12 @@ If the definition of a class `X` does not explicitly declare a move
 assignment operator, one will be implicitly declared as defaulted if and
 only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared move constructor,
-- `X` does not have a user-declared copy assignment operator,
-- `X` does not have a user-declared destructor, and
-- the move assignment operator would not be implicitly defined as
-  deleted.
 The class definition
 ``` cpp
 struct S {
@@ -337,24 +309,18 @@ deleted if `X` has:
 - a variant member with a non-trivial corresponding assignment operator
   and `X` is a union-like class, or
 - a non-static data member of `const` non-class type (or array thereof),
   or
 - a non-static data member of reference type, or
-- a non-static data member of class type `M` (or array thereof) that
-  cannot be copied/moved because overload resolution ([[over.match]]),
-  as applied to `M`’s corresponding assignment operator, results in an
-  ambiguity or a function that is deleted or inaccessible from the
-  defaulted assignment operator, or
-- a direct or virtual base class `B` that cannot be copied/moved because
-  overload resolution ([[over.match]]), as applied to `B`’s
-  corresponding assignment operator, results in an ambiguity or a
-  function that is deleted or inaccessible from the defaulted assignment
-  operator, or
-- for the move assignment operator, a non-static data member or direct
-  base class with a type that does not have a move assignment operator
-  and is not trivially copyable, or any direct or indirect virtual base
-  class.
 Because a copy/move assignment operator is implicitly declared for a
 class if not declared by the user, a base class copy/move assignment
 operator is always hidden by the corresponding assignment operator of a
 derived class ([[over.ass]]). A *using-declaration* (
@@ -365,27 +331,38 @@ declaration of such an operator and does not suppress the implicit
 declaration of the derived class operator; the operator introduced by
 the *using-declaration* is hidden by the implicitly-declared operator in
 the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
-user-provided and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
 - the assignment operator selected to copy/move each direct base class
   subobject is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 otherwise the copy/move assignment operator is *non-trivial*.
-A copy/move assignment operator that is defaulted and not defined as
-deleted is *implicitly defined* when it is odr-used ([[basic.def.odr]])
-(e.g., when it is selected by overload resolution to assign to an object
-of its class type) or when it is explicitly defaulted after its first
-declaration.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members shall have
 been implicitly defined. An implicitly-declared copy/move assignment
@@ -436,19 +413,20 @@ member function is not accessible (Clause  [[class.access]]).
 Copying/moving one object into another using the copy/move constructor
 or the copy/move assignment operator does not change the layout or size
 of either object.
 When certain criteria are met, an implementation is allowed to omit the
-copy/move construction of a class object, even if the copy/move
-constructor and/or destructor for the object have side effects. In such
-cases, the implementation treats the source and target of the omitted
-copy/move operation as simply two different ways of referring to the
-same object, and the destruction of that object occurs at the later of
-the times when the two objects would have been destroyed without the
-optimization.[^8] This elision of copy/move operations, called *copy
-elision*, is permitted in the following circumstances (which may be
-combined to eliminate multiple copies):
 - in a `return` statement in a function with a class return type, when
   the expression is the name of a non-volatile automatic object (other
   than a function or catch-clause parameter) with the same
   cv-unqualified type as the function return type, the copy/move
@@ -465,14 +443,15 @@ combined to eliminate multiple copies):
   same cv-unqualified type, the copy/move operation can be omitted by
   constructing the temporary object directly into the target of the
   omitted copy/move
 - when the of an exception handler (Clause  [[except]]) declares an
   object of the same type (except for cv-qualification) as the exception
-  object ([[except.throw]]), the copy/move operation can be omitted by
   treating the as an alias for the exception object if the meaning of
   the program will be unchanged except for the execution of constructors
-  and destructors for the object declared by the .
 ``` cpp
 class Thing {
 public:
   Thing();
@@ -496,22 +475,25 @@ function `f()` and the copying of that temporary object into object
 viewed as directly initializing the global object `t2`, and that
 object’s destruction will occur at program exit. Adding a move
 constructor to `Thing` has the same effect, but it is the move
 construction from the temporary object to `t2` that is elided.
-When the criteria for elision of a copy operation are met or would be
-met save for the fact that the source object is a function parameter,
-and the object to be copied is designated by an lvalue, overload
-resolution to select the constructor for the copy is first performed as
-if the object were designated by an rvalue. If overload resolution
-fails, or if the type of the first parameter of the selected constructor
-is not an rvalue reference to the object’s type (possibly cv-qualified),
-overload resolution is performed again, considering the object as an
-lvalue. This two-stage overload resolution must be performed regardless
-of whether copy elision will occur. It determines the constructor to be
-called if elision is not performed, and the selected constructor must be
-accessible even if the call is elided.
 ``` cpp
 class Thing {
 public:
   Thing();

 one is declared *implicitly*. If the class definition declares a move
 constructor or move assignment operator, the implicitly declared copy
 constructor is defined as deleted; otherwise, it is defined as
 defaulted ([[dcl.fct.def]]). The latter case is deprecated if the class
 has a user-declared copy assignment operator or a user-declared
+destructor.
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
+if each potentially constructed subobject of a class type `M` (or array
+thereof) has a copy constructor whose first parameter is of type `const`
+`M&` or `const` `volatile` `M&`.[^4] Otherwise, the implicitly-declared
+copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 If the definition of a class `X` does not explicitly declare a move
 constructor, one will be implicitly declared as defaulted if and only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared copy assignment operator,
+- `X` does not have a user-declared move assignment operator, and
+- `X` does not have a user-declared destructor.
 When the move constructor is not implicitly declared or explicitly
 supplied, expressions that otherwise would have invoked the move
 constructor may instead invoke a copy constructor.
 member of its class. A defaulted copy/move constructor for a class `X`
 is defined as deleted ([[dcl.fct.def.delete]]) if `X` has:
 - a variant member with a non-trivial corresponding constructor and `X`
   is a union-like class,
+- a potentially constructed subobject type `M` (or array thereof) that
   cannot be copied/moved because overload resolution ([[over.match]]),
   as applied to `M`’s corresponding constructor, results in an ambiguity
   or a function that is deleted or inaccessible from the defaulted
   constructor,
+- any potentially constructed subobject of a type with a destructor that
+ is deleted or inaccessible from the defaulted constructor, or,
 - for the copy constructor, a non-static data member of rvalue reference
+  type.
+A defaulted move constructor that is defined as deleted is ignored by
+overload resolution ([[over.match]], [[over.over]]). A deleted move
+constructor would otherwise interfere with initialization from an rvalue
+which can use the copy constructor instead.
 A copy/move constructor for class `X` is trivial if it is not
+user-provided, its parameter-type-list is equivalent to the
+parameter-type-list of an implicit declaration, and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
+- class `X` has no non-static data members of volatile-qualified type,
+  and
 - the constructor selected to copy/move each direct base class subobject
   is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 A copy/move constructor that is defaulted and not defined as deleted is
+*implicitly defined* if it is odr-used ([[basic.def.odr]]) or when it
 is explicitly defaulted after its first declaration. The copy/move
 constructor is implicitly defined even if the implementation elided its
 odr-use ([[basic.def.odr]], [[class.temporary]]). If the
 implicitly-defined constructor would satisfy the requirements of a
 `constexpr` constructor ([[dcl.constexpr]]), the implicitly-defined
 constructor is `constexpr`.
 Before the defaulted copy/move constructor for a class is implicitly
+defined, all non-user-provided copy/move constructors for its
+potentially constructed subobjects shall have been implicitly defined.
+An implicitly-declared copy/move constructor has an
 *exception-specification* ([[except.spec]]).
 The implicitly-defined copy/move constructor for a non-union class `X`
 performs a memberwise copy/move of its bases and members.
 *brace-or-equal-initializer*s of non-static data members are ignored.
 object representation ([[basic.types]]) of `X`.
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
 parameter of type `X`, `X&`, `const` `X&`, `volatile` `X&` or `const`
+`volatile` `X&`.[^5] An overloaded assignment operator must be declared
 to have only one parameter; see  [[over.ass]]. More than one form of
 copy assignment operator may be declared for a class. If a class `X`
 only has a copy assignment operator with a parameter of type `X&`, an
 expression of type const `X` cannot be assigned to an object of type
 `X`.
 - each direct base class `B` of `X` has a copy assignment operator whose
   parameter is of type `const` `B&`, `const` `volatile` `B&` or `B`, and
 - for all the non-static data members of `X` that are of a class type
   `M` (or array thereof), each such class type has a copy assignment
   operator whose parameter is of type `const` `M&`, `const` `volatile`
+  `M&` or `M`.[^6]
 Otherwise, the implicitly-declared copy assignment operator will have
 the form
 ``` cpp
 assignment operator, one will be implicitly declared as defaulted if and
 only if
 - `X` does not have a user-declared copy constructor,
 - `X` does not have a user-declared move constructor,
+- `X` does not have a user-declared copy assignment operator, and
+- `X` does not have a user-declared destructor.
 The class definition
 ``` cpp
 struct S {
 - a variant member with a non-trivial corresponding assignment operator
   and `X` is a union-like class, or
 - a non-static data member of `const` non-class type (or array thereof),
   or
 - a non-static data member of reference type, or
+- a potentially constructed subobject of class type `M` (or array
+ thereof) that cannot be copied/moved because overload resolution (
+ [[over.match]]), as applied to `M`’s corresponding assignment
+ operator, results in an ambiguity or a function that is deleted or
+ inaccessible from the defaulted assignment operator.
+A defaulted move assignment operator that is defined as deleted is
+ignored by overload resolution ([[over.match]], [[over.over]]).
 Because a copy/move assignment operator is implicitly declared for a
 class if not declared by the user, a base class copy/move assignment
 operator is always hidden by the corresponding assignment operator of a
 derived class ([[over.ass]]). A *using-declaration* (
 declaration of the derived class operator; the operator introduced by
 the *using-declaration* is hidden by the implicitly-declared operator in
 the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
+user-provided, its parameter-type-list is equivalent to the
+parameter-type-list of an implicit declaration, and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
+- class `X` has no non-static data members of volatile-qualified type,
+  and
 - the assignment operator selected to copy/move each direct base class
   subobject is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 otherwise the copy/move assignment operator is *non-trivial*.
+A copy/move assignment operator for a class `X` that is defaulted and
+not defined as deleted is *implicitly defined* when it is odr-used (
+[[basic.def.odr]]) (e.g., when it is selected by overload resolution to
+assign to an object of its class type) or when it is explicitly
+defaulted after its first declaration. The implicitly-defined copy/move
+assignment operator is `constexpr` if
+- `X` is a literal type, and
+- the assignment operator selected to copy/move each direct base class
+  subobject is a `constexpr` function, and
+- for each non-static data member of `X` that is of class type (or array
+  thereof), the assignment operator selected to copy/move that member is
+  a `constexpr` function.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members shall have
 been implicitly defined. An implicitly-declared copy/move assignment
 Copying/moving one object into another using the copy/move constructor
 or the copy/move assignment operator does not change the layout or size
 of either object.
 When certain criteria are met, an implementation is allowed to omit the
+copy/move construction of a class object, even if the constructor
+selected for the copy/move operation and/or the destructor for the
+object have side effects. In such cases, the implementation treats the
+source and target of the omitted copy/move operation as simply two
+different ways of referring to the same object, and the destruction of
+that object occurs at the later of the times when the two objects would
+have been destroyed without the optimization.[^7] This elision of
+copy/move operations, called *copy elision*, is permitted in the
+following circumstances (which may be combined to eliminate multiple
+copies):
 - in a `return` statement in a function with a class return type, when
   the expression is the name of a non-volatile automatic object (other
   than a function or catch-clause parameter) with the same
   cv-unqualified type as the function return type, the copy/move
   same cv-unqualified type, the copy/move operation can be omitted by
   constructing the temporary object directly into the target of the
   omitted copy/move
 - when the of an exception handler (Clause  [[except]]) declares an
   object of the same type (except for cv-qualification) as the exception
+  object ([[except.throw]]), the copy operation can be omitted by
   treating the as an alias for the exception object if the meaning of
   the program will be unchanged except for the execution of constructors
+  and destructors for the object declared by the . There cannot be a
+  move from the exception object because it is always an lvalue.
 ``` cpp
 class Thing {
 public:
   Thing();
 viewed as directly initializing the global object `t2`, and that
 object’s destruction will occur at program exit. Adding a move
 constructor to `Thing` has the same effect, but it is the move
 construction from the temporary object to `t2` that is elided.
+When the criteria for elision of a copy/move operation are met, but not
+for an , and the object to be copied is designated by an lvalue, or when
+the *expression* in a `return` statement is a (possibly parenthesized)
+*id-expression* that names an object with automatic storage duration
+declared in the body or *parameter-declaration-clause* of the innermost
+enclosing function or *lambda-expression*, overload resolution to select
+the constructor for the copy is first performed as if the object were
+designated by an rvalue. If the first overload resolution fails or was
+not performed, or if the type of the first parameter of the selected
+constructor is not an rvalue reference to the object’s type (possibly
+cv-qualified), overload resolution is performed again, considering the
+object as an lvalue. This two-stage overload resolution must be
+performed regardless of whether copy elision will occur. It determines
+the constructor to be called if elision is not performed, and the
+selected constructor must be accessible even if the call is elided.
 ``` cpp
 class Thing {
 public:
   Thing();

Diff to HTML by rtfpessoa