Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions

  




 

 

7.4.2 Providing your own templates

In addition to the template classes provided by the C++ standard library you can define your own templates. The recommended way to use templates with g++ is to follow the inclusion compilation model, where template definitions are placed in header files. This is the method used by the C++ standard library supplied with GCC itself. The header files can then be included with '#include' in each source file where they are needed.

For example, the following template file creates a simple Buffer<T> class which represents a circular buffer holding objects of type T.

#ifndef BUFFER_H
#define BUFFER_H

template <class T> 
class Buffer
{
public:
  Buffer (unsigned int n);
  void insert (const T & x);
  T get (unsigned int k) const;
private:
  unsigned int i;
  unsigned int size;
  T *pT;
};

template <class T> 
Buffer<T>::Buffer (unsigned int n)
{
  i = 0;
  size = n;
  pT = new T[n];
};

template <class T> 
void 
Buffer<T>::insert (const T & x)
{
  i = (i + 1) % size;
  pT[i] = x;
};

template <class T> 
T 
Buffer<T>::get (unsigned int k) const
{
  return pT[(i + (size - k)) % size];
};

#endif /* BUFFER_H */

The file contains both the declaration of the class and the definitions of the member functions. This class is only given for demonstration purposes and should not be considered an example of good programming. Note the use of include guards, which test for the presence of the macro BUFFER_H, ensuring that the definitions in the header file are only parsed once if the file is included multiple times in the same context.

The program below uses the templated Buffer class to create a buffer of size 10, storing the floating point values 0.25 and 1.0 in the buffer:

#include <iostream>
#include "buffer.h"

using namespace std;

int
main ()
{
  Buffer<float> f(10);
  f.insert (0.25);
  f.insert (1.0 + f.get(0));
  cout << "stored value = " << f.get(0) << '\n';
  return 0;
}

The definitions for the template class and its functions are included in the source file for the program with '#include "buffer.h"' before they are used. The program can then be compiled using the following command line:

$ g++ -Wall tprog.cc
$ ./a.out 
stored value = 1.25

At the points where the template functions are used in the source file, g++ compiles the appropriate definition from the header file and places the compiled function in the corresponding object file.

If a template function is used several times in a program it will be stored in more than one object file. The GNU Linker ensures that only one copy is placed in the final executable. Other linkers may report "multiply defined symbol" errors when they encounter more than one copy of a template function--a method of working with these linkers is described below.


 
 
  Published under the terms of the GNU General Public License Design by Interspire