Because constructor function returns the object it creates, not Void.

Because constructor function returns the object it creates, not Void.

The constructor is a special function (for this reason there is no void) that is executed whenever an object is created.

Constructors method of a class is a representation of object so the return is an object instant , some times we use arguments to build objects that passed through class method constructor called from main program

If I recall correctly, a constructor applied to a datatype (int, float, user defined) first creates an instance of that datatype and then applies a set of default or user defined actions on that datatype (possible initializations of data). If a function is declared:

int i;

void *j;

with the declaration of i, you get the normal integer constructor.

with void pointers (*j), what kind of constructor would you think should be invoked? All that is known is that it is a pointer, but not what it will reference. when it is dereferenced via a cast

i = (int) j;

i has already had the integer constructor run when the object, i, was initially allocated.

As for a void function(), the whole point is to make sure that there is nothing returned from it, and no expectation it will return anything. in fact, there should be compilation issues (warning or errors) if you try to return a value from a void function. Likewise there should be similar issues if you have the return of that function assigned to a variable.

hmm... Very Interesting & understandable :)

Thanks a lot to all of U 4 ur's kind replies.

In which case you expect a constructor to return void type ? A constructor always returns a new object instance of the class where the constructor is defined.

The constructor is not even allowed to return null as when you write:

Object a = new Object();

You always expect 'a' to be created. If an error occurs during construction at best the constructor should throw an exception. Also for native datatype (as int, float, double, pointer...) you don't have constructor, constructor is called when you have 'new' followed by the class name you want to create a new instance for.

Yet another answer:

From the user's perspective, constructors DO "return" a value. So one might prefer to define the syntax so they looked more like ordinary non-void functions, e.g.

MyClass make (...) { // where "make" is a magical function name

...

return someObject;

}

But then the question arises: what would someObject be? It can't be a local variable, because returning a (non-primitive) local variable invokes a copy constructor, and how would we write that copy constructor without invoking itself? It can't be a reference to a local variable, because returning references to locals leads to dangling-reference bugs. It can't be a pointer to a heap-allocated object, because C++ constructors produce objects, not pointers (and they're frequently invoked in contexts that should create local, not heap-allocated, objects). And where would someObject come from, if not invoking a constructor (which again leads to infinite recursion)? So we would need to invent some kind of special syntax to refer to "the object that was created by this constructor". Rather than doing that, Stroustrup decided to invent a special syntax for *declaring* a constructor: it doesn't contain explicit "return" statements, and it has no return type at all (or if you prefer, it has a return type but no function name at all).

That said, constructors in both Java and C++ really irritate me. They can't be inherited or overridden, they can't return instances of subclasses of the specified class....

exactly...u r right...Stephen Bloch

thanks a lot of all others too 4 sharing ur views....

Reading the previous answers I started to think that a constructor just does not behave like function. Malika, you are right that a constructor should return void, but at the same time you are also wrong.

This occurred to me when I read Stephane's answer. The constructor will never return a null pointer because it returns nothing. In your example

Object *a = new Object(...); // (1)

the new-operator can return a null pointer or throw a bad_alloc exception. The memory is allocated by the new-operator and on this memory location the constructor is called to initialize the data. But what if I don't use 'new'? What if I write

Object a(...); // (2)

or even

Object a = Object(...); // (3)

? First of all, both notations are equivalent. The declaration of 'a' will reserve memory on the stack and--like with the dynamically allocated object in the previous example (1)--next will call the constructor on this memory location. (If the stack is full the application will crash before the constructor is called!) So, since the constructor works on a memory location it does not return anything. And if it would return the object itself then we would either need a copy constructor (darn it, it's a constructor after all) or an assignment operator. But, you probably already know that an assignment operator is not necessary in every class.

But, then what about case (3)? It looks like an assignment and can only work if the right-hand side returns an Object. Although it looks like you need an assignment operator, a copy constructor is enough. But, most compilers today are smart enough to reduce this to case (2) (look up 'copy elision'). Because otherwise we would construct 2 objects: first, an object on the right-hand side (rhs), and second an object on the left-hand side (lhs). Then, the rhs-object would be copied to the lhs-object through the copy constructor and finally the rhs-object will be destroyed.

To sum it up: whenever it looks like you are just calling the constructor, there are two things that happen. First, memory will be reserved--either dynamically through 'new' or statically on the heap. Next, the constructor will be called on this memory (returning nothing). Finally, the part that reserved the memory returns the object. Because of this special treatment a constructor is not like a regular function. And although the constructor of its own returns 'void', it looks like it is returning a new instance of this class when called. Declaring the constructor either as 'void Object();' or as 'Object Object();' would both be confusing and misleading. So, we are better off with not defining its return type.

Maybe a little addition to my previous answer: for many other languages the statement "the constructor returns an object" is true, just like posted in previous answers. But as you see, C++ is a little bit more complicated...

Constructor is not like any ordinary method or function, it has no return type, thus it does not return void.

Constructors don't create objects. They don't return an object and, in my understanding, you does never call constructors directly.

An object is a region of storage. I don't know what is the definition of "construction", but the lifetime of an object begins when its initialization is complete. I mean, the general procedure is as follows:

When an object of type T has to be created, the compiler has to reserve storage for the object (accoding to its size: sizeof(T)), and after that, this storage has to be initialize with a proper value. When initialization is finished, the lifetime of the object begins (3.8p1 in the standard).

How is that initialization performed? The initialization is different if the object is of a non-class type, of a class type with a trivial default constructor (the constructor which the implementation does automatically create if you don't define one), or without a trivial default constructor.

In the third case, when we write a constructor for a class T, the body of the construction controlls the initialization of the object of class T.

So, when we write something like:

- T t; or

- T() within another expression

we are not "calling a constructor" and T() isn't a call to a construtor. We are only creating an object, and the compiler reserve storage and calls implicitly the construction for us.

So, a constructor is a special type of procedure which does never appear in an expression.

Functions require the return type is specified, because, when you call a function in an expression, the compiler should know in compiling time what is the type of the expression for searching ill-formness. For example, a program is ill-formed if you call a procedure F inside an expression when a value is expected. The compiler can detect that this program is ill-formed since you are required to write that that function-procedure returns "void".

But since the compiler is who calls constructors and not you, constructors do never appear in expressions and it has no sense writting the type of the constructor, even not "void", since there's no type to "check".

Because void means returns nothing and constructor returns the address where it creates an object of a class.

A constructor function "constructs" something. If it returns void then it means it constructs nothing which is apparently not the case. The thing it constructs is an object of the class which offers the constructor

Thanks so much to all of u..i got my point.. 

Constructor is not similar to normal function. The definition of constructor and function is different. The objectives of function and constructor is different.