C++ for Scientists - Technische Universität Dresden

4.2. GENERIC FUNCTIONS 91
would not compile because the if statement without the parentheses is not a legal expression of
the C ++ grammar. Meanwhile the following stupid implementation:
template
T inline max (T a, T b)
{
if (a > b)
return max(a, b); // Infinite loop !
else
return max(b, a); // Infinite loop !
}
compiles because it does not violate any grammar rule. It obviously results in an infinite loop
but this is beyond the compiler’s responsibility.
So far, the compiler only checked the grammatical correctness of the definition but did not
generate code. If we do not call the template function, the binary will have no trace of our max
function. What happens when we call the generic function and cause their instantiation. The
compiler first checks if the function can be compiled with the given argument type. It can do
it for int or double as we have seen before. What about types that have no ‘>’? For instance
std::complex. Let us try to compile:
std::complex z(3, 2), c(4, 8);
std::cout ≪ ”The maximum of c and z is ” ≪ ::max(c, z) ≪ ’\n’;
The double colons in front of max shall avoid ambiguities with the standard libraries max that
some compilers may include implicitly (as g++ apparently). Our compilation attempt will end
in error like:
Error: no match for ≫operator>≪ in ≫a > b≪
Obviously, we cannot call the max function with types that have no “greater than” operator.
In fact, there is no maximum function for complex numbers.
What happens when our template function calls another template function which in turn . . . ?
Likewise, these functions are only completely checked at instantiation time. Let us look at the
following program:
#include
#include
#include
#include
int main ()
{
using namespace std;
vector v;
sort(v.begin(), v.end());
}
return 0 ;
Without going into detail, the problem is the same as before: we cannot compare complex
numbers and thus not sort arrays of it. This time the missing comparison is discovered in
an indirectly called function and the compiler provides you the entire call stack so that you