Re: Template instantiation problem, take 2
Vladimir Marko wrote:
Kaba wrote:
Here is a short snippet of code that does not compile (tested with Vc8
and Comeau). This is because somehow Vector<0> gets instantiated, for
which the array size goes to 0. However, I don't quite get it why it
gets instantiated in the first place. So why does not this compile?
template <int N>
struct Vector
{
int data_[N];
};
template <int HEIGHT, int WIDTH>
struct Matrix
{
};
template <int HEIGHT, int WIDTH>
Vector<WIDTH> operator *(
const Vector<HEIGHT>&,
const Matrix<HEIGHT, WIDTH>&)
{
return Vector<WIDTH>();
}
template <int HEIGHT, int WIDTH>
Vector<WIDTH - 1> operator *(
const Vector<HEIGHT - 1>&,
const Matrix<HEIGHT, WIDTH>&)
{
return Vector<WIDTH - 1>();
}
int main()
{
Matrix<1, 1> transform;
Vector<1> translation;
translation = translation * transform;
return 0;
}
This is gonna be quite long as I'm going to explain the whole process
in detail. And I'm not going to look up the exact paragraphs in the
standard since they are many.
The line
translation = translation * transform;
triggers the lookup for operator* with function arguments
argument 1: Vector<1> l-value
argument 2: Matrix<1,1> l-value
The lookup finds both templated operator*s, and tries to find out
whether any of them is a match. That's where template argument
deduction comes to play. Each function parameter is compared to the
corresponding function argument to find the template arguments.
....
For the second operator* template, i.e.
template <int HEIGHT, int WIDTH>
Vector<WIDTH - 1> operator *(
const Vector<HEIGHT - 1>&,
const Matrix<HEIGHT, WIDTH>&);
from the first parameter-argument pair,
function parameter 1: const Vector<HEIGHT-1>&
function argument 1: Vector<1> l-value
the compiler deduces
template arguments: HEIGHT=unknown, WIDTH=unknown
(if HEIGHT is used directly it can be deduced, if it's just a part of
an integral expression, it can't; that's the catch!)
and from the second parameter-argument pair,
function parameter 2: const Matrix<HEIGHT,WIDTH>&
function argument 2: Matrix<1,1> l-value
it deduces
template arguments: HEIGHT=1, WIDTH=1
We again got two compatible results (which may be quite unexpected), so
the template arguments are deduced as HEIGHT=1, WIDTH=1. The "deduced
operator*" would be
Vector<0> operator*(const Vector<0>&,const Matrix<1,1>&);
and the compiler must find out whether it is a match or not. The
question is whether a conversion exists
Actually, the first template argument in the second function cannot be
deduced because the non-type parameter is involved in an expression. In
other words, Vector<HEIGHT> can be deduced but Vector<HEIGHT-1> (or any
expression involving HEIGHT) cannot be deduced:
"If, in the declaration of a function template with a non-type template
parameter, the non-type template parameter is used in an expression in
the function parameter list, the expression is a non-deduced context."
[?14.8.2.5/14]
The example provided:
template <int i> class A { / * ... */ };
template <int i> void g(A<i+1>);
template <int i> void f(A<i>, A<i+1>);
A<1> a1;
g(a1); // error: deduction fails for expression i+1
applies to this case as well.
Since the template argument cannot be deduced, the compiler
instantiates the second, overloaded operator*() as a candidate
function, which in turn requires instantiating Vector<0>. This
instantiation fails due to an illegal member declaration (a member
array of size zero).
Remark: The standard exactly specifies all cases where the substitution
failure results in deduction failure instead of an error (SFINAE). This
is not one of them! However, gcc behaves as if it was :(
The original program fails to compile on gcc 4.01 when I tested it, so
at least some builds of gcc are correct.
In any event, the failure in this case occurs before the substitution
can even be attempted. Moreover the failure occurs during instantiation
(that is after, an instantiation has begun) - which is always an error:
"The program is ill-formed if any instantiation fails." [?2.1/8]
Now once the program is corrected and Vector<0> is made instantiable -
then the attempted substitution of Vector<0> as the function parameter
does fail. And the substitution failure is not an error.
Greg
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]