C++ for Scientists - Technische Universität Dresden

4.3. GENERIC CLASSES 95
+= operator to variables of type T. This operator is defined for int and double types. This
implies that the following main program will compile without the need for another definition of
the accumulate function:
int main()
{
const int n = 10;
float a[n] ;
int b[n] ;
for (int i= 0; i < n; ++i) {
a[i]= float(i) + 1.0f;
b[i]= i + 1;
}
float s= accumulate(a, a + n);
int r= accumulate(b, b + n);
return 0;
}
As well as in the previous example we do not need to indicate explicitly that T is double or int.
The compiler deduces this for us from the function. We can, however, fill in the correct value
of the type as follows:
int r = accumulate(b, b+n);
If you fill in the wrong type the compiler will give you a type error by saying that no matching
function exists.
4.3 Generic classes
In the previous section, we described the use of templates to create generic functions. Templates
can also be used to create generic classes, that define a certain behaviour that is independent
of the types they operate on. Good candidates are for example container classes like vectors,
matrices and lists. We can also extend the complex class with a parametric value type but we
spent already so much time with it that we will now look at something else.
Let us write a generic vector class. 4 First we just implement a class with the most fundamental
operators:
template
class vector
{
void check size(int that size) const { assert(my size == that size); }
void check index(int i) const { assert(i >= 0 && i < my size); }
public:
explicit vector(int size)
: my size(size), data( new T[my size] )
{}
vector()
: my size(0), data(0)
{}
4 In the sense of linear algebra not like STL vector.