Why does C++ allow but ignore the application of const to function types?

Question

I get a real kick out of exploring the unusual corners of C++. Having learned about the real types of functions rather than function pointers from this question, I tried messing around with function typing and came up with this bizarre case:

typedef int Func(int);

int Foo(int x) { return 1; }

int main()
{
    const Func*& f = &Foo;

    return 0;
}

Since &Foo is an rvalue of type Func*, I figured that I should be able to put it in a const reference, but I get this error from g++ 4.6:

funcTypes.cpp: In function ‘int main()’:
funcTypes.cpp:7:23: error: invalid initialization of non-const reference of type ‘int (*&)(int)’ from an rvalue of type ‘int (*)(int)’

But f is const! It has become apparent to me that the application of const to a function (or reference/reference to pointer etc.) is simply ignored; this code compiles just fine:

template <typename A, typename B>
struct SameType;

template <typename A>
struct SameType<A, A> { };

typedef int Func(int);

int main()
{
    SameType<const Func, Func>();

    return 0;
}

I'm guessing this is how boost pulls off their is_function type trait, but my question is - why does C++ allow this by ignoring it instead of forbidding it?

EDIT: I realise now that in the first example f is non-const and that const FuncPtr& f = &Foo does work. However, that was just background, the real question is the one above.

Answer 1

But f is const!

No, it's not. You're confusing

const Func*& f = &Foo;

with

Func* const& f = &Foo;

The former is a non-const ref to a const pointer. The latter is a const ref to a non-const pointer.

That's why I always write the const-ness before the */& rather than before the type. I would always write the first case as

Func const*& f = &Foo;

and then read right to left: reference to a pointer to a const Func.