Templates don't generate code until they are instantiated. It is a
feature, and a very nice one, for that matter. It helps generic
programming, because you can define functions that may not apply to all
specializations. For example:

template <class Container>
bool IsMember(const Container& items, const Container::referece_type value)
{
   return items.find(value) != items.end();
}

This function is always there, but it can only be called if the
container has a .find() member function, or else it will fail at compile
time. On the other hand, as long as the function is not called, it won't
issue any errors.

Note that the compiler doesn't know anything about Container until it
actually sees a specific instantiation. There's nothing in the above
template code that advises that Container has a .find method that takes
a single input, and an .end() method that takes no args, nor is it clear
that the two are comparable via operator!=. Only when you actually
create an instance of a template class or call a template function will
the compiler do a full syntax check and validation.

Tom

It isn't a bug, though it is a slight annoyance. The C++ standard leaves
it up to the implementation as to when syntax errors in templates are
diagnosed. Many compilers don't perform any syntax checking at all until
a template is instantiated. Others perform every bit of syntax checking
that is possible prior to template instantiation (e.g. non-dependent
names are looked up, etc.) and then do the remaining at instantiation
time. VC++ belongs to the former group, Comeau C++ and other EDG based
compilers (such as Intel C++) to the latter group, and I think that GCC
lies somewhere in the middle - certainly it diagnoses the error in this
program, unlike VC7.1:

template <class T>
void f()
{
    g();
}

int main()
{
}

That code is ill-formed, since there is no g() visible, but it is up to
the compiler whether it diagnoses the error or not.

Tom