Default constructors

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

C++ language

 

Classes

General

overview

class/struct types

union types

Members

data members

static members

the this pointer

nested classes

member templates

bit fields

using-declarations

member functions

member access specifiers

constructor initializer list

in-class brace-or-equal initializer(C++11)

friend specifier

Special member functions

default constructor

copy constructor

move constructor(C++11)

copy assignment operator

move assignment operator(C++11)

destructor

Inheritance

base and derived classes

virtual member functions

override(C++11)

final(C++11)

pure virtual functions and abstract classes

 

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.

Syntax

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

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

4) Explicitly forcing the automatic generation of a default constructor

ClassName is the identifier of the enclosing class

The default constructors are called during default initializations and value initializations.

Implicitly-declared default constructor

If no user-defined 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-defined constructors are present, the user may still force the generation of the implicitly declared constructor with the keyword default

(since C++11)

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

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 brace-or-equal initializer. (since C++11)
• T has a const member without user-defined default constructor or a brace-or-equal initializer (since C++11).
• T has a member (without a brace-or-equal 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.

(since C++11)

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

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 (that is, implicitly-defined or defaulted)
• T has no virtual member functions
• T has no virtual base classes

T has no non-static members with brace-or-equal 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. Objects with trivial default constructors can be created by using reinterpret_cast on any suitably aligned storage, e.g. on memory allocated with std::malloc. All data types compatible with the C language (POD types) are trivially default-constructible.

Example

struct A {
    int x;
    A(int x = 1) : x(x) {} // user-defined default ctor
};
struct B : A {
    // B::B() is implicitly-defined, calls A::A()
};
struct C {
    A obj;
    // 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 declared as deleted
};
 
int main()
{
    A a;
    B b;
//  D d; // compile error
    E e;
//  F f; // compile error
}