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 (*)()"?