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.

Answer 2

In c++03 it was not ignored, but illformed (and was an sfinae case). I guess they changed that in c++11 because then you can simply have function parameters be const F& and can pass to it rvalue function objects aswell as normal functions.

See this DR which made the change http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#295

Answer 3

&Foo is a pointer. In general, I would suggest avoiding references to pointers (const or no). At least, not unless you know what you're doing.

So you should have:

const Func *f = &Foo;

Or really, you can ditch the const entirely:

Func *f = &Foo;

why does C++ allow this by ignoring it instead of forbidding it?

Because you're talking about two different things.

In C++, there is a difference between a function type and a function pointer. Foo is a function type, specifically int(int). &Foo is a function pointer, of type int(*)(int). A function type degrades into a function pointer, where necessary (much like array types degrade into pointers). But they are distinct (just like arrays).

So your two cases are not the same. Your first case is dealing with a function pointer, and your second case is dealing with a function type (which is what the template argument is deduced as).

As for why function types swallow the const, that's because the values of function types are already implicitly constant. You can't change them. The only operation you can perform on a function type is () (or conversion to function pointer). So a const T is equivalent to T if T is a function type. Visual Studio 2010 actually gives a warning about that.

Answer 4

The following compiles fine:

typedef int Func(int);
int Foo(int x) { return 1; }

int main()
{
  Func* const& f = &Foo;  //ok
  return 0;
}

Be aware that const statements are evaluated along with pointers and references from right to left. The last const to the very left you wrote translates to last possible position right of a Name (C++ FAQ on const placement). Hence

const Func*& f 

Is translated by the compiler to

Func const*& f 

Hence you get a reference to a constant pointer which is not what you want. Besides I would not use references to function pointer if you do not really have to.

Answer 5

No, f is not const. First of all, it is a reference to some mutable type (that mutable type happens to be a const pointer, i.e. a mutable pointer to something that you promise not to change through that particular pointer). However, with &Foo you are creating a temporary (of type Func*) and you cannot assign a temporary to a mutable reference. You can only assign it to a const reference. And that is precisely what the error message is telling you.

Answer 6

Sometimes the error messages can be a bit cryptic.

I put together an example on ideone to illustrate the types printed by gcc for a variety of things:

#include <iostream>

typedef int(Func)(int);
typedef Func* FuncPtr;
typedef FuncPtr& FuncPtrRef;
typedef FuncPtr const& FuncPtrConstRef;

template <typename T> void DisplayType() { T::foo(); }

int main() {
  DisplayType<Func>();
  DisplayType<FuncPtr>();
  DisplayType<FuncPtrRef>();
  DisplayType<FuncPtrConstRef>();

}

The compilation errors give:

• Func is of type int ()(int) (not a valid type, should now be fixed in gcc)
• FuncPtr is of type int (*)(int)
• FuncPtrRef is of type int (*&)(int)
• FuncPtrConstRef is of type int (* const&)(int)

In your error message you have int (*&)(int), which is a reference to a non-const pointer to a function type.

You are not allowed to bind an rvalue to a non-const reference.

Note: this has thus nothing to do with const being swallowed, as smparkes correctly diagnosed