Completely misleading declaration

  Assume we have a piece of code like this:

#include <map>

struct A { ... };
struct Comp { bool operator()(const A&, const A&) const { ... } };

int main()
{
    std::map<A, int, Comp> theMap(Comp());

    A a;
    theMap[a] = 5;
}

  All is well, right? No. gcc gives this error:

error: no match for 'operator[]' in 'theMap[a]'

  Inexperienced C++ programmers will be completely confused by this
error message.

  Experienced C++ programmers may see what is the problem: What looks
like a map instantiation called 'theMap' actually isn't. It actually is
a function declaration. This even though we are seemingly creating a
(nameless) instance of Comp which we give to this map as parameter. How
can a function be declared with a parameter which is an instance of a
struct instead of being a parameter type?

  It seems that we have a doubly-confusing declaration here. In fact, in
this case it doesn't seem to be an instantiation of Comp at all.
Instead, at least according to gcc, it declares a function pointer
type (!)

  So, in all its glory, the line:

    std::map<A, int, Comp> theMap(Comp());

declares a function named 'theMap' which returns an instance of
std::map<A, int, Comp> and which takes one parameter: A pointer to a
function taking no parameters and which returns an instance of Comp.

  Could this become any more confusing?

  A small change in that line completely changes its semantic meaning:

    std::map<A, int, Comp> theMap((Comp()));

  Now it does what it looks like it should do: It creates a map instance
called 'theMap' and gives its constructor an instance of Comp.

  Anyways, my actual question is the following:

  Is gcc behaving correctly here? Can you really declare a function
pointer type as "Comp()" instead of the more common "Comp (*)()"?