9 Declarations [dcl.dcl]

9.4 Function definitions [dcl.fct.def]

9.4.1 In general [dcl.fct.def.general]

Function definitions have the form

function-definition:
	attribute-specifier-seq $_{o p t}$  decl-specifier-seq $_{o p t}$  declarator virt-specifier-seq $_{o p t}$  function-body
	attribute-specifier-seq $_{o p t}$  decl-specifier-seq $_{o p t}$  declarator requires-clause function-body

function-body:
	ctor-initializer $_{o p t}$  compound-statement
	function-try-block
	= default ;
	= delete ;

Any informal reference to the body of a function should be interpreted as a reference to the non-terminal function-body.

The optional attribute-specifier-seq in a function-definition appertains to the function.

A virt-specifier-seq can be part of a function-definition only if it is a member-declaration.

In a function-definition, either void declarator ; or declarator ; shall be a well-formed function declaration as described in [dcl.fct].

A function shall be defined only in namespace or class scope.

The type of a parameter or the return type for a function definition shall not be an incomplete or abstract (possibly cv-qualified) class type in the context of the function definition unless the function is deleted ([dcl.fct.def.delete]).

[ Example

A simple example of a complete function definition is

int max(int a, int b, int c) {
  int m = (a > b) ? a : b;
  return (m > c) ? m : c;
}

Here int is the decl-specifier-seq; max(int a, int b, int c) is the declarator; { /* ... */ } is the function-body.

— end example

]

A ctor-initializer is used only in a constructor; see [class.ctor] and [class.init].

[ Note

A cv-qualifier-seq affects the type of this in the body of a member function; see [dcl.ref].

— end note

]

[ Note

Unused parameters need not be named.

For example,

void print(int a, int) {
  std::printf("a = %d\n",a);
}

— end note

]

In the function-body, a function-local predefined variable denotes a block-scope object of static storage duration that is implicitly defined (see [basic.scope.block]).

The function-local predefined variable __func__ is defined as if a definition of the form

static const char __func__[] = "function-name";

had been provided, where function-name is an implementation-defined string.

It is unspecified whether such a variable has an address distinct from that of any other object in the program.104

[ Example

struct S {
  S() : s(__func__) { }             // OK
  const char* s;
};
void f(const char* s = __func__);   // error: __func__ is undeclared

— end example

]

104)

Implementations are permitted to provide additional predefined variables with names that are reserved to the implementation ([lex.name]).

If a predefined variable is not odr-used ([basic.def.odr]), its string value need not be present in the program image.

9.4.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 ([expr.spaceship], [expr.rel], [expr.eq]), and
(1.2)
not have default arguments.

The type T

_{1}

of an explicitly defaulted 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; and
(2.2)
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.3)
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.4)
otherwise, if F is explicitly defaulted on its first declaration, it is defined as deleted;
(2.5)
otherwise, the program is ill-formed.

An explicitly-defaulted function that is not defined as deleted may be declared constexpr only if it would have been implicitly declared as constexpr.

If a function is explicitly defaulted on its first declaration, it is implicitly considered to be constexpr if the implicit declaration would be.

[ 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() noexcept(false) = 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.ctor], [class.copy.assign]), 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

]

9.4.3 Deleted definitions [dcl.fct.def.delete]

A function definition whose function-body is of the form = delete ; is called a deleted definition.

A function with a deleted definition is also called a deleted function.

A program that refers to a deleted function implicitly or explicitly, other than to declare it, is ill-formed.

[ Note

This includes calling the function implicitly or explicitly and forming a pointer or pointer-to-member to the function.

It applies even for references in expressions that are not potentially-evaluated.

If a function is overloaded, it is referenced only if the function is selected by overload resolution.

The implicit odr-use ([basic.def.odr]) of a virtual function does not, by itself, constitute a reference.

— end note

]

[ Example

One can prevent default initialization and initialization by non-doubles with

struct onlydouble {
  onlydouble() = delete;                // OK, but redundant
  template<class T>
    onlydouble(T) = delete;
  onlydouble(double);
};

— end example

]

[ Example

One can prevent use of a class in certain new-expressions by using deleted definitions of a user-declared operator new for that class.

struct sometype {
  void* operator new(std::size_t) = delete;
  void* operator new[](std::size_t) = delete;
};
sometype* p = new sometype;     // error, deleted class operator new
sometype* q = new sometype[3];  // error, deleted class operator new[]

— end example

]

[ Example

One can make a class uncopyable, i.e., move-only, by using deleted definitions of the copy constructor and copy assignment operator, and then providing defaulted definitions of the move constructor and move assignment operator.

struct moveonly {
  moveonly() = default;
  moveonly(const moveonly&) = delete;
  moveonly(moveonly&&) = default;
  moveonly& operator=(const moveonly&) = delete;
  moveonly& operator=(moveonly&&) = default;
  ~moveonly() = default;
};
moveonly* p;
moveonly q(*p);                 // error, deleted copy constructor

— end example

]

A deleted function is implicitly an inline function ([dcl.inline]).

[ Note

The one-definition rule ([basic.def.odr]) applies to deleted definitions.

— end note

]

A deleted definition of a function shall be the first declaration of the function or, for an explicit specialization of a function template, the first declaration of that specialization.

An implicitly declared allocation or deallocation function ([basic.stc.dynamic]) shall not be defined as deleted.

[ Example

struct sometype {
  sometype();
};
sometype::sometype() = delete;  // ill-formed; not first declaration

— end example

]