Default constructors

• 1 Syntax
• 2 Explanation
• 3 Implicitly-declared default constructor
• 4 Implicitly-defined default constructor
• 5 Deleted default constructor
• 6 Trivial default constructor
• 7 Eligible default constructor
• 8 Notes
• 9 Example
• 10 Defect reports
• 11 See also

If a default constructor of a union-like class 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 implicit-lifetime type, the default constructor of T begins the lifetime of that member if it is not the active member of its union.

If this satisfies the requirements of a constexpr constructor (until C++23)constexpr function (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.

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-union class and(since C++26) has a non-variant non-static non-const-default-constructible data member of const-qualified type (or possibly multidimensional array thereof) without a default member initializer.

• 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.

[edit] 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 user-provided (since C++11).
• T has no virtual member functions.
• T has no virtual base classes.

• Every direct base of T has a trivial default constructor.

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.

[edit] Eligible default constructor

Triviality of eligible default constructors determines whether the class is an implicit-lifetime type, and whether the class is a trivially copyable type.

[edit] Notes

[edit] Example

struct A
{
 int x;
 A(int x = 1): x(x) {} // user-defined default constructor
};
 
struct B : A
{
 // B::B() is implicitly-defined, calls A::A()
};
 
struct C
{
 A a;
 // C::C() is implicitly-defined, calls A::A()
};
 
struct D : A
{
 D(int y) : A(y) {}
 // D::D() is not declared because another constructor exists
};
 
struct E : A
{
 E(int y) : A(y) {}
 E() = default; // explicitly defaulted, calls A::A()
};
 
struct F
{
 int& ref; // reference member
 const int c; // 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 constructor
 
struct G
{
 G(const G&) {}
 // G::G() is implicitly defined as deleted
};
 
struct H
{
 H(const H&) = delete;
 // H::H() is implicitly defined as deleted
};
 
struct I
{
 I(const I&) = default;
 // I::I() is implicitly defined as deleted
};
 
int main()
{
 A a;
 B b;
 C c;
// D d; // compile error
 E e;
// F f; // compile error
// G g; // compile error
// H h; // compile error
// I i; // compile error
}

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

• constructor
• initialization
  • aggregate initialization
  • constant initialization
  • copy initialization
  • default initialization
  • direct initialization
  • list initialization
  • reference initialization
  • value initialization
  • zero initialization
• new