last->next = f->next; return f;

Возможно более гибкое решение, когда slist handler - указатель на функцию, а не сама функция. Тогда вызов

slist handler( нельзя взять из пустого списка ); будет задаваться так

(*slist handler)( нельзя взять из пустого списка );

Как мы уже делали для функции new handler ($$3.2.6), полезно завести функцию, которая поможет пользователю создавать свои обработчики ошибок:

typedef void (*PFV)(const char*); PFV set slist handler(PFV a)

PFV old = slist handler; slist handler = a; return old;

PFV slist handler = &default slist handler;

Особые ситуации, которые обсуждаются в главе 9, не только дают альтернативный способ обработки ошибок, но и способ реализации slist handler.

8.3.4 Итерация

В классе slist base нет функций для просмотра списка, можно только вставлять и удалять элементы. Однако, в нем описывается как друг класс slist base iter, поэтому можно определить подходящий для списка итератор. Вот один из возможных, заданный в том стиле, какой был показан в $$7.8:

class slist base iter {

slink* ce; текущий элемент

slist base* cs; текущий список

public:

inline slist base iter(slist base& s); inline slink* operator()()

slist base iter::slist base iter(slist base& s)

cs = &s; ce = cs->last;

slink* slist base iter::operator()() возвращает 0, когда итерация кончается

slink* ret = ce ? (ce=ce->next) : 0; if (ce == cs->last) ce = 0; return ret;

Исходя из этих определений, легко получить итераторы для Slist и Islist. Сначала надо определить дружественные классы для итераторов по соответствующим контейнерным классам:

template<class T> class Islist iter; template<class T> class Islist {

friend class Islist iter<T>;

template<class T> class Slist iter;

template<class T> class Slist { friend class Slist iter<T>;

Обратите внимание, что имена итераторов появляются без определения их шаблонного класса. Это способ определения в условиях взаимной зависимости шаблонов типа.

Теперь можно определить сами итераторы:

template<class T>

class Islist iter : private slist base iter { public:

Islist iter(Islist<T>& s) : slist base iter(s) { } T* operator()()

{ return (T*) slist base iter::operator()(); }

template<class T>

class Slist iter : private slist base iter { public:

Slist iter(Slist<T>& s) : slist base iter(s) { } inline T* operator()();

T* Slist iter::operator()()

return ((Tlink<T>*) slist base iter::operator()())->info;

Заметьте, что мы опять использовали прием, когда из одного базового класса строится семейство производных классов (а именно, шаблонный класс). Мы используем наследование, чтобы выразить общность классов и избежать ненужного дублирования функций. Трудно переоценить стремление избежать дублирования функций при реализации таких простых и часто используемых классов как списки и итераторы. Пользоваться этими итераторами можно так:

void f(name* p)

Islist<name> lst1; Slist<name> lst2; lst1.insert(p); lst2.insert(p); ...

Islist iter<name> iter1(lst1); const name* p;

while (p=iter1()) {

list iter<name> iter2(lst1); const name* q; while (q=iter2()) {

if (p == q) cout << найден << *p << \n;

Есть несколько способов задать итератор для контейнерного класса. Разработчик программы или библиотеки должен выбрать один из них и придерживаться его. Приведенный способ может показаться слишком хитрым. В более простом варианте можно было просто переименовать operator()() как next(). В обоих вариантах предполагается взаимосвязь между контейнерным классом и итератором для него, так

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

Если понятие текущего элемента предоставляет не итератор, а сам контейнер, итерация происходит в принудительном порядке по отношению к контейнеру аналогично тому, как поля связи принудительно хранятся в объектах из контейнера. Значит трудно одновременно вести две итерации для одного контейнера, но расходы на память и время при такой организации итерации близки к оптимальным. Приведем пример:

class slist base {

...

slink* last; last->next голова списка

slink* current; текущий элемент public:

...

slink* head() { return last?last->next:0; } slink* current() { return current; } void set current(slink* p) { current = p; } slink* first() { set current(head()); return current; } slink* next(); slink* prev();

Подобно тому, как в целях эффективности и компактности программы можно использовать для одного объекта как список с принудительной связью, так и список без нее, для одного контейнера можно использовать принудительную и непринудительную итерацию:

void f(Islist<name>& ilst) медленный поиск имен- дубликатов

list iter<name> slow(ilst); используется итератор name* p;

while (p = slow()) {

ilst.set current(p); рассчитываем на текущий элемент name* q;

while (q = ilst.nextO)

if (strcmp(p->string,q->string) == 0) cout << дубликат << p << \n;

Еще один вид итераторов показан в $$8.8.

8.4 Шаблоны типа для функций

Использование шаблонных классов означает наличие шаблонных функций-членов. Помимо этого, можно определить глобальные шаблонные функции, т.е. шаблоны типа для функций, не являющихся членами класса. Шаблон типа для функций порождает семейство функций точно также, как шаблон типа для класса порождает семейство классов. Эту возможность мы обсудим на последовательности примеров, в которых приводятся варианты функции сортировки sort(). Каждый из вариантов в последующих разделах будет иллюстрировать общий метод.

Как обычно мы сосредоточимся на организации программы, а не на разработке ее алгоритма, поэтому использоваться будет тривиальный алгоритм. Все варианты шаблона типа для sort() нужны для того, чтобы показать возможности языка м полезные приемы программирования. Варианты не упорядочены в соответствии с тем, насколько они хороши. Кроме того, можно обсудить и традиционные варианты без шаблонов типа, в частности, передачу указателя на функцию, производящую сравнение.