Why constructor does not have return type?

Answer 1

Constructors cannot have return types. The main job of the constructor is to create new instance of its class and return that instance. So the default return type of all constructor is the object of its class.

Answer 2

No. It would make no sense to return anything from a constructor (not even void) because constructors cannot be called directly from within your code.

When an object is constructed, whether statically allocated upon the stack at compile time or dynamically allocated upon the heap at runtime, memory must first be set aside for it and this mustoccur before the constructor is called. In the case of static variables, the memory is guaranteed to exist provided your program's data segment is large enough to accommodate an instance of your object (which can easily be determined at compile time, resulting in a compile time error upon failure). In the case of dynamic variables, however, there is no guarantee an allocation will succeed every time. Either way, if an allocation should fail for any reason, the constructor cannot be called because the object must exist in memory in order for the constructor to be able to initialise the memory allocated to it. Bear in mind that every instance of an object has an implicit this pointer that must exist at the point of construction. The only way that can be achieved is if memory is physically allocated to the object prior to the constructor being called. This allocation is transparent to the programmer because it is done automatically, Behind the Scenes.

Consider what happens when you instantiate an object dynamically. We'll use the following class declaration as an example:

class foo {

private: int m_data;

public: foo():m_data(0){}

};

To create an instance of this class dynamically, you would use the following line within your code:

foo* F = new foo();

Although it may look like you are calling the default constructor directly, you are actually calling the newoperator directly. The new operator expects you to pass the address of the required constructor as its operand, including any arguments required by that constructor. Thus you are effectively calling the constructor through the new operator.

The new operator first allocates enough memory to accommodate an instance of the class (including a v-table if it has one). In this case, the class only has one member variable of type int, thus sizeof(int) bytes are allocated to the entire class. If the class has more member variables, the allocated memory is divided up and assigned to each member variable, according to the order they were declared within the class declaration, including any padding for alignment purposes.

If the allocation fails for any reason, the new operator simply returns a NULL pointer which is then assigned to the F variable. Thus we need only ensure F is non-NULL to be assured we have a valid object. If F is NULL, then the object was never created and therefore the constructor was never called.

Assuming the allocation was successful, control immediately passes to the address that was passed to it: in this case the address of the default constructor. The default constructor subsequently initialises the member variable, foo::m_data by calling the int default constructor.

As an aside, initialising objects, including primitives, via a constructor's initialisation list is far more efficient than initialising them from the constructor body using assignment statements. This is because the default constructors of all member variables will be called implicitly unless you specify otherwise via the initialisation section. If you choose to initialise by assignment then you will effectively initialise the members twice: once via the default constructor and again via assignment. In the case of complex objects with many members to initialise, this can prove to be quite costly. Therefore get into the habit of always initialising though construction whenever possible. Note also that the initialisation section makes it possible to call specific base class constructors rather than their default constructors (thus a class' copy constructor can call its base class' copy constructor directly).

In this case the body has no code, so construction is complete once foo::m_data is initialised. The new operator then regains control and returns a pointer of type foo containing the starting address of our newly-constructed object, the value of which is subsequently assigned to the variable F.

If the constructor could return a value, then it would be completely lost to us by now. Remember that we didn't call the constructor directly, the new operator did it for us. Thus if the constructor could return a value, then it would have been received by the new operator, not our code.

Note that 100% OOP languages that do not support primitive pointers will throw exceptions during dynamic construction to indicate failures. But since C++ is not 100% OOP, we need only check the returned pointer is non-NULL before we use a dynamic object.

Statically allocated objects work exactly the same way, the only real difference being that memory is allocated and initialised at compile time rather than at runtime. Again, if the constructor could return a value, it would be completely lost to us because we never called the constructor directly, the compiler did it for us. The following is an example of static construction:

foo f; // statically allocated object constructed at compile time

Note that this is no different to declaring a static primitive such as int:

int i;

Although C++ allows int variables to be constructed using construction syntax, this is merely sugar-coating to allow primitives to behave in exactly the same way as objects:

int i = int(5);

In the above example, you are not actually calling a constructor since there is none to call. The compiler will simply replace the code with the equivalent primitive declaration:

int i = 5;

Answer 3

You can think of the constructor as returning a new object of its class type. So you can think of the constructor for the Point class to have a return type of Point.

Just keep in mind that constructors are special types of methods which follow some special rules.

Answer 4

Because, they are not methods to have a return type. The constructor by default creates an object of the class and that's all. It does not return any value, hence it has no return type.

The above hints at the reason why constructors don't have a declared return type, but let's make it explicit:

Constructor methods do have a return type. The return type is an Object of the type of the Class of the constructor.The reason this is not put in explicitly is because it CANNOT BE CHANGED - that is, a constructor, by definition, can only create an object of the class it is in. Thus, the return type is implied as the Class of the constructor method.

The purpose of a constructor is to create an instance of that Class, so letting a user change that return type is useless (and harmful). Since the return type cannot be changed, why require it to be provided (as that only allows for mistakes)?

Answer 5

No Way... The default return type of a constructor is the object of the same class. You cannot make a constructor explicitly return any other data type.

Answer 6

No, constructors don't return anything.