Default constructor

In computer programming languages the term “default constructor” refers to a constructor that is automatically generated in the absence of explicit constructors (and perhaps under other circumstances); this automatically provided constructor is usually a nullary constructor. In specification or discussion of some languages, “default constructor” may additionally refer to any constructor that may be called without arguments, either because it is a nullary constructor or because all of its parameters have default values.

C++

In C++, the standard describes the default constructor for a class as a constructor that can be called with no arguments (this includes a constructor whose parameters all have default arguments). For example:

class MyClass
{
    int x;
    int y;
public:
    MyClass();                                 // constructor declared
};

MyClass :: MyClass()                           // constructor defined   
{
    x = 100;
    y = 200;
}

int main()
{
    MyClass object_1;                          // object created      
}

In C++, default constructors are significant because they are automatically invoked in certain circumstances:

• When an object value is declared with no argument list, e.g. MyClass x;; or allocated dynamically with no argument list, e.g. new MyClass; the default constructor is used to initialize the object
• When an array of objects is declared, e.g. MyClass x[10];; or allocated dynamically, e.g. new MyClass [10]; the default constructor is used to initialize all the elements
• When a derived class constructor does not explicitly call the base class constructor in its initializer list, the default constructor for the base class is called
• When a class constructor does not explicitly call the constructor of one of its object-valued fields in its initializer list, the default constructor for the field's class is called
• In the standard library, certain containers "fill in" values using the default constructor when the value is not given explicitly, e.g. vector<MyClass>(10); initializes the vector with 10 elements, which are filled with the default-constructed value of our type.

In the above circumstances, it is an error if the class does not have a default constructor.

The compiler will implicitly define a default constructor if no constructors are explicitly defined for a class. This implicitly-declared default constructor is equivalent to a default constructor defined with a blank body. For example:

class MyClass
{
    .....                                      // No Constructor          
};
int main()
{
    MyClass object_1;                          // No errors      
    ....
}

If some constructors are defined, but they are all non-default, the compiler will not implicitly define a default constructor. Hence, a default constructor may not exist for a class.This is the reason for a typical error which can be demonstrated by the following example.

class MyClass 
{
private:
    int x;
public:
    MyClass(int y);                            // A Constructor     
};
MyClass :: MyClass(int y)
{
    x = y;
}
int main()
{
    MyClass object_1(100);                     // Constructor Called           
    MyClass object_2;                          // Error: No default Constructor            
    return 0;
}

As a constructor of type other than default is defined the compiler does not define a default constructor and hence the creation of object_2 leads to an error.

Java and C#

In both Java and C#, a "default constructor" refers to a nullary constructor that is automatically generated by the compiler if no constructors have been defined for the class.The default constructor is also empty, meaning that it does nothing.