Krdytkyu

I can do this:

#include <iostream>



int counter;



int main()

{

    struct Boo

    {

        Boo(int num)

        {

            ++counter;

            if (rand() % num < 7) Boo(8);

        }

    };



    Boo(8);



    return 0;

}

This will compile fine, my counter result is 21. However when I try to create the Boo object passing the constructor argument instead of an integer literal I get a compile error:

#include <iostream>



int counter;



int main()

{

    struct Boo

    {

        Boo(int num)

        {

            ++counter;

            if (rand() % num < 7) Boo(num); // No default constructor 

                                            // exists for Boo

        }

    };



    Boo(8);



    return 0;

}

How is a default constructor called in the second example but not in the first example? This is error I get on Visual Studio 2017.

On the online C++ compiler onlineGDB I get the errors:

error: no matching function for call to ‘main()::Boo::Boo()’

    if (rand() % num < 7) Boo(num);



                           ^

note:   candidate expects 1 argument, 0 provided

Clang gives this warning message:

<source>:12:16: warning: parentheses were disambiguated as redundant parentheses around declaration of variable named 'num' [-Wvexing-parse]

            Boo(num); // No default constructor 

               ^~~~~

This is a most vexing parse issue. The compiler has to decide whether you want to call Boo with num as argument or whether you are writing a declaration Boo num; with extra parantheses around num. If both is possible the standard requires to assume a declaration.

If it is parsed as declaration, then Boo num; would call the default constructor (the constructor without arguments), which isn't declared either by you or implicitly.

This is not an issue with Boo(8);, because 8 cannot be a variable's identifier, so it is parsed as a call creating a Boo temporary with 8 as argument to the constructor, thereby not calling the default constructor (which is not declared), but the one you defined manually.

You can disambiguate this from a declaration by either using Boo{num}; instead of Boo(num); (because {} around the declarator is not allowed.), by making the temporary a named variable, e.g. Boo temp(num);, or by putting it as an operand in another expression, e.g. (Boo(num));, (void)Boo(num);, etc.

In any case it doesn't seem a good idea to misuse temporary object creation for something that should be a normal (member) function call.

This happens even though the declaration would be ill-formed as it changes the type of num, because of [stmt.ambig]/3:

The disambiguation is purely syntactic; that is, the meaning of the
names occurring in such a statement, beyond whether they are
type-names or not, is not generally used in or changed by the
disambiguation.

[...]

Disambiguation precedes parsing, and a statement disambiguated as a declaration may be an ill-formed declaration.

This is known as the "most vexing parse" (The term was used by Scott Meyers in Effective STL).

Boo(num) is not a call to the constructor. Clang gives a good warning to see:

<source>:12:38: warning: parentheses were disambiguated as redundant parentheses around declaration of variable named 'num' [-Wvexing-parse]

So you declared a Boo variable with name num, which needs the default constructor.
For Boo(8) this cannot happen, as the parser can be sure this is not a decleration and calls the constructor Boo(int).

The c++ standard, section 8.2, requires the compiler to assume this is a function declaration

C++ Standard 8.2 [dcl.ambig.res]
The ambiguity arising from the similarity between a function-style cast and a declaration mentioned in [stmt.ambig] can also occur in the context of a declaration. In that context, the choice is between a function declaration with a redundant set of parentheses around a parameter name and an object declaration with a function-style cast as the initializer. Just as for the ambiguities mentioned in [stmt.ambig], the resolution is to consider any construct that could possibly be a declaration a declaration. [ Note: A declaration can be explicitly disambiguated by a nonfunction-style cast, by an = to indicate initialization or by removing the redundant parentheses around the parameter name. — end note ]

[ Example:



struct S {

  S(int);

};



void foo(double a) {

  S w(int(a));      // function declaration

  S x(int());       // function declaration

  S y((int)a);      // object declaration

  S z = int(a);     // object declaration

}



 — end example ]

By the way: You can disambiguate by using enclosing parentheses:

 if (rand() % num < 7)  (Boo(num));

or in my opinion better, use the new uniform initialization syntax

if (rand() % num < 7)  Boo{num};

Which will then compile see here.