9 Declarations [dcl]

9.6 Function definitions [dcl.fct.def]

9.6.2 Explicitly-defaulted functions [dcl.fct.def.default]

A function definition whose function-body is of the form = default ; is called an explicitly-defaulted definition.

A function that is explicitly defaulted shall

(1.1)
be a special member function ([special]), comparison operator function ([over.binary], [class.compare.default]), or postfix increment or decrement operator function ([over.inc.default]), and
(1.2)
not have default arguments ([dcl.fct.default]).

The program is ill-formed if an explicitly defaulted special member function

F_{1}

of class C differs from the corresponding special member function

F_{2}

that would have been implicitly declared other than as follows:

(2.1)
if $F_{1}$ is an assignment operator, it may have the & ref-qualifier;
(2.2)
if $F_{2}$ is an assignment operator (which has an implicit object parameter of type “lvalue reference to C”), $F_{1}$ may have an explicit object parameter of type “lvalue reference to C”, in which case the type of $F_{1}$ would differ from the type of $F_{2}$ in that the type of $F_{1}$ has an additional parameter;
(2.3)
$F_{1}$ and $F_{2}$ may have differing exception specifications;
(2.4)
if $F_{2}$ has a non-object parameter of type “lvalue reference to const C”, the corresponding non-object parameter of $F_{1}$ may be of type “lvalue reference to C”; and
(2.5)
if $F_{2}$ has a non-object parameter of type “lvalue reference to C”, the corresponding non-object parameter of $F_{1}$ may be of type “lvalue reference to const C”; in this case only, $F_{1}$ is defined as deleted if it is explicitly defaulted on its first declaration and the program is ill-formed otherwise.

A function explicitly defaulted on its first declaration is implicitly inline ([dcl.inline]), and is implicitly constexpr ([dcl.constexpr]) if it is constexpr-suitable.

[Note 1:

Other defaulted functions are not implicitly constexpr.

— end note]

[Example 1: struct S { S(int a = 0) = default; // error: default argument void operator=(const S&) = default; // error: non-matching return type ~S() noexcept(false) = default; // OK, despite mismatched exception specification private: int i; S(S&); // OK, private copy constructor }; S::S(S&) = default; // OK, defines copy constructor struct T { T(); T(T &&) noexcept(false); }; struct U { T t; U(); U(U &&) noexcept = default; }; U u1; U u2 = static_cast<U&&>(u1); // OK, calls std::terminate if T::T(T&&) throws — end example]

Explicitly-defaulted functions and implicitly-declared functions are collectively called defaulted functions, and the implementation shall provide implicit definitions for them ([class.ctor], [class.dtor], [class.copy.ctor], [class.copy.assign]) as described below, including possibly defining them as deleted.

A defaulted prospective destructor ([class.dtor]) that is not a destructor is defined as deleted.

A defaulted special member function that is neither a prospective destructor nor an eligible special member function ([special]) is defined as deleted.

A function is user-provided if it is user-declared and not explicitly defaulted or deleted on its first declaration.

A user-provided explicitly-defaulted function (i.e., explicitly defaulted after its first declaration) is implicitly defined at the point where it is explicitly defaulted; if such a function is implicitly defined as deleted, the program is ill-formed.

[Note 2:

Declaring a function as defaulted after its first declaration can provide efficient execution and concise definition while enabling a stable binary interface to an evolving code base.

— end note]

A non-user-provided defaulted function (i.e., implicitly declared or explicitly defaulted in the class) that is not defined as deleted is implicitly defined when it is odr-used ([basic.def.odr]) or needed for constant evaluation ([expr.const.defns]).

[Note 3:

The implicit definition of a non-user-provided defaulted function does not bind any names.

— end note]

[Example 2: struct trivial { trivial() = default; trivial(const trivial&) = default; trivial(trivial&&) = default; trivial& operator=(const trivial&) = default; trivial& operator=(trivial&&) = default; ~trivial() = default; }; struct nontrivial1 { nontrivial1(); }; nontrivial1::nontrivial1() = default; // not first declaration — end example]