C++: Template Class Tutorial

Templates are super simple and are a great way to reuse code.

First, two classes that do not use templates and do the same thing. These will be converted to use one class template.

#include <iostream>
#include <string>
using namespace std;

class Proware
{
private:
	int data;
	/* make this constructor private so that the class can not
	be initialized without passing the constructor an argument */
	Proware() {}

public:
	Proware(const int &argument) : data(argument) {}
	/* this method will double the value stored in the class
	and return it */
	int Double()
	{
		return data + data;
	}
};

int main()
{
	Proware obj(123);
	cout << obj.Double() << endl;
	return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Proware
{
private:
	double data;
	Proware() {}

public:
	Proware(const double &argument) : data(argument) {}
	int Double()
	{
		return data + data;
	}
};

int main()
{
	Proware obj(123.123);
	cout << obj.Double() << endl;
	return 0;
}

Now, a small, over simplified example of how template classes work. To convert these classes, the class declaration is proceeded by template <class TGenericType> and then variables are declared as the generic type TGenericType.

#include <iostream>
#include <string>
using namespace std;

template <class TGenericType> class Proware
{
private:
	TGenericType data;
	Proware() {}

public:
	Proware(const TGenericType &argument) : data(argument) {}
	TGenericType Double()
	{
		return data + data;
	}
};

int main()
{
	Proware<int> obj(123);
	cout << obj.Double() << endl;
	return 0;
}

The method Double is defined inline. If defining a method (or member function) outside the class then it must be preceded with template <TGenericType>. The following syntax is also valid:

/* notice three TGenericTypes */
template <class TGenericType> TGenericType Proware<TGenericType>::Double()
{
	return data + data;
}

Here is this small example converted to a template class. It handles three datatypes with one class declaration.

#include <iostream>
#include <string>
using namespace std;

template <class TGenericType> class Proware
{
private:
	TGenericType data;
	Proware() {}

public:
	Proware(const TGenericType &argument);
	TGenericType Double();
};

template <class TGenericType> Proware<TGenericType>::Proware(const TGenericType &argument) : data(argument) {}

template <class TGenericType> TGenericType Proware<TGenericType>::Double()
{
	return data + data;
}

/* now the driver code; notice that the same class is
	 working with three datatypes (int, string and double) */
int main()
{
	// specify that the int datatype will be used
	Proware<int> obj_int(8);

	// specify that the string datatype will be used
	Proware<string> obj_string("Test");

	// specify that the float datatype will be used
	Proware<float> obj_float(8.8);

	/* double each of the values, notice how the string
			class is contatenating the values instead of adding */
	cout << obj_int.Double() << endl;
	cout << obj_string.Double() << endl;
	cout << obj_float.Double() << endl;
}

Template Specialization

Define a different implementation for a template (and not reuse code) with specialization. For example:

#include <iostream>
#include <string>
using namespace std;

template <class TGenericType> class Proware
{
private:
	TGenericType data;
	Proware() {}

public:
	Proware(const TGenericType &argument) : data(argument) {}
	TGenericType Double()
	{
		return data + data;
	}
};

template<> class Proware <string>
{
private:
	string data;
	Proware() {}

public:
	Proware(const string &argument) : data(argument) {}
	const string &Data() const
	{
		return data;
	}
	int Find(const string query) const
	{
		size_t found = data.find(query, 0);
		if (found == string::npos)
			return -1;
		return found;
	}
};

int main()
{
	Proware<string> obj_str("How now brown cow.");
	Proware<double> obj_dbl(1234.5678);
	Proware<int> obj_int(336699);

	cout << obj_str.Data() << endl;
	cout << "brown found at " << obj_str.Find("brown") << endl;
	cout << obj_dbl.Double() << endl;
	cout << obj_int.Double() << endl;
}

Templates can also have regular, as opposed to generic, typed parameters:

#include <iostream>
using namespace std;

template <class TGenericType, int number> class Proware
{
	TGenericType array[number];
public:
	void SetArrayItem(int index, TGenericType value);
	TGenericType GetArrayItem(int index);
};

template <class TGenericType, int index> void Proware<TGenericType, index>::SetArrayItem(int index, TGenericType value)
{
	array[index] = value;
}

template <class TGenericType, int index> TGenericType Proware<TGenericType, index>::GetArrayItem(int index)
{
	return array[index];
}

int main() {
	Proware<float, 10> floats;
	Proware<int, 10> ints;

	floats.SetArrayItem(2, 123.45);
	ints.SetArrayItem(5, 12345);

	cout << floats.GetArrayItem(2) << endl;
	cout << ints.GetArrayItem(5) << endl;

	return 0;
}

Template Functions

Functions can also have templates. This allows them to work with template classes but they stand on their own also.

template <typename TGenericType> TGenericType DoubleIt(TGenericType &data)
{
	return data + data;
}

Comment