Class A {
public:
A(int i = 0, int k = 0) {} // default constructor WHY ??
~A() {}
};
int main()
{
A a; // This creates object using defined default
// constructor but the constructor still has two arguments
A b(1,2); // Called as parametrized one
}
Why this default argument constructor is default constructor. Why it is not called Parametrized constructor or default parametrized constructor because even if this constructor is called with no arguments it does contain two arguments ?? Is there any specific reason or its just because the standard says so.
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.
A default constructor is a constructor created by the compiler if we do not define any constructor(s) for a class. Here is an example: public class Student { String firstName; String lastName; int age; public static void main(String args[]) { Student myStudent = new Student(); myStudent.
A default constructor is a 0 argument constructor which contains a no-argument call to the super class constructor. To assign default values to the newly created objects is the main responsibility of default constructor.
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.
C++11 §12.1 Constructors
A default constructor for a class X is a constructor of class X that can be called without an argument.
This is the definition of default constructor. A constructor that supplies default arguments for all its parameters can be called without argument, thus fits the definition.
By definition, a default constructor is one that can be called without arguments. Yours cleary fits that definition, since both parameters have default value.
The asnwer to "why" is, I'd say, simply because C++ standard says so. The choice of constructor to be called is done by overload resolution based on number and types of parameters, just like with other functions.
The feature of constructor overload allow the compiler to infer which constructor to call based on the passed arguments. The default constructor is just the constructor which is resolved for no arguments, as in
A a;
or
A a=A();
And again due to parameters overloading only a single constructor can be resolved for each set. So, if all parameters have default values => it is ok to call 'A()' => it is the default constructor.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With