CODEWITHSUNDEEP
c++constructorstandards
mring
mring

Reputation: 1747

A most vexing parse error: constructor with no arguments

I was compiling a C++ program in Cygwin using g++ and I had a class whose constructor had no arguments. I had the lines:

MyClass myObj();
myObj.function1();

And when trying to compile it, I got the message:

error: request for member 'function1' in 'myObj', which is of non-class type 'MyClass ()()'

After a little research, I found that the fix was to change that first line to

MyClass myObj;

I could swear I've done empty constructor declarations with parentheses in C++ before. Is this probably a limitation of the compiler I'm using or does the language standard really say don't use parentheses for a constructor without arguments?

Upvotes: 56

Views: 33478

Answers (7)

sbk
sbk

Reputation: 9508

MyClass myObj();

That's parsed as a function declaration. The function is called myObj, takes no arguments and returns a MyClass object. I've never seen a compiler accepting that. On the other hand, MyClass* myPtr = new MyClass(); is acceptable, and may be that got you confused?

Upvotes: 4

Liz Albin
Liz Albin

Reputation: 1489

This is a fairly well-known issue and isn't compiler dependent. Essentially, you were declaring a function returning type MyObj. Not surprisingly, you couldn't call its constructor. See the C++ faq lite for a good explanation.

Upvotes: 11

Peter Alexander
Peter Alexander

Reputation: 54270

This is called the Most Vexing Parse issue. When the parser sees

MyClass myObj();

It thinks you are declaring a function called myObj that has no parameters and returns a MyClass.

To get around it, use:

MyClass myObj;

Upvotes: 58

CB Bailey
CB Bailey

Reputation: 791849

Although MyClass myObj(); could be parsed as an object definition with an empty initializer or a function declaration the language standard specifies that the ambiguity is always resolved in favour of the function declaration. An empty parentheses initializer is allowed in other contexts e.g. in a new expression or constructing a value-initialized temporary.

Upvotes: 63

suszterpatt
suszterpatt

Reputation: 8273

I found this in the C++ standard (§8.5.8):

An object whose initializer is an empty set of parentheses, i.e., (), shall be value-initialized.

[Note: since () is not permitted by the syntax for initializer,

X a ();

is not the declaration of an object of class X, but the declaration of a function taking no argument and returning an X. The form () is permitted in certain other initialization contexts (5.3.4, 5.2.3, 12.6.2). —end note ]

Upvotes: 20

Ari
Ari

Reputation: 3480

Your line makes the compiler think you are declaring a function named myObj which takes no arguments and returns a MyClass. This ambiguity resolution is indeed annoying.

Upvotes: 3

JonH
JonH

Reputation: 33143

The standard does not require parentheses.

int* x = new int;

is legal syntax.

In your case myclass myobj(); is a function prototype. Whereas myclass myobj; is a variable.

Upvotes: 1

Related Questions