9 Declarations [dcl.dcl]

9.5 Function definitions [dcl.fct.def]

9.5.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 or a comparison operator function ([over.binary]), and
(1.2)
not have default arguments.

The type T

_{1}

of an explicitly defaulted special member function F is allowed to differ from the type T

_{2}

it would have had if it were implicitly declared, as follows:

(2.1)
T $_{1}$ and T $_{2}$ may have differing ref-qualifiers;
(2.2)
T $_{1}$ and T $_{2}$ may have differing exception specifications; and
(2.3)
if T $_{2}$ has a parameter of type const C&, the corresponding parameter of T $_{1}$ may be of type C&.

If T

_{1}

differs from T

_{2}

in any other way, then:

(2.4)
if F is an assignment operator, and the return type of T $_{1}$ differs from the return type of T $_{2}$ or T $_{1}$ 's parameter type is not a reference, the program is ill-formed;
(2.5)
otherwise, if F is explicitly defaulted on its first declaration, it is defined as deleted;
(2.6)
otherwise, the program is ill-formed.

An explicitly-defaulted function that is not defined as deleted may be declared constexpr or consteval only if it is constexpr-compatible ([special], [class.compare.default]).

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

[ Example

struct S {
  constexpr S() = default;              // error: implicit S() is not constexpr
  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]), which might mean 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 defined at the point where it is explicitly defaulted; if such a function is implicitly defined as deleted, the program is ill-formed.

[ Note

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

]

[ Example

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

]