C++Talk.NET

Bart Samwel · Guest

NOTE: This posting is the result of a discussion on comp.lang.c++,
subject "Template argument deduction on integer literals".

Please consider this snippet:

template<typename A>
void foo(A&)
{
}

int main()
{
foo(10);
}

What happens here is that the type deduced for A is "int", after which
compilation fails because one cannot bind an rvalue to a reference that
is not to "const". This happens with all compilers that I've tried
(Comeau, g++ 3.3, MSVC++ 7.1). However, IMHO the compiler *should* be
able to see that the value passed is an rvalue, and it *should* know
that if it selects "int" here, that compilation will subsequently fail.

Quoting the standard [temp.deduct.call], the compiler can apply the
following alternative deduction:

"If the original P is a reference type, the deduced A (i.e., the type
referred to by the reference) can be more cv-qualified than A."

In the snippet above, as I read the standard, P = "int&", so the
deduced "A" is allowed to be "int" but also "const int". However, the
standard also says here that:

"These alternatives are considered only if type deduction would
otherwise fail."

So, apparently type deduction doesn't fail in the situation in the
snippet above. But the subsequent call *always* fails, and this should
be perfectly clear to the compiler! So, my question is, might it be a
good idea to change the standard to include the rvalue-ness of the
passed value in the equation, and to always deduce a top-level "const"
qualifier whenever the value whose type is "A" is an rvalue and "P" is
a reference type?

--Bart

P.S.: For those of you who want to know why I would want this to work
this way, please read the discussion in comp.lang.c++. I explain the
situation I'm dealing with in some length there.

The abstract: I'm trying to build a "generic pass-through" function
which passes on its arguments to another, unknown function (in this
case, a constructor for a type which is also a template parameter), and
which passes the arguments through completely unchanged, so that the
same function overload is selected as when the function would have been
called directly, preserving both reference-ness and constness for all
arguments. We provide overloads for 0 to 20 arguments for the
pass-through function, so providing overloads for all combinations of
const/non-const argument types is not an option; this would yield 2**20
overloads for the 20-argument version alone!

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]

Howard Hinnant · Guest

In article <1114339382.885440.25740 (AT) z14g2000cwz (DOT) googlegroups.com>,
"Bart Samwel" <bsamwel (AT) gmail (DOT) com> wrote: