You could fill a whole book on C++ Templates - indeed some people already have - as it's a complex subject. Let me simply provide an example and a highly simplified description of what templates are about. If you need more, please ask, but remember that it's a big topic and forum posts will barely scratch the surface.
If we want to write a function that returns the highest of two integers we could easily do so like this:
int maxInt(int x, int y)
{
return x < y ? y : x;
}
It's easy to understand such a function; x is compared with y and if x is lower than y we return y. Otherwise we return x.
If we want to write a function that returns the highest of two floating point values it's just as easy:
double maxDouble(double a, double b)
{
return a < b ? b : a;
}
I'm sure you get the idea. We could do the same for any type we like, whether we're using built in types or our own types (e.g. classes), as long as the type supports the < operator. All we have to do is write the appropriate function for the specific type and Bob's your uncle.
If you look at the above functions though, you'll see the similarity in the structure of the functions themselves. The algorithm, if you like, is the same regardless of the data type we're using. In each case we go through the same steps to find the maximum value, it's just the type that differs.
C++, well known as supporting Object Oriented programming, provides support for Generic programming. It does so through the use of templates. (Ada is another example of a language that supports generic programming).
Using templates we only have to write the function once. We simply code the steps that are needed - and remember, those steps are the same regardless of data type. At compile time our program will be compiled with a version of the function that is appropriate for the data type we use.
Here's an example of a program using a templaterized version of a function for finding the maximum of two values:
#include <iostream>
#include <string>
using namespace std;
template <typename T>
inline const T& myMax (const T& first, const T& second)
{
return first < second ? second : first;
}
int main()
{
int a=3, b=99;
cout << "a=3, b=99, myMax(3,99)=" << myMax(a,b) << '\n' << endl;
double m=99.9, n=3.3;
cout << "m=99.9, n=3.3, myMax(99.9,3.3)=" << myMax(m,n) << '\n' << endl;
string s1("hello"), s2("world");
cout << "s1=hello, s2=world, myMax(hello,world)=" << myMax(s1,s2) << '\n' << endl;
}
The type is represented by T in our function. We call this function for int, double and string values, and the compiler handles it for us. We only wrote a single function, but there will be 3 versions of this function in our compiled program, one for each data type used.
Some people claim that templates lead to code bloat but this doesn't make much sense when you consider that if you hand coded it you'd still end up with three (different) versions of the function.
Generic programming opens up a whole new world of possibilities and can be very useful. But I have to repeat, it's a complex area and there is much to consider. My example above really is very basic, but hopefully gives you some idea what using templates is about.
Online 
Offline 
I'm still clueless. I haven't had a need for them so it sorta wandered to the back of my mind. But it would still be great if someone could just fill me in a bit. 
Unsolved 
