подвидов. Приведите пример открытого интерфейса для этой иерархии, включая конструкторы. Определите виртуальные функции. Напишите псевдокод маленькой

(a)Точка

(b)Служащий

(c)Фигура

(d)Телефонный_номер

(e)Счет_в_банке

программы, использующей данный интерфейс.

(f) Курс_продажи

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

Наш класс 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;

}

Array<int>

ia(array_size)

;

Здесь определены три экземпляра класса Array:

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

Что делает компилятор, встретив такое объявление? Подставляет текст шаблона Array, заменяя параметр elemType на тот тип, который указан в каждом конкретном случае. Следовательно, объявления членов приобретают в первом случае такой вид:

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

int *_ia;

Заметим, что это в точности соответствует определению массива IntArray. Для оставшихся двух случаев мы получим следующий код:

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

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

#include

"Array

.h"

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

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

<iostre

am>

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

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

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

Упражнение 2.16

Пример из предыдущего упражнения накладывает определенные ограничения на типы данных, которые могут быть подставлены вместо elemType. Так, параметр конструктора имеет по умолчанию значение 0:

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

Однако не все типы могут быть инициализированы нулем (например, тип string), поэтому определение объекта

Example2<string> exs("Walden");

является правильным, а

Example2<string> exs2;

приведет к синтаксической ошибке4. Также ошибочным будет вызов функции min(), если для данного типа не определена операция меньше. С++ не позволяет задать ограничения для типов, подставляемых в шаблоны. Как вы думаете, было бы полезным иметь такую возможность? Если да, попробуйте придумать синтаксис задания ограничений и перепишите в нем определение класса Example2. Если нет, поясните почему.

Упражнение 2.17

Как было показано в предыдущем упражнении, попытка использовать шаблон Example2 с типом, для которого не определена операция меньше, приведет к синтаксической

4 Вот как выглядит общее решение этой проблемы:

Example2( elemType nval = elemType() ) " _val( nval ) {}