# Default constructors

> C++ Atlas: `cppatlas.com/w/cpp/language/default_constructor` | Source: https://en.cppreference.com/w/cpp/language/default_constructor | Domain: Language | Standards: C++11, C++17, C++20, C++23

A default constructor is a constructor which can be called with no arguments.

## Official Specification Summary (cppreference)

A default constructor is a constructor 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)

- `class-name` - the class whose default constructor is being declared
- `parameter-list` - a parameter list where all parameters (except parameter packs) (since C++11) have default arguments
- `function-body` - the function body of the default constructor

### 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 default initializations and value initializations.

### 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 `inline public` 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) noexcept specification (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 defined (that is, a function body is generated and compiled) by the compiler if odr-used or needed for constant evaluation (since C++11), and it 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 value initialization.

(since C++11):

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 (since C++11) default constructor for class `T` is undefined (until C++11) defined as deleted (since C++11) if any of the following conditions is satisfied:

- `T` is a union and all of its variant members are of const-qualified type (or possibly multi-dimensional array thereof).
- `T` is a non-union class and all members of any anonymous union member are of const-qualified type (or possibly multi-dimensional array thereof).
- `T` has a non-static data member of reference type without a default initializer (since C++11).
- `T` has a non-variant non-static non-const-default-constructible data member of const-qualified type (or possibly multi-dimensional array thereof) without a default member initializer (since C++11).
- `T` has a potentially constructed subobject of class type `M` (or possibly multi-dimensional array thereof) such that

  - `M` has a destructor that is deleted or (since C++11) inaccessible from the default constructor, or
  - all of the following conditions are satisfied:

  - The subobject is not a non-static data member with a default initializer.
  - The subobject is not a variant member of a union where another non-static data member has a default initializer. (since C++11)

  - The overload resolution as applied to find `M`'s default constructor

  - does not result in a usable candidate, or
  - in the case of the subobject being a variant member, selects a non-trivial function.

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 (i.e. performs no action) if all of the following is true:

- The constructor is not user-provided (i.e., is implicitly-defined or defaulted on its first declaration).
- `T` has no virtual member functions.
- `T` has no virtual base classes.

(since C++11):

- `T` has no non-static members with default initializers.

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

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)

(since C++20):

A default constructor is eligible if all following conditions are satisfied:

- It is not deleted.
- Its associated constraints (if any) are satisfied.
- No default constructor whose associated constraints are satisfied is more constrained.

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

### Example

```cpp
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
}
```

### Defect reports

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

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| CWG 1353 | C++98 | the conditions where implicitly-declared default constructors are undefined did not consider multi-dimensional array types | consider these types |
| CWG 2084 | 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 |
| CWG 2595 | 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 |
| CWG 2871 | 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

- [constructor](https://en.cppreference.com/w/cpp/language/initializer_list)
- [initialization](https://en.cppreference.com/w/cpp/language/initialization)
  - [aggregate initialization](https://en.cppreference.com/w/cpp/language/aggregate_initialization)
  - [constant initialization](https://en.cppreference.com/w/cpp/language/constant_initialization)
  - [copy initialization](https://en.cppreference.com/w/cpp/language/copy_initialization)
  - [default initialization](https://en.cppreference.com/w/cpp/language/default_initialization)
  - [direct initialization](https://en.cppreference.com/w/cpp/language/direct_initialization)
  - [list initialization](https://en.cppreference.com/w/cpp/language/list_initialization)
  - [reference initialization](https://en.cppreference.com/w/cpp/language/reference_initialization)
  - [value initialization](https://en.cppreference.com/w/cpp/language/value_initialization)
  - [zero initialization](https://en.cppreference.com/w/cpp/language/zero_initialization)
- [`new`](https://en.cppreference.com/w/cpp/language/new)

---
Attribution: content from https://en.cppreference.com/w/cpp/language/default_constructor (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.