Default Constructor - C++

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 obj ; // object created and default constructor called automatically }

Allocating memory dynamically, the constructor may be called by adding parenthesis after the dynamic object. In a sense, this is an explicit call to the constructor.

int main { MyClass * MyClass_ptr = new MyClass ; // object created and default constructor called automatically }

If the constructor is declared with one or more parameters which all have default values, then it is still a default constructor. Remember that there could be only one default constructor in your class, may it be with default parameters or without any parameters.

MyClass (int i = 0){}

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 or new MyClass; the default constructor is used to initialize the object
• When an array of objects is declared, e.g. MyClass x;; or allocated dynamically, e.g. new MyClass ; 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(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; // for declaration do not need to know about existing constructors object_2 = new MyClass; // 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.