Use of template in C++ when declaring classes and functions

Question

I am quite new to the topic of templates in C++. Why in the following toy example code do we have to precede the class's and each function's name with template <class T> (meaning why do we need it, at all)?

Is it possible to modify the code not to use template <class T> everywhere?

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>

using namespace std;

template <class T>
class Stack {   private:
    vector<T> elements;

  public:
    void push(T const &);
    void pop();
    T top();
    bool empty(); };

template <class T>
void Stack<T>::push(T const &elem) {
    elements.push_back(elem); }

template <class T>
void Stack<T>::pop() {
    if (elements.empty()) {
        throw out_of_range("Stack<>::pop(): empty stack");
    } else {
        elements.pop_back();
    }
}

template <class T>
T Stack<T>::top() {
    if (empty()) {
        throw out_of_range("Stack<>::top(): empty stack");
    }
    return elements.back();
}

template <class T>
bool Stack<T>::empty() {
    return elements.empty();
}


int main() {
    try {
        Stack<int> intStack;       // Stack of ints
        Stack<string> stringStack; // Stack of strings

        // Manipulate integer stack
        intStack.push(7);
        cout << intStack.top() << endl;

        // Manipulate string stack
        stringStack.push("hello");
        cout << stringStack.top() << std::endl;
        stringStack.pop();
        stringStack.pop();
    }
    catch (exception const &ex) {
        cerr << "Exception: " << ex.what() << endl;
        return -1;
    }
}

Answer 1

C++ is a statically typed language.

Since this is the case, say I wanted a function to check the minimum or maximum of two values.

I could create a function like the following:

int max(int a, int b) { return (a > b) ? a : b; }

But this only works for int types. If I want one for a double or uint64_t or FooBarClass, I would need to create additional functions:

double max(double a, double b) { return (a > b) ? a : b; }
uint64_t max(uint64_t a, uint64_t b) { return (a > b) ? a : b; }
FooBarClass max(FooBarClass a, FooBarClass b) { return (a > b) ? a : b; }

Why in the following toy example code do we have to precede the class's and each function's name with template ?

In C++, a template is a way to introduce a concept known as "generics". With generics, you no longer need to concern your self with creating a function for each type, the type will be deduced from the template function signature.

So instead, I could write the following:

template < typename T > // the typename or class keywords are synonymous when declaring a template
T max(T a, T b) { return (a > b) ? a : b; }

The inclusion of template < typename T > to the function signature indicates to the compiler that this function is a "generic" function and must be processed accordingly.

If, on the other hand, you just had the following:

T max(T a, T b) { return (a > b) ? a : b; }

The compiler will expect T to be an explicit type (like typedef int T;).

A template can be applied to a class or function, and both at the same time:

template < typename T >
class Wrapper {
    public:
        Wrapper(const T& val) : _val(val) {}
        // ... other code

        template < typename X >
        operator X()
        {
            return static_cast<X>(this->_val);
        }

        T operator+(const T& val)
        {
            return this->_val + val;
        }

        friend std::ostream& operator<<(std::ostream& os, const Wrapper& val)
        {
            os << val._val;
            return os;
        }

    private:
        T _val;
};

int main(int argc, char* argv[])
{
    Wrapper<int> x(42);
    // template deduction will call Wrapper::operator X() with X being a double
    double d = x;
    // template deduction will call Wrapper::operator X() with X being a long
    long l = x;
    // this actually calls T operator+(const T& val) with val = 10 and T = int
    int i = x + 10;

    std::cout << "x = " << x << std::endl  // 42
              << "d = " << d << std::endl  // 42
              << "l = " << l << std::endl  // 42
              << "i = " << i << std::endl; // 52
    return 0;
}

You can also explicitly define a template type, this is known as template specialization and is beyond the scope of this answer given your understanding of templates at the current.

Is it possible to modify the code not to use template everywhere?

Yes and no. Yes, you can remove the template < class T > signature definition, but, as mentioned, the signature of the class/function takes on a completely different meaning.

Hope that clears up a little bit. Templates, when used properly, are a very powerful tool in C++.

Answer 2

You have to include template <class T> in each member definition because that is part of the name of the member.

You can define the functions within the class-template body, for only one line with template <class T>

template <class T> 
class Stack {   
  private:
    vector<T> elements;

  public:
    void push(T const &) {
      elements.push_back(elem); }
    void pop() {
      if (elements.empty()) {
          throw out_of_range("Stack<>::pop(): empty stack");
      } else {
          elements.pop_back();
      } }
    T top() {
      if (empty()) {
          throw out_of_range("Stack<>::top(): empty stack");
      }
      return elements.back(); }
    bool empty() {
      return elements.empty(); } };