[ 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

Механизм шаблонов можно использовать и в наследуемых классах. Вот как выглядит

#include <cassert>

определение шаблона класса ArrayRC:

#include Array.h

template <class elemType> class ArrayRC : public AArray<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 < AArray<elemType>:: size ); return ia[ ix ];

private:

...

Подстановка реальных параметров вместо типа-параметра elemType происходит как в базовом, так и в производном классах. Определение

ArrayRC<int> ia rc(10); ведет себя точно так же, как определение IntArrayRC из пред1дущего раздела. Изменим

функцию swap() тоже следует сделать шаблоном

пример использования из предыдущего раздела. Прежде всего, чтобы оператор

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

был допустимым, нам потребуется представить функцию swap() в виде шаблона.

AArray<char> ca(array size); int size; char * ia;

Что происходит с функциями-членами? В них тоже тип-параметр elemType заменяется на реальный тип, однако компилятор не конкретизирует те функции, которые не вызываются в каком-либо месте программы. (Подробнее об этом в разделе 16.8.)

При выполнении программа этого примера выдаст следующий результат:

#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;

При каждом вызове swap() генерируется подходящая конкретизация, которая зависит от

#include <iostream>

типа массива. Вот как выглядит программа, использующая шаблоны Array и ArrayRC: #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;

Упражнение 2.13

template<class elemType> class Array;

Пусть мы имеем следующие объявления типов:

enum Status { ... }; typedef string *Pstring;

Есть ли ошибки в приведенных ниже описаниях объектов?

class example1 {

public:

example1 (double min, double max); example1 (const double *array, int size);

doubles operator[] (int index); bool operator== (const example1&) const;

bool insert (const double*, int); bool insert (double);

double min (double) const { return min; };

double max (double) const { return max; };

void min (double); void max (double);

int count (double value) const;

private: int size; double *parray; double min; double max;

Перепишите следующее определение, сделав из него шаблон класса:

Упражнение 2.15

template <class elemType> class Example2 {

Имеется следующий шаблон класса:

public:

explicit Example2 (elemType val=0) : val(val) {};

bool min(elemType value) { return val < value; } void value(elemType new val) { val = new val; } void print (ostream &os) { os << val; }

private:

elemType val;

template <class elemType>

(a) Array< int*& > pri(1024);

(b) Array< Array<int> > aai(1024);

(c) Array< complex< double > > acd(1024);

(d) Array< Status > as(1024);

(e) Array< Pstring > aps(1024); Упражнение 2.14