C++ for Scientists - Technische Universität Dresden

92 CHAPTER 4. GENERIC PROGRAMMING
can trace back the error. Please try to compile this example on different compilers at your
availability and see if you can make any sense out of the error messages.
If you run into such lengthy error message 1 DON’T PANIC! First, look at the error itself
and take out what is useful for you, e.g. missing “operator>” or something not assignable,
i.e. missing “operator=” or something const that should not. Then find in the call stack your
innermost code that is the part of your program where you call somebody else’s template
function. Stare for a while at this and its preceding lines because this is the most likely place
where the error is made. Does a type of the template function function’s argument is missing
an operator or function as mentioned in the error? Do not get scared away from this, often
the problem is much simpler than it seems from the never-ending error message. From our
experience, most errors in template functions one can find faster than run-time errors.
Another question we have not answered so far is what happens if we use two different types:
unsigned u1= 2;
int i= 3;
std::cout ≪ ”The maximum of u1 and i is ” ≪ max(u1, i) ≪ ’\n’;
The compiler tell us — this time briefly — something like
Error: no match for function call ≫max(unsigned int&, int)≪
Indeed, we assumed that both types are the same. Now can we write a template function with
two template parameters? Of course, we can. But that does not help us much here because we
would not know what return type the function had.
There are different options. First we could add a non-templated function like:
int inline max (int a, int b) { return a > b ? a : b; }
This can be called with mixed types and the unsigned argument would be implicitly converted
into an int. But what would happen if we also add a function for unsigned?
int max(unsigned a, unsigned b) { return a > b ? a : b; }
Shall the int be converted into an unsigned or vice versa? The compiler does not know and will
complain about this ambibuity.
At any rate, adding non-templated overloads to the templated implemention is far from being
elegant nor productive. So, we remove all non-templated overloads and look what we can do in
the function call. We can explicitly convert one argument to the type of the other:
unsigned u1= 2;
int i= 3;
std::cout ≪ ”The maximum of u1 and i is ” ≪ max(int(u1), i) ≪ ’\n’;
Now max is called with two ints. Another option is specifying the template type explicitly in
the function call:
unsigned u1= 2;
int i= 3;
std::cout ≪ ”The maximum of u1 and i is ” ≪ max(u1, i) ≪ ’\n’;
1 The longest we have heard off was 18MB what corresponds to about 9000 pages of text.