[class.inhctor] - C++14 → C++17

Files changed (1) hide show

tmp/tmpo6qjsxs0/{from.md → to.md} +0 -310

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

@@ -1,310 +0,0 @@
-## Inheriting constructors <a id="class.inhctor">[[class.inhctor]]</a>
-A *using-declaration* ([[namespace.udecl]]) that names a constructor
-implicitly declares a set of *inheriting constructors*. The *candidate
-set of inherited constructors* from the class `X` named in the
-*using-declaration* consists of actual constructors and notional
-constructors that result from the transformation of defaulted parameters
-as follows:
-- all non-template constructors of `X`, and
-- for each non-template constructor of `X` that has at least one
-  parameter with a default argument, the set of constructors that
-  results from omitting any ellipsis parameter specification and
-  successively omitting parameters with a default argument from the end
-  of the parameter-type-list, and
-- all constructor templates of `X`, and
-- for each constructor template of `X` that has at least one parameter
-  with a default argument, the set of constructor templates that results
-  from omitting any ellipsis parameter specification and successively
-  omitting parameters with a default argument from the end of the
-  parameter-type-list.
-The *constructor characteristics* of a constructor or constructor
-template are
-- the template parameter list ([[temp.param]]), if any,
-- the *parameter-type-list* ([[dcl.fct]]),
-- absence or presence of `explicit` ([[class.conv.ctor]]), and
-- absence or presence of `constexpr` ([[dcl.constexpr]]).
-For each non-template constructor in the candidate set of inherited
-constructors other than a constructor having no parameters or a
-copy/move constructor having a single parameter, a constructor is
-implicitly declared with the same constructor characteristics unless
-there is a user-declared constructor with the same signature in the
-complete class where the *using-declaration* appears or the constructor
-would be a default, copy, or move constructor for that class. Similarly,
-for each constructor template in the candidate set of inherited
-constructors, a constructor template is implicitly declared with the
-same constructor characteristics unless there is an equivalent
-user-declared constructor template ([[temp.over.link]]) in the complete
-class where the *using-declaration* appears. Default arguments are not
-inherited. An *exception-specification* is implied as specified in
-[[except.spec]].
-A constructor so declared has the same access as the corresponding
-constructor in `X`. It is deleted if the corresponding constructor in
-`X` is deleted ([[dcl.fct.def]]). An inheriting constructor shall not
-be explicitly instantiated ([[temp.explicit]]) or explicitly
-specialized ([[temp.expl.spec]]).
-Default and copy/move constructors may be implicitly declared as
-specified in  [[class.ctor]] and  [[class.copy]].
-``` cpp
-struct B1 {
-  B1(int);
-};
-struct B2 {
-  B2(int = 13, int = 42);
-};
-struct D1 : B1 {
-  using B1::B1;
-};
-struct D2 : B2 {
-  using B2::B2;
-};
-```
-The candidate set of inherited constructors in `D1` for `B1` is
-- `B1(const B1&)`
-- `B1(B1&&)`
-- `B1(int)`
-The set of constructors present in `D1` is
-- `D1()`, implicitly-declared default constructor, ill-formed if
-  odr-used
-- `D1(const D1&)`, implicitly-declared copy constructor, not inherited
-- `D1(D1&&)`, implicitly-declared move constructor, not inherited
-- `D1(int)`, implicitly-declared inheriting constructor
-The candidate set of inherited constructors in `D2` for `B2` is
-- `B2(const B2&)`
-- `B2(B2&&)`
-- `B2(int = 13, int = 42)`
-- `B2(int = 13)`
-- `B2()`
-The set of constructors present in `D2` is
-- `D2()`, implicitly-declared default constructor, not inherited
-- `D2(const D2&)`, implicitly-declared copy constructor, not inherited
-- `D2(D2&&)`, implicitly-declared move constructor, not inherited
-- `D2(int, int)`, implicitly-declared inheriting constructor
-- `D2(int)`, implicitly-declared inheriting constructor
-If two *using-declaration*s declare inheriting constructors with the
-same signatures, the program is ill-formed ([[class.mem]],
-[[over.load]]), because an implicitly-declared constructor introduced by
-the first *using-declaration* is not a user-declared constructor and
-thus does not preclude another declaration of a constructor with the
-same signature by a subsequent *using-declaration*.
-``` cpp
-struct B1 {
-  B1(int);
-};
-struct B2 {
-  B2(int);
-};
-struct D1 : B1, B2 {
-  using B1::B1;
-  using B2::B2;
-};                  // ill-formed: attempts to declare D1(int) twice
-struct D2 : B1, B2 {
-  using B1::B1;
-  using B2::B2;
-  D2(int);          // OK: user declaration supersedes both implicit declarations
-};
-```
-An inheriting constructor for a class is implicitly defined when it is
-odr-used ([[basic.def.odr]]) to create an object of its class type (
-[[intro.object]]). An implicitly-defined inheriting constructor performs
-the set of initializations of the class that would be performed by a
-user-written `inline` constructor for that class with a
-*mem-initializer-list* whose only *mem-initializer* has a
-*mem-initializer-id* that names the base class denoted in the
-*nested-name-specifier* of the *using-declaration* and an
-*expression-list* as specified below, and where the *compound-statement*
-in its function body is empty ([[class.base.init]]). If that
-user-written constructor would be ill-formed, the program is ill-formed.
-Each *expression* in the *expression-list* is of the form
-`static_cast<T&&>(p)`, where `p` is the name of the corresponding
-constructor parameter and `T` is the declared type of `p`.
-``` cpp
-struct B1 {
-  B1(int) { }
-};
-struct B2 {
-  B2(double) { }
-};
-struct D1 : B1 {
-  using B1::B1;     // implicitly declares D1(int)
-  int x;
-};
-void test() {
-  D1 d(6);          // OK: d.x is not initialized
-  D1 e;             // error: D1 has no default constructor
-}
-struct D2 : B2 {
-  using B2::B2;     // OK: implicitly declares D2(double)
-  B1 b;
-};
-D2 f(1.0);          // error: B1 has no default constructor
-template< class T >
-struct D : T {
-  using T::T;       // declares all constructors from class T
-  ~D() { std::clog << "Destroying wrapper" << std::endl; }
-};
-```
-Class template `D` wraps any class and forwards all of its constructors,
-while writing a message to the standard log whenever an object of class
-`D` is destroyed.
-<!-- Link reference definitions -->
-[basic.def.odr]: basic.md#basic.def.odr
-[basic.life]: basic.md#basic.life
-[basic.lookup]: basic.md#basic.lookup
-[basic.lval]: basic.md#basic.lval
-[basic.start.init]: basic.md#basic.start.init
-[basic.start.term]: basic.md#basic.start.term
-[basic.stc]: basic.md#basic.stc
-[basic.stc.auto]: basic.md#basic.stc.auto
-[basic.stc.dynamic]: basic.md#basic.stc.dynamic
-[basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
-[basic.stc.static]: basic.md#basic.stc.static
-[basic.stc.thread]: basic.md#basic.stc.thread
-[basic.types]: basic.md#basic.types
-[class]: class.md#class
-[class.abstract]: class.md#class.abstract
-[class.access]: class.md#class.access
-[class.base.init]: #class.base.init
-[class.cdtor]: #class.cdtor
-[class.conv]: #class.conv
-[class.conv.ctor]: #class.conv.ctor
-[class.conv.fct]: #class.conv.fct
-[class.copy]: #class.copy
-[class.ctor]: #class.ctor
-[class.dtor]: #class.dtor
-[class.expl.init]: #class.expl.init
-[class.free]: #class.free
-[class.friend]: class.md#class.friend
-[class.inhctor]: #class.inhctor
-[class.init]: #class.init
-[class.mem]: class.md#class.mem
-[class.member.lookup]: class.md#class.member.lookup
-[class.mfct]: class.md#class.mfct
-[class.mi]: class.md#class.mi
-[class.qual]: basic.md#class.qual
-[class.temporary]: #class.temporary
-[class.union]: class.md#class.union
-[class.virtual]: class.md#class.virtual
-[conv]: conv.md#conv
-[conv.lval]: conv.md#conv.lval
-[dcl.array]: dcl.md#dcl.array
-[dcl.constexpr]: dcl.md#dcl.constexpr
-[dcl.fct]: dcl.md#dcl.fct
-[dcl.fct.def]: dcl.md#dcl.fct.def
-[dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
-[dcl.fct.default]: dcl.md#dcl.fct.default
-[dcl.fct.spec]: dcl.md#dcl.fct.spec
-[dcl.init]: dcl.md#dcl.init
-[dcl.init.aggr]: dcl.md#dcl.init.aggr
-[dcl.init.list]: dcl.md#dcl.init.list
-[dcl.init.ref]: dcl.md#dcl.init.ref
-[dcl.type.cv]: dcl.md#dcl.type.cv
-[diff.special]: compatibility.md#diff.special
-[except]: except.md#except
-[except.ctor]: except.md#except.ctor
-[except.spec]: except.md#except.spec
-[except.throw]: except.md#except.throw
-[expr]: expr.md#expr
-[expr.ass]: expr.md#expr.ass
-[expr.call]: expr.md#expr.call
-[expr.cast]: expr.md#expr.cast
-[expr.const.cast]: expr.md#expr.const.cast
-[expr.delete]: expr.md#expr.delete
-[expr.dynamic.cast]: expr.md#expr.dynamic.cast
-[expr.new]: expr.md#expr.new
-[expr.prim]: expr.md#expr.prim
-[expr.pseudo]: expr.md#expr.pseudo
-[expr.ref]: expr.md#expr.ref
-[expr.static.cast]: expr.md#expr.static.cast
-[expr.type.conv]: expr.md#expr.type.conv
-[expr.typeid]: expr.md#expr.typeid
-[expr.unary.op]: expr.md#expr.unary.op
-[intro.execution]: intro.md#intro.execution
-[intro.object]: intro.md#intro.object
-[namespace.udecl]: dcl.md#namespace.udecl
-[over.ass]: over.md#over.ass
-[over.best.ics]: over.md#over.best.ics
-[over.ics.ref]: over.md#over.ics.ref
-[over.load]: over.md#over.load
-[over.match]: over.md#over.match
-[over.match.best]: over.md#over.match.best
-[over.over]: over.md#over.over
-[special]: #special
-[stmt.dcl]: stmt.md#stmt.dcl
-[stmt.return]: stmt.md#stmt.return
-[temp.dep.type]: temp.md#temp.dep.type
-[temp.expl.spec]: temp.md#temp.expl.spec
-[temp.explicit]: temp.md#temp.explicit
-[temp.over.link]: temp.md#temp.over.link
-[temp.param]: temp.md#temp.param
-[temp.variadic]: temp.md#temp.variadic
-[^1]: The same rules apply to initialization of an `initializer_list`
-    object ([[dcl.init.list]]) with its underlying temporary array
-[^2]: These conversions are considered as standard conversions for the
-    purposes of overload resolution ([[over.best.ics]],
-    [[over.ics.ref]]) and therefore initialization ([[dcl.init]]) and
-    explicit casts ([[expr.static.cast]]). A conversion to `void` does
-    not invoke any conversion function ([[expr.static.cast]]). Even
-    though never directly called to perform a conversion, such
-    conversion functions can be declared and can potentially be reached
-    through a call to a virtual conversion function in a base class.
-[^3]: A similar provision is not needed for the array version of
-    `operator` `delete` because  [[expr.delete]] requires that in this
-    situation, the static type of the object to be deleted be the same
-    as its dynamic type.
-[^4]: This implies that the reference parameter of the
-    implicitly-declared copy constructor cannot bind to a `volatile`
-    lvalue; see  [[diff.special]].
-[^5]: Because a template assignment operator or an assignment operator
-    taking an rvalue reference parameter is never a copy assignment
-    operator, the presence of such an assignment operator does not
-    suppress the implicit declaration of a copy assignment operator.
-    Such assignment operators participate in overload resolution with
-    other assignment operators, including copy assignment operators,
-    and, if selected, will be used to assign an object.
-[^6]: This implies that the reference parameter of the
-    implicitly-declared copy assignment operator cannot bind to a
-    `volatile` lvalue; see  [[diff.special]].
-[^7]: Because only one object is destroyed instead of two, and one
-    copy/move constructor is not executed, there is still one object
-    destroyed for each one constructed.

Diff to HTML by rtfpessoa