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.
Contents
- 1 Syntax
- 2 Explanation
- 3 Implicitly-declared default constructor
- 4 Implicitly-defined default constructor
- 5 Deleted implicitly-declared default constructor
- 6 Trivial default constructor
- 7 Eligible default constructor
- 8 Example
- 9 Defect reports
- 10 See also
[edit] Syntax
class-name (); | (1) | |
class-name :: class-name () body | (2) | |
class-name () = delete; | (3) | (since C++11) |
class-name () = default; | (4) | (since C++11) |
class-name :: class-name () = default; | (5) | (since C++11) |
Where class-name must name the current class (or current instantiation of a class template), or, when declared at namespace scope or in a friend declaration, it must be a qualified class name.
[edit] Explanation
1) Declaration of a default constructor inside of class definition.
2) Definition of the constructor outside of class definition (the class must contain a declaration (1)). See constructors and member initializer lists for details on the constructor body.
3) Deleted default constructor: if it is selected by overload resolution, the program fails to compile.
4) Defaulted default constructor: the compiler will define the implicit default constructor even if other constructors are present.
5) Defaulted default constructor outside of class definition (the class must contain a declaration (1)). Such constructor is treated as user-provided (see below and value initialization).
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 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 or defaulted default constructor during value initialization.
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. | (since C++11) |
[edit] Deleted implicitly-declared default constructor
The implicitly-declared or 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 is true:
- T has a member of reference type without a default initializer (since C++11).
- T has a non-const-default-constructible const member without 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 or a non-static data member which has a deleted destructor, or a destructor that is inaccessible from this constructor.
| (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 on its first declaration)
- T has no virtual member functions
- T has no virtual base classes
- 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.
[edit] 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
| (since C++20) |
Triviality of eligible default constructors determines whether the class is an implicit-lifetime type, and whether the class is a trivial type.
[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.
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] See also
- constructor
-
initialization
- aggregate initialization
- constant initialization
- copy initialization
- default initialization
- direct initialization
- list initialization
- reference initialization
- value initialization
- zero initialization
- new