A default constructor is a
which can be called with no arguments.
Syntax
class-name(parameter-list(optional));(1) class-name(parameter-list(optional))function-body(2) class-name() = default;(3) (since C++11)class-name(parameter-list(optional)) = delete;(4) (since C++11)class-name::class-name(parameter-list(optional))function-body(5) class-name::class-name() = default;(6) (since C++11)Explanation
1) Declaration of a default constructor inside of class definition.
2-4) Definition of a default constructor inside of class definition.
3) The default constructor is explicitly-defaulted.
4) The default constructor is deleted.
5,6) Definition of a default constructor outside of class definition (the class must contain a declaration (1)).
6) The default constructor is explicitly-defaulted.
Default constructors are called during
and
.
Implicitly-declared default constructor
If there is no user-declared constructor or constructor template for a class type, the compiler will implicitly declare a default constructor as an inlinepublic member of its class.
The implicitly-declared (or defaulted on its first declaration) default constructor has an exception specification as described in
dynamic exception specification
(until C++17)
(since C++17).
Implicitly-defined default constructor
If the constructor is implicitly-declared(until C++11)the implicitly-declared or explicitly-defaulted default constructor is not defined as deleted(since C++11), it is implicitly-defined by the compiler when
or
needed for constant evaluation
(since C++11).
If a default constructor of a
T is trivial, then for each union U that is either T or an anonymous union member of T, if the first variant member (if any) of U has
, the default constructor of T begins the lifetime of that member if it is not the active member of its union.
(since C++26)An(until C++26)Otherwise, an(since C++26) implicitly-defined default constructor has the same effect as a user-defined constructor with empty body and empty initializer list. That is, it calls the default constructors of the bases and of the non-static members of this class. Class types with an empty user-provided constructor may get treated differently than those with an implicitly-defined default constructor during
.
If this satisfies the requirements of a
(until C++23)
(since C++23), the generated constructor is constexpr.
If some user-defined constructors are present, the user may still force the automatic generation of a default constructor by the compiler that would be implicitly-declared otherwise with the keyword default.
(since C++11)Deleted default constructor
The implicitly-declared or explicitly-defaulted default constructor for class T is defined as deleted if any of the following conditions is satisfied:
T has a non-static data member of reference type without a default initializer.
T is a non-
class and(since C++26) has a non-variant non-static non-
data member of const-qualified type (or possibly multidimensional array thereof) without a default member initializer.
T is a
and all of its variant members are of const-qualified type (or possibly multidimensional array thereof).
T is a non-union class and all members of any
member are of const-qualified type (or possibly multidimensional array thereof).
(until C++26)Given a class type M, T has a
potentially constructed subobject
obj of type M (or possibly multidimensional array thereof), and any of the following conditions is satisfied:
M has a destructor that is deleted or inaccessible from the default constructor, and either obj is non-variant or obj has a default member initializer(since C++26).
All following conditions are satisfied:
obj is not a non-static data member with a default initializer.
obj is not a variant member of a union where another non-static data member has a default initializer(until C++26).
The overload resolution as applied to find M's default constructor does not result in a usable candidate, or in the case of obj being a variant member, selects a non-trivial function(until C++26).
If no user-defined constructors are present and the implicitly-declared default constructor is not trivial, the user may still inhibit the automatic generation of an implicitly-defined default constructor by the compiler with the keyword delete.
(since C++11)Trivial default constructor
The default constructor for class T is trivial if all following conditions are satisfied:
The constructor is implicitly-declared(until C++11)not
(since C++11).
T has no virtual member functions.
T has no virtual base classes.
T has no non-static members with default initializers.
(since C++11)Every direct base of T has a trivial default constructor.
Every non-static member of class type (or array thereof) has a trivial default constructor.
(until C++26)Either T is a union, or every non-variant non-static member of class type (or array thereof) has a trivial default constructor.
(since C++26)A trivial default constructor is a constructor that performs no action. All data types compatible with the C language (POD types) are trivially default-constructible.
Eligible default constructor
A default constructor is eligible if it is either user-declared or both implicitly-declared and definable.
(until C++11)A default constructor is eligible if it is not deleted.
(since C++11)
(until C++20)A default constructor is eligible if all following conditions are satisfied:
It is not deleted.
Its
(if any) are satisfied.
No default constructor whose associated constraints are satisfied is
.
(since C++20)Triviality of eligible default constructors determines whether the class is an
, and whether the class is a
.
Notes
Feature-test macroValueStdFeature
(C++26)Relaxing the triviality requirements for special member functions of unions Example
Run this code
structA{intx;A(intx=1):x(x){}// user-defined default constructor};structB:A{// B::B() is implicitly-defined, calls A::A()};structC{Aa;// C::C() is implicitly-defined, calls A::A()};structD:A{D(inty):A(y){}// D::D() is not declared because another constructor exists};structE:A{E(inty):A(y){}E()=default;// explicitly defaulted, calls A::A()};structF{int&ref;// reference memberconstintc;// const member// F::F() is implicitly defined as deleted};// user declared copy constructor (either user-provided, deleted or defaulted)// prevents the implicit generation of a default constructorstructG{G(constG&){}// G::G() is implicitly defined as deleted};structH{H(constH&)=delete;// H::H() is implicitly defined as deleted};structI{I(constI&)=default;// I::I() is implicitly defined as deleted};intmain(){Aa;Bb;Cc;// D d; // compile errorEe;// F f; // compile error// G g; // compile error// H h; // compile error// I i; // compile error}Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR Applied to Behavior as published Correct behavior
C++11 the conditions where implicitly-declared default constructors are
defined as deleted did not consider multidimensional array types consider these types
C++11 default member initializers had no effect on whether
a defaulted default constructor of a union is deleted they prevent the defaulted default
constructor from being deleted
C++20 a default constructor was not eligible if there is
another default constructor which is more constrained
but does not satisfy its associated constraints it can be eligible in this case
C++98 a default constructor would be implicitly declared
even if there is a user-declared constructor template no implicit declaration
in this case See also