##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Default constructors

From cppreference.com
< cpp‎ | language

A default constructor is a constructor which can be called with no arguments (either defined with an empty parameter list, or with default arguments provided for every parameter). A type with a public default constructor is `DefaultConstructible`.

### [edit] Syntax

`ClassName` `(` `)` `;` | (1) |
`ClassName` `::` `ClassName` `(` `)` body | (2) |
`ClassName()` `=` `delete` `;` | (3) | (since C++11)
`ClassName()` `=` `default` `;` | (4) | (since C++11)

### [edit] Explanation

1) Declaration of a default constructor.
2) Definition of the constructor outside the class body.
3) Inhibiting the automatic generation of a default constructor by the compiler.
4) Explicitly forcing the automatic generation of a default constructor by the compiler.

`ClassName` is the identifier of the enclosing class

Default constructors are called during default initializations and value initializations.

### [edit] Implicitly-declared default constructor

If no user-declared constructors of any kind are provided for a class type (struct, class, or union), the compiler will always declare a default constructor as an `inline public` member of its class.

If some user-declared 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)

The implicitly-declared (or defaulted on its first declaration) default constructor has an exception specification as described in dynamic exception specification (until C++17)exception specification (since C++17)

### [edit] Implicitly-defined default constructor

If the implicitly-declared default constructor is not defined as deleted, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used, and it has exactly 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.

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)

### [edit] Deleted implicitly-declared default constructor

The implicitly-declared or defaulted default constructor for class `T` is undefined (until C++11)defined as deleted (since C++11) if any of the following is true:

- `T` has a member of reference type without a default initializer. (since C++11)
- `T` has a const member without user-defined default constructor or a default member initializer (since C++11).
- `T` has a member (without a default member initializer) (since C++11) which has a deleted default constructor, or its default constructor is ambiguous or inaccessible from this constructor.
- `T` has a direct or virtual base which has a deleted default constructor, or it is ambiguous or inaccessible from this constructor.
- `T` has a direct or virtual base which has a deleted destructor, or a destructor that is inaccessible from this constructor.

`T` is a union with at least one variant member with non-trivial default constructor, and no variant member of `T` has a default member initializer. `T` is a non-union class with a variant member `M` with a non-trivial default constructor, and no variant member of the anonymous union containing `M` has a default member initializer. | (since C++11)

- `T` is a union and all of its variant members are const.

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)

### [edit] 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)
- `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 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. Unlike in C, however, objects with trivial default constructors cannot be created by simply reinterpreting suitably aligned storage, such as memory allocated with std::malloc: placement-new is required to formally introduce a new object and avoid potential undefined behavior.

### [edit] 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 2084 | C++11 | default member initializers have no effect on whether a defaulted default constructor of a union is deleted | they prevent the defaulted default constructor from being defined as deleted

### [edit] Example

Run this code

    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
    };

    int main()
    {
        A a;
        B b;
        C c;
    //  D d; // compile error
        E e;
    //  F f; // compile error
    }

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/language/default_constructor&oldid=89110"