Why are qualifiers of template arguments stripped when deducing the type?

Question

While building a little sample program with Microsoft VisualStudio 2008 I noticed an odd thing about the deduction of types passed to templates. Consider this example:

Answer 1

The answer is that although the variable v has type const int &, the expression v is an lvalue expression with type const int.

litb provides the text (5/6): "If an expression initially has the type “reference to T” (8.3.2, 8.5.3), the type is adjusted to “T” prior to any further analysis, the expression designates the object or function denoted by the reference, and the expression is an lvalue."

An "argument" is "an expression in the comma-separated list bounded by the parentheses in a function call expression" (1.3.1). So in 14.8.2.1:

• "the corresponding argument type of the call (call it A)" is const int.
• "If A is a cv-qualified type, the top-level cv-qualifiers of A's type are ignored for type deduction" (hence, int).
• "the deduction process attempts to find template argument values that will make the deduced A identical to A" (so T is int)

Answer 2

http://accu.org/index.php/journals/409 is a rather extensive article, but it explains the process. From the template parameters, a parameter type P is derived, and this is matched to an argument type A. The relevant part is where it describes how a target type A is derived from the function argument: for non-array types, references are simply stripped. Hence, if the type of the argument is int&, then the target type A is simply int.

This is the simple reason: because the standard tells us so. What is the rationale? As it happens, the article has a footnote pointing that out too. In your example, typeid(v)==typeid(const int). When used in non-lvalue contexts, reference types behave like non-reference types.