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?
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;