Reference collapsing?

Question

By trying to solve this problem, something made me wonder. Consider the following code:

template <typename T>
struct foo 
{
    foo(T const& x) : data(x) {}
    T data;
};

It seems that I can construct an object of type foo<T const&> without error, the hypothetical T const& const& being understood as T const&.

It seems also that this is called reference collapsing, but I never heard this term before (see comments in the linked question).

Is this widespread? Is this standard?

Answer 1

In C++03, it was not legal to do the following

typedef int &ref;
ref &r = ...; // reference to reference!

This frequently causes problems for people compiling with really strict or older C++03 compilers (GCC4.1 as well as Comeau 8/4/03 do not like the above) because the Standard function object binders do not take care of the "reference to reference" situation, and occasionally create such illegal types.

In C++0x this is called "reference collapsing", yes. Most current C++03 compilers do that (i.e a T& where T denotes a reference type is T again), by retroactively applying the rule. The boost.call_traits library makes it easy to declare such function parameters though, so that the "reference to reference" situation does not occur.

Please note that the const there does not have any effect. A const applied on a reference type is silently ignored. So even if the compiler supports reference collapsing, the following is not legal

int const x = 0;

// illegal: trying to bind "int&" to "int const"!
ref const& r = x; 

Answer 2

According to this, in C++98 there was only limited support for reference collapsing:

In C++98, there is only one reference collapsing rule: T& & or a reference to a reference, collapses to T&:

void g(int & ri) {++ri;} // int& & -> int& 
void f(int & ri) {g(ri);}

Even there, it's illegal to try to declare a variable that is a reference to a reference:

int ben;
int& bill(ben);     // OK
int & & bob(bill);  // error C2529: 'bob' : reference to reference is illegal