Code duplication is bad for your code. Think of it as a malignant tumor waiting to grow into a cancer. C++ offers Class Templates to avoid code duplication.

Like function templates, class templates provide class behavior for different types. For example, you can create a container class which can manage elements of a certain type.

First, let me show you how declare a class template and its implementation. Then I will show you how to create a class template.

Declaring a Class Template

Before the class declaration, a statement declares an identifier as a type parameter. For example:

template <typename T>
class MyClass{
//...
};

Inside the class template, you can use the parameter T as any type to declare members and methods. For example:

template <typename T>
class MyClass{
    private:
        std::vector<T> myElements;
    public:
        MyClass();  //constructor
        void push(T const& element);
        T getElement();
};

If you have to declare your own copy constructor and copy assignment, it would look like this:

template <typename T>
class MyClass{
//...
    MyClass (MyClass<T> const& u);  //copy constructor
    MyClass<T>& operator=(MyClass<T> const& u); //copy assignment
};

Implementation of Member functions

Member functions are specified as function templates. And you have to specify the full type qualification of the class template. For example:

template <typename T>
void MyClass::push(T const& element){
//...
}

Implementing a Class Template Stack

Let's create a class template that will mimic the functionality of a stack algorithm. This class will contain a vector container whose type depends on the template parameter.

template <typename T>
class Stack{

private:
    std::vector<T> elements;  //elements
public:
    Stack(){};
    ~Stack(){};
    void push(T const& uElement); //push element
    void pop();     //remove last element
    T top() const; //return last element

};

The class provides a vector container named elements along with three member functions.

The listing below shows the implementation of the function members.

template <typename T>
void Stack<T>::push(T const& uElement){
    elements.push_back(uElement);  //append the element
}

template <typename T>
void Stack<T>::pop(){
    //Normally you would do a check if the vector is not empty. Avoiding for simplicity
    elements.pop_back();  //remove last element
}

template <typename T>
T Stack<T>::top() const{
    //Normally you would do a check if the vector is not empty. Avoiding for simplicity
    return elements.back();     //return copy of last element
}

Using the Class Template Stack

To use a class template object, specify the template arguments explicitly. For example:

int main(int argc, const char * argv[]) {

    //create a stack of int type
    Stack<int> myIntStack;

    //append an integer to the container
    myIntStack.push(2);

    //create a stack of float type
    Stack<float> myFloatStack;

    //append a float to the container
    myFloatStack.push(4.2);

    return 0;
}

A class template allows you to create several versions of a class which can deal with different types. The Stack class above not only can deal with ints and floats but also with strings.

As you can see, Class Templates are simple to set up. Use them to avoid code duplication.

The Inclusion Model

If you are like any other developer, you will want to separate your template class into a declaration file (.h) and an implementation file (.cpp). However, doing so will normally result in a compiler error.

To fix this error you need to #include your implementation file at the end of your header file as shown below:

#ifndef Stack_hpp
#define Stack_hpp

#include <stdio.h>
#include <vector>
#include <stdexcept>
#include <iostream>

template<typename T>

class Stack{

    private:
    std::vector<T> elements; //elements of container

    public:
    Stack(); //constructor

    void push(T const& uElement); //push element

    T top()const;   //return top element
};

#include "Stack.cpp"  //#Included the implementation file
#endif

And in your implementation file (.cpp) you will need to use Header guards. I know, you normally use header guards in (.h) files, but this time you will also need to use them in your implementation file. See the snippet below:

#ifndef Stack_cpp  //Header guards 
#define Stack_cpp

#include "Stack.hpp"

template <typename T>
Stack<T>::Stack(){} //constructor

template <typename T>
void Stack<T>::push(T const& uElement){

    elements.push_back(uElement);  //push element into vector

}

template <typename T>
T Stack<T>::top() const{

    if (elements.empty()) {
        std::cout<<"Come on dude, I have nothing more to give";
        throw std::out_of_range("Stack<>::top():empty stack");
    }

    return elements.back(); //return copy of last element
}

#endif

Now you will be able to use your template in your main.c file:

#include "Stack.hpp"

int main(int argc, const char * argv[]) {

    //create Stack class of type int
    Stack<int> stackOfInts;

    //push value 2
    stackOfInts.push(2);

    //get last value
    int intValue=stackOfInts.top();

    std::cout<<intValue<<std::endl;

    return 0;
}

You can grab the Inclusion-Model code example from my github page.

I hope this tutorial helped. If you want, sign up and get monthly development tips.