Question

Observation: the codes pasted below were tested only with GCC 4.4.1, and I'm only interested in them working with GCC.

Hello,

It wasn’t for just a few times that I stumbled into an object construction statement that I didn’t understand, and it was only today that I noticed what ambiguity was being introduced by it. I’ll explain how to reproduce it and would like to know if there’s a way to fix it (C++0x allowed). Here it goes.

Suppose there is a class whose constructor takes only one argument, and this one argument’s type is another class with a default constructor. E.g.:

struct ArgType {};

class Class
{
public:
    Class(ArgType arg);
};

If I try to construct an object of type Class on the stack, I get an ambiguity:

Class c(ArgType()); // is this an object construction or a forward declaration
                    // of a function "c" returning `Class` and taking a pointer
                    // to a function returning `ArgType` and taking no arguments
                    // as argument? (oh yeh, loli haets awkward syntax in teh
                    // saucecode)

I say it’s an object construction, but the compiler insists it’s a forward declaration inside the function body. For you who still doesn’t get it, here is a fully working example:

#include <iostream>

struct ArgType {};
struct Class {};

ArgType func()
{
    std::cout << "func()\n";
    return ArgType();
}

int main()
{
    Class c(ArgType());

    c(func); // prints "func()\n"
}

Class c(ArgType funcPtr()) // Class c(ArgType (*funcPtr)()) also works
{
    funcPtr();
    return Class();
}

So well, enough examples. Anyone can help me get around this without making anything too anti-idiomatic (I’m a library developer, and people like idiomatic libraries)?

— edit

Never mind. This is a dupe of Most vexing parse: why doesn't A a(()); work?.

Thanks, sbi.

Answer 1

This is known as “C++’s most vexing parse”. See here and here.