Использование шаблонов

Наш класс IntArray служит хорошей альтернативой встроенному массиву целых чисел. Но в жизни могут потребоваться массивы для самых разных типов данных. Можно предположить, что единственным отличием массива элементов типа double от нашего является тип данных в объявлениях, весь остальной код совпадает буквально.

Для решения данной проблемы в С++ введен механизм шаблонов. В объявлениях классов и функций допускается использование параметризованных типов. Типы-параметры заменяются в процессе компиляции настоящими типами, встроенными или определенными пользователем. Мы можем создать шаблон класса Array, заменив в классе IntArray тип элементов int на обобщенный тип-параметр. Позже мы конкретизируем типы-параметры, подставляя вместо них реальные типы int, double и string. В результате появится способ использовать эти конкретизации так, как будто мы на самом деле определили три разных класса для этих трех типов данных.

Вот как может выглядеть шаблон класса 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 говорит о том, что задается шаблон, параметры которого заключаются в угловые скобки (<>). В нашем случае имеется лишь один параметр elemType; ключевое слово class перед его именем сообщает, что этот параметр представляет собой тип.

При конкретизации класса-шаблона Array параметр elemType заменяется на реальный тип при каждом использовании, как показано в примере:

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

}

¦фхё№ юяЁхфхыхэv ЄЁш ¤ъчхьяы Ёр ъырёёр Array:

Array<int> ia(array_size);

Array<double> da(array_size);

Array<char> ca(array_size);

+Єю фхырхЄ ъюьяшы ЄюЁ, тёЄЁхЄшт Єръюх юс· тыхэшх? ¦юфёЄрты хЄ ЄхъёЄ °рсыюэр Array, чрьхэ ярЁрьхЄЁ elemType эр ЄюЄ Єшя, ъюЄюЁvщ єърчрэ т ърцфюь ъюэъЁхЄэюь ёыєўрх. TыхфютрЄхы№эю, юс· тыхэш ўыхэют яЁшюсЁхЄр¦Є т яхЁтюь ёыєўрх Єръющ тшф:

// Array<int> ia(array_size);

int _size;

int *_ia;

¦рьхЄшь, ўЄю ¤Єю т ЄюўэюёЄш ёююЄтхЄёЄтєхЄ юяЁхфхыхэш¦ ьрёёштр IntArray.

-ы юёЄрт°шїё фтєї ёыєўрхт ьv яюыєўшь ёыхфє¦•шщ ъюф:

// Array<double> da(array_size);

intаааа _size;

double *_ia;

// Array<char> ca(array_size);

intаа _size;

char *_ia;

+Єю яЁюшёїюфшЄ ё ЇєэъЎш ьш-ўыхэрьш? T эшї Єюцх Єшя-ярЁрьхЄЁ elemType чрьхэ хЄё эр Ёхры№эvщ Єшя, юфэръю ъюьяшы ЄюЁ эх ъюэъЁхЄшчшЁєхЄ Єх ЇєэъЎшш, ъюЄюЁvх эх тvчvтр¦Єё т ъръюь-ышсю ьхёЄх яЁюуЁрььv. (¦юфЁюсэхх юс ¤Єюь т Ёрчфхых 16.8.)

¦Ёш тvяюыэхэшш яЁюуЁрььр ¤Єюую яЁшьхЁр тvфрёЄ ёыхфє¦•шщ Ёхчєы№ЄрЄ:

[ 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

¦хїрэшчь °рсыюэют ьюцэю шёяюы№чютрЄ№ ш т эрёыхфєхьvї ъырёёрї. TюЄ ъръ тvуы фшЄ юяЁхфхыхэшх °рсыюэр ъырёёр 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:

// ...

};

¦юфёЄрэютър Ёхры№эvї ярЁрьхЄЁют тьхёЄю Єшяр-ярЁрьхЄЁр elemType яЁюшёїюфшЄ ъръ т срчютюь, Єръ ш т яЁюшчтюфэюь ъырёёрї. +яЁхфхыхэшх

ArrayRC<int> ia_rc(10);

тхфхЄ ёхс Єюўэю Єръ цх, ъръ юяЁхфхыхэшх IntArrayRC шч яЁхфvфє•хую Ёрчфхыр. Lчьхэшь яЁшьхЁ шёяюы№чютрэш шч яЁхфvфє•хую Ёрчфхыр. ¦Ёхцфх тёхую, ўЄюсv юяхЁрЄюЁ

// ЇєэъЎш¦ swap() Єюцх ёыхфєхЄ ёфхырЄ№ °рсыюэюь

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

сvы фюяєёЄшьvь, эрь яюЄЁхсєхЄё яЁхфёЄртшЄ№ ЇєэъЎш¦ swap() т тшфх °рсыюэр.

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

}

¦Ёш ърцфюь тvчютх swap() ухэхЁшЁєхЄё яюфїюф •р ъюэъЁхЄшчрЎш , ъюЄюЁр чртшёшЄ юЄ Єшяр ьрёёштр. TюЄ ъръ тvуы фшЄ яЁюуЁрььр, шёяюы№чє¦•р °рсыюэv Array ш 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;

}

LяЁрцэхэшх 2.13

¦єёЄ№ ьv шьххь ёыхфє¦•шх юс· тыхэш Єшяют:

template<class elemType> class Array;

enum Status { ... };

typedef string *Pstring;

+ёЄ№ ыш ю°шсъш т яЁштхфхээvї эшцх юяшёрэш ї юс·хъЄют?

(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);

LяЁрцэхэшх 2.14

¦хЁхяш°шЄх ёыхфє¦•хх юяЁхфхыхэшх, ёфхырт шч эхую °рсыюэ ъырёёр:

class example1 {

public:

а example1 (double min, double max);

а example1 (const double *array, int size);

а double& 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;

}

LяЁрцэхэшх 2.15

LьххЄё ёыхфє¦•шщ °рсыюэ ъырёёр:

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>

ostream& operator<<(ostream &os,const Example2<elemType> &ex)

а { ex.print(os); return os; }

¦ръшх фхщёЄтш тvчvтр¦Є ёыхфє¦•шх шэёЄЁєъЎшш?

(a) Example2<Array<int>*> ex1;

(b) ex1.min (&ex1);

(c) Example2<int> sa(1024),sb;

(d) sa = sb;

(e) Example2<string> exs("Walden");

(f) cout << "exs: " << exs << endl;

LяЁрцэхэшх 2.16

¦ЁшьхЁ шч яЁхфvфє•хую єяЁрцэхэш эръырфvтрхЄ юяЁхфхыхээvх юуЁрэшўхэш эр Єшяv фрээvї, ъюЄюЁvх ьюуєЄ сvЄ№ яюфёЄртыхэv тьхёЄю elemType. Tръ,а ярЁрьхЄЁ ъюэёЄЁєъЄюЁр шьххЄ яю єьюыўрэш¦ чэрўхэшх 0:

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

+фэръю эх тёх Єшяv ьюуєЄ сvЄ№ шэшЎшрышчшЁютрэv эєыхь (эряЁшьхЁ, Єшя string), яю¤Єюьє юяЁхфхыхэшх юс·хъЄр

Example2<string> exs("Walden");

ты хЄё яЁртшы№эvь, р

Example2<string> exs2;

яЁштхфхЄ ъ ёшэЄръёшўхёъющ ю°шсъх[4]. Tръцх ю°шсюўэvь сєфхЄ тvчют ЇєэъЎшш min(), хёыш фы фрээюую Єшяр эх юяЁхфхыхэр юяхЁрЎш ьхэ№°х. T++ эх яючтюы хЄ чрфрЄ№ юуЁрэшўхэш фы Єшяют, яюфёЄрты хьvї т °рсыюэv. ¦ръ тv фєьрхЄх, сvыю сv яюыхчэvь шьхЄ№ Єръє¦ тючьюцэюёЄ№? +ёыш фр, яюяЁюсєщЄх яЁшфєьрЄ№ ёшэЄръёшё чрфрэш юуЁрэшўхэшщ ш яхЁхяш°шЄх т эхь юяЁхфхыхэшх ъырёёр Example2. +ёыш эхЄ, яю ёэшЄх яюўхьє.

LяЁрцэхэшх 2.17

¦ръ сvыю яюърчрэю т яЁхфvфє•хь єяЁрцэхэшш, яюяvЄър шёяюы№чютрЄ№ °рсыюэ Example2 ё Єшяюь, фы ъюЄюЁюую эх юяЁхфхыхэр юяхЁрЎш ьхэ№°х, яЁштхфхЄ ъ ёшэЄръёшўхёъющ ю°шсъх. +фэръю ю°шсър яЁю тшЄё Єюы№ъю Єюуфр, ъюуфр т ЄхъёЄх ъюьяшышЁєхьющ яЁюуЁрььv фхщёЄтшЄхы№эю тёЄЁхЄшЄё тvчют ЇєэъЎшш min(), т яЁюЄштэюь ёыєўрх ъюьяшы Ўш яЁющфхЄ єёях°эю. ¦ръ тv ёўшЄрхЄх, юяЁртфрэю ыш Єръюх яютхфхэшх? =х ыєў°х ыш яЁхфєяЁхфшЄ№ юс ю°шсъх ёЁрчє, яЁш юсЁрсюЄъх юяшёрэш °рсыюэр? ¦ю ёэшЄх ётюх ьэхэшх.

Содержание раздела