What if I write return statement in constructor?

What if I write return statement in constructor? Is it standard conformant?

struct A
{ 
     A() { return; } 
};

The above code compiles fine, without any error at ideone. But the following code doesn't:

struct A
{ 
   A() { return 100; } 
};

It gives this error at ideone:

error: returning a value from a constructor

I understand that returning value from constructor doesn't make sense at all, because it doesn't explicitly mention return type, and we cannot store the re开发者_高级运维turned value after all. But I'm curious to know :

• Which statement from the C++ Standard allows the first example but forbids the second one? Is there any explicit statement?
• Is the return type in the first example void?
• Is there any implicit return type at all?

---

Yes, using return statements in constructors is perfectly standard.

Constructors are functions that do not return a value. The family of functions that do not return a value consists of: void functions, constructors and destructors. It is stated in 6.6.3/2 in the C++ standard. The very same 6.6.3/2 states that it is illegal to use return with an argument in a function that does not return a value.

6.6.3 The return statement

2 A return statement without an expression can be used only in functions that do not return a value, that is, a function with the return type void, a constructor (12.1), or a destructor (12.4). A return statement with an expression of non-void type can be used only in functions returning a value; the value of the expression is returned to the caller of the function.

Additionally, 12.1/12 states that

12.1 Constructors

12 No return type (not even void) shall be specified for a constructor. A return statement in the body of a constructor shall not specify a return value.

Note, BTW, that in C++ it is legal to use return with an argument in a void function, as long as the argument of return has type void

void foo() {
  return (void) 0; // Legal in C++ (but not in C)
}

This is not allowed in constructors though, since constructors are not void functions.

There's also one relatively obscure restriction relevant to the usage of return with constructors: it is illegal to use return in function-try-block of a constructor (with other functions it is OK)

15.3 Handling an exception

15 If a return statement appears in a handler of the function-try-block of a constructor, the program is ill formed.

---

Perhaps the notion of having typeless return in constructors is to control the termination of constructor function.

struct A
{ 
// more definitions     
A() 
{ 
if( !goodToGoOn)  
 return;
// the rest of the stuffs go here
} 
};

---

A constructor by definition does return something.

For the code below,

#include <string>
#include <iostream>
using namespace std;

class dog{
    private:
        string _name;
        string _breed;
    public:
        //initialise private variables to those passed in
        void init(string name, string breed)
        {
            _name = name;
            _breed = breed;
        }

        void bark(){cout << "BARK! BARK! My name is " << getName() << "\n";}

        string getBreed(){return _breed;}
        string getName(){return _name;}
    };

//can run with
int main(int argc, char** argv){
    //create a dog named Sally
    dog sally;
    //Initialise its variables
    sally.init("sally", "chocolate lab");
    sally.bark();
}

Here we create a void type function that initializes our dog object, then in our main function we must call that init function on our new dog object.But if use a constructor our code looks instead like

#include <string>
#include <iostream>
using namespace std;

class dog{
    private:
        string _name;
        string _breed;

    public:
        //Dog constructor to initialize passed in variables
        dog(string name, string breed){
            _name = name;
            _breed = breed;
        }

        void bark(){cout << "BARK! BARK! My name is " << getName() << "\n";}

        string getBreed(){return _breed;}
        string getName(){return _name;}
};

//can run with
int main(int argc, char** argv){
    //create a dog named Sally
    dog sally("sally", "chocolate lab");
    sally.bark();
}

This code does essentially the same thing but it is to show that a constructor initializes the passed in variables and returns the object itself.

You cannot say

dog(string name, string breed)
    {
        _name = name;
        _breed = breed;
        return cout << "BARK! BARK! My name is " << getName() << "\n";
    }