Just looking for some good reasons so i could start learning about them :/
To avoid repeating code that would be otherwise identical except for different types. Sometimes you simply can't rely on implicit conversion or promotion and you can't stuff everything into an object hierarchy.
Do you even know what templates are, to begin with? In the hierarchy of programming language concepts, templates are on a way higher plane than functions. A class(/struct) or function is fine, but bound to certain types. When you write a class vector, it only work for one type (and its subclasses, if a class at all), because you're forced to name the type of the items directly. But using a template, you don't have to care of what type the items are - it is irrelevant to the vector implementation, but you have to use templates to achive this genericy.
That being said, C++ templates suck hard. At least they're there, I appreciate that they are there, and back in the 80s it was all new and modern, but today generic code is possible without all the pain of e.g. template error messages. Nonetheless, they are important and incredibly powerful.
Additionally, C++ templates are turing complete and a sufficently smart programmer with a lot of free time can do mind-blowing things with it. Consider: Boost (one of the greates C++ libraries, many would say) is mostly templates. Not functions. Template functions and classes. Templates.
Templates are an important part of C++, as already mentioned, they allow you to develop functions or Classes that are type generic. You specify the type when you use them. You really should learn templates if, for no other reason, to understand boost and the standard template libraries.
These libraries give you a whole suite of containers and algorithms that will work for any built-in or user defined type.
For example, the vector class:
vector<int> v(3); // Declare a vector of 3 elements.
v[0] = 7;
v[1] = v[0] + 3;
v[2] = v[0] + v[1]; // v[0] == 7, v[1] == 10, v[2] == 17
The client of this class specifies this as a vector of int's, but it could have easily been a vector of strings or any other type.
1) Templates are a simple way to save yourself on copy/paste code & then edit it.
template<class T>
T Max(const T& a, const T& b){ return (a>b)?a:b: }
Will work with int,double,string, and anything else which supports the > symbol.
Yes, you could do it with a macro, but a lot of more complex template examples cannot reasonably be done so.
2) Container classes (vector, list, map) are all templated.
My advice, you MUST learn to use templates. Its useful to know how to write them, as they can be useful to use. (You can do a lot of really freaky things with templates, but you don't need that stuff).
In order to master templates, it helps to have some exposure to generic and functional programming. Depending on the task at hand, generic programming can greatly simplify the design of key functionality. Languages like Haskell and F# (among many others) will help you think about problems in ways that fit better with template mechanics.
Once you're comfortable with the semantics of functions as objects, type parameters, "recursive iteration" so to speak, up values, and the like, C++ templates become only a matter of overcoming pitfalls of the language.
You can do some pretty great magic with templates, but it's definitely a good idea to start playing with them in your spare time. Templates can help simplify the conceptual complexity of the problem, but the mechanics of C++ can also make them a bit unwieldy (C++0x will solve some of the big annoyances). It's certainly a good idea to make sure anyone you work with is comfortable with them. You may have to prove yourself worthy to use them in a professional setting. ;)