8 Declarators [dcl.decl]

A function definition of the form:

attribute-specifier-seqopt decl-specifier-seqopt declarator virt-specifier-seqopt  = default ;

is called an explicitly-defaulted definition. A function that is explicitly defaulted shall

• (1.1)

  be a special member function,

• (1.2)

  have the same declared function type (except for possibly differing ref-qualifiers and except that in the case of a copy constructor or copy assignment operator, the parameter type may be “reference to non-const T”, where T is the name of the member function's class) as if it had been implicitly declared, and

• (1.3)

  not have default arguments.

An explicitly-defaulted function may be declared constexpr only if it would have been implicitly declared as constexpr. If a function is explicitly defaulted on its first declaration,

• (2.1)

  it is implicitly considered to be constexpr if the implicit declaration would be, and,

• (2.2)

  it is implicitly considered to have the same exception-specification as if it had been implicitly declared ([except.spec]).

If a function that is explicitly defaulted has an explicit exception-specification that is not compatible ([except.spec]) with the exception-specification on the implicit declaration, then

• (3.1)

  if the function is explicitly defaulted on its first declaration, it is defined as deleted;

• (3.2)

  otherwise, the program is ill-formed.

[ Example:

struct S {
  constexpr S() = default;                  // ill-formed: implicit S() is not constexpr
  S(int a = 0) = default;                   // ill-formed: default argument
  void operator=(const S&) = default;       // ill-formed: non-matching return type
  ~S() throw(int) = default;                // deleted: exception specification does not match
private:
  int i;
  S(S&);                                    // OK: private copy constructor
};
S::S(S&) = default;                         // OK: defines copy constructor

 — 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]), which might mean defining them 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 ]