What is the method of constructor overloading in c plus plus?

Answer 1

Constructor overloading, just like any function's overloading, is where more than one configuration of parameters exists for the function. Based on the number and type of the parameters, different versions of the function can be resolved by the linker.

This is typically used in the constructor as the default constructor (no parameters), the copy constructor (one reference parameter of the same type as the class), and the conversion constructor (any other combination of parameters).

Answer 2

Yes. Depending on the signature (argument list) there can be several different constructors. The default constructor takes no arguments, the copy constructor takes one argument of class type, and the conversion constructor takes one argument of non-class type. Other constructors take more than one argument. Any constructor can have default parameters, making it possible for different types of constructors to share the same code body.

Answer 3

You overload a constructor by declaring two or more constructors in a class, each with different signatures.

When no constructor is specified, a default constructor and a copy constructor are implied. Both can be overridden. The default constructor can also be overloaded if all arguments are given default values in the declaration.

You can add as many construction overloads as required in order to initialise your class. If your class has many members to initialise, it may be helpful to use a structure and an overloaded constructor to accept the structure.

For every constructor that has exactly one argument, there should also be an equivalent assignment operator overload. The copy constructor assignment overload is implied if not specified.

Answer 4

That depends on how you define body of class. If you do not define constructors then compiler will provide default constructor and it is not overloaded. If you create your own constructor you automatically overload default constructor.

Answer 5

To construct a derived object we invoke the appropriate derived class constructor, just as we would for any non-derived object. However, every class constructor has an implicit initialiser list and this provides the means by which we can initialise member data efficiently (at the point of instantiation), but we can also use the initialiser list to invoke specific base class constructors where required. If we do not specify a base class constructor in the initialiser list, the base class default constructor will be invoked implicitly. But if there is no base class default constructor, or we wish to invoke a base class constructor other than the default, then we must specify it explicitly.

Given the following base class:

class A {

int value;

public:

A (int val = 0) value {val} {} // default constructor

A (const A& other): value {other.value} {}

// ...

};

A derived class might be defined as follows:

class B : public A {

public:

B (int val = 0): A {val} {}

B (const B& other): A {other} {}

// ...

};

Note how B's default constructor explicitly invokes A's default constructor, while B's copy constructor explicitly invokes A's copy constructor.