The use of templates in C++

Our IntArray class provides a good alternative to the built-in array of integers. But life can take arrays for various data types. We can assume, the only difference between array elements of double type from our type of the data is in the ads, the rest of the code matches literally.
To resolve this problem in c++ mechanism templates. Class and function declarations are allowed to use parameterized types. Type parameters are replaced at compile time these types, built-in or user-defined. We can create a template Array class, replacing in the class IntArray elements of type int on a generic type parameter. Later we determine the types-options, substituting them real types int, double and string. The result will be a way to use this specification so, as if we actually defined three different classes for these three data types.
Now can be rewritten as a template class Array:

template <class elemType>
class Array {
public:
   explicit Array( int sz = DefaultArraySize );
   Array( const elemType *ar, int sz );
   Array( const Array &iA );
   virtual ~Array() { delete[] _ia; }
   Array& operator=( const Array & );
   int size() const { return _size; }
   virtual elemType& operator[]( int ix )
      { return _ia[ix]; }
   virtual void sort( int,int );
   virtual int find( const elemType& );
   virtual elemType min();
   virtual elemType max();
protected:
   void init( const elemType*, int );
   void swap( int, int );
   static const int DefaultArraySize = 12;
   int _size;
   elemType *_ia;
};

template <class elemType>

class Array {

public:

explicit Array( int sz = DefaultArraySize );

Array( const elemType *ar, int sz );

Array( const Array &iA );

virtual ~Array() { delete[] _ia; }

Array& operator=( const Array & );

int size() const { return _size; }

virtual elemType& operator[]( int ix )

{ return _ia[ix]; }

virtual void sort( int,int );

virtual int find( const elemType& );

virtual elemType min();

virtual elemType max();

protected:

void init( const elemType*, int );

void swap( int, int );

static const int DefaultArraySize = 12;

int _size;

elemType *_ia;

};

The keyword template tells, that sets the template, parameters are enclosed in angle brackets (<>). In our case there is only one parameter elemType; the class keyword in front of its name tells, what this option represents a type of.
In specifying template classes Array parameter elemType is replaced by the actual type for each use, as shown in the example:

#include <iostream>
#include "Array.h"
int main()
{
   const int array_size = 4;
   // elemType заменяется на int
   Array<int> ia(array_size);
   // elemType заменяется на double
   Array<double> da(array_size);
   // elemType заменяется на char
   Array<char> ca(array_size);
   int ix;
   for ( ix = 0; ix < array_size; ++ix ) {
      ia[ix] = ix;
      da[ix] = ix * 1.75;
      ca[ix] = ix + 'a';
   }
   for ( ix = 0; ix < array_size; ++ix )
      cout << "[ " << ix << " ] ia: " << 
          ia[ix]
          << "\tca: " << ca[ix]
          << "\tda: " << da[ix] << endl;
   return 0;
}

#include <iostream>

#include "Array.h"

int main()

{

const int array_size = 4;

// elemType заменяется на int

Array<int> ia(array_size);

// elemType заменяется на double

Array<double> da(array_size);

// elemType заменяется на char

Array<char> ca(array_size);

int ix;

for ( ix = 0; ix < array_size; ++ix ) {

ia[ix] = ix;

da[ix] = ix * 1.75;

ca[ix] = ix + 'a';

}

for ( ix = 0; ix < array_size; ++ix )

cout << "[ " << ix << " ] ia: " <<

ia[ix]

<< "\tca: " << ca[ix]

<< "\tda: " << da[ix] << endl;

return 0;

}

It defines three instance of the class Array:

Array<int> ia(array_size);
Array<double> da(array_size);
Array<char> ca(array_size);

Array<int> ia(array_size);

Array<double> da(array_size);

Array<char> ca(array_size);

What does the compiler, if you saw this ad? Displays the text of the template Array, replacing the parameter elemType the type, specified in each case. Therefore, ads members are becoming in the first case, this kind:

// Array<int> ia(array_size);
int _size;
int *_ia;

// Array<int> ia(array_size);

int _size;

int *_ia;

Note, what is it exactly corresponds to the definition of the array IntArray.
For the remaining two cases, we get the following code:

// Array<double> da(array_size);
int _size;
double *_ia;
// Array<char> ca(array_size);
int _size;
char *_ia;

// Array<double> da(array_size);

int _size;

double *_ia;

// Array<char> ca(array_size);

int _size;

char *_ia;

What happens to the member functions? This type is the parameter elemType is replaced by the actual type, however, the compiler does not specify the functions, which are not invoked in any place of the program.
When you run a program this example will give following result:

[ 0 ] ia: 0 ca: a da: 0
[ 1 ] ia: 1 ca: b da: 1.75
[ 2 ] ia: 2 ca: c da: 3.5
[ 3 ] ia: 3 ca: d da: 5.25

[ 0 ] ia: 0 ca: a da: 0

[ 1 ] ia: 1 ca: b da: 1.75

[ 2 ] ia: 2 ca: c da: 3.5

[ 3 ] ia: 3 ca: d da: 5.25

The template engine can be used in inherited classes. Here is the definition of a template class ArrayRC:

#include <cassert>
#include "Array.h"
template <class elemType>
class ArrayRC : public Array<elemType> {
public:
   ArrayRC( int sz = DefaultArraySize )
      : Array<elemType>( sz ) {}
   ArrayRC( const ArrayRC& r )
      : Array<elemType>( r ) {}
   ArrayRC( const elemType *ar, int sz )
      : Array<elemType>( ar, sz ) {}
   elemType& ArrayRC<elemType>::operator[]( int ix )
   {
      assert( ix >= 0 && ix < Array<elemType>::_size );
      return _ia[ ix ];
   }
private:
   // ...
};

#include <cassert>

#include "Array.h"

template <class elemType>

class ArrayRC : public Array<elemType> {

public:

ArrayRC( int sz = DefaultArraySize )

: Array<elemType>( sz ) {}

ArrayRC( const ArrayRC& r )

: Array<elemType>( r ) {}

ArrayRC( const elemType *ar, int sz )

: Array<elemType>( ar, sz ) {}

elemType& ArrayRC<elemType>::operator[]( int ix )

{

assert( ix >= 0 && ix < Array<elemType>::_size );

return _ia[ ix ];

}

private:

// ...

};

The substitution of actual parameters instead type-parameter elemType happens both in the base, and in derived classes.

ArrayRC<int> ia_rc(10);

1	ArrayRC<int> ia_rc(10);

Definition behaves exactly the same, as the definition IntArrayRC from the previous section. Change the example usage from the previous section.

swap( ia1, 1, ia1.size() );

1	swap( ia1, 1, ia1.size() );

First of all, to operator // function swap() also you should make the template valid, we will need to introduce a function swap() template.

#include "Array.h"
template <class elemType>
inline void
swap( Array<elemType> &array, int i, int j )
{
   elemType tmp = array[ i ];
   array[ i ] = array[ j ];
   array[ j ] = tmp;
}

#include "Array.h"

template <class elemType>

inline void

swap( Array<elemType> &array, int i, int j )

{

elemType tmp = array[ i ];

array[ i ] = array[ j ];

array[ j ] = tmp;

}

Each call to swap() generated appropriate specification, which depends on type of array. Here is the program, using templates Array and ArrayRC:

#include <iostream>
#include "Array.h"
#include "ArrayRC.h"
template <class elemType>
inline void
swap( Array<elemType> &array, int i, int j )
{
   elemType tmp = array[ i ];
   array[ i ] = array[ j ];
   array[ j ] = tmp;
}
int main()
{
   Array<int> ia1;
   ArrayRC<int> ia2;
   cout << "swap() with Array<int> ia1" << endl;
   int size = ia1.size();
   swap( ia1, 1, size );
   cout << "swap() with ArrayRC<int> ia2" << endl;
   size = ia2.size();
   swap( ia2, 1, size );
   return 0;
}

#include <iostream>

#include "Array.h"

#include "ArrayRC.h"

template <class elemType>

inline void

swap( Array<elemType> &array, int i, int j )

{

elemType tmp = array[ i ];

array[ i ] = array[ j ];

array[ j ] = tmp;

}

int main()

{

Array<int> ia1;

ArrayRC<int> ia2;

cout << "swap() with Array<int> ia1" << endl;

int size = ia1.size();

swap( ia1, 1, size );

cout << "swap() with ArrayRC<int> ia2" << endl;

size = ia2.size();

swap( ia2, 1, size );

return 0;

}

Похожие записи: