C++

После этого с помощью name2(), макроса из «generic.h» для конкатенации имен, определяются имена новых обобщенных

классов:

#define gslist(type) name2(type,gslist) #define gslist_iterator(type) name2(type,gslist_iterator)

И, наконец, можно написать классы gslist(тип) и gslist_iterator(тип):

#define gslistdeclare(type) \ struct gslist(type) : slist (* \ int insert(type a) \ (* return slist::insert( ent(a) ); *) \ int append(type a) \ (* return slist::append( ent(a) ); *) \ type get() (* return type( slist::get() ); *) \ gslist(type)() (* *) \ gslist(type)(type a) : (ent(a)) (* *) \ ~gslist(type)() (* clear(); *) \ *); \ \ struct gslist_iterator(type) : slist_iterator (* \ gslist_iterator(type)(gslist(type) amp; a) \ : ( (slist amp;)s ) (**) \ type operator()() \ (* return type( slist_iterator::operator()() ); *)\ *)

\ на конце строк указывает , что следующая строка явлется частью определяемого макроса.

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

#include «name.h»

typedef name* Pname; declare(gslist,Pname); // описывает класс gslist(Pname)

gslist(Pname) nl; // описывает один gslist(Pname)

Макрос declare (описать) определен в «generic.h». Он конкатинирует свои параметры и вызывает макрос с этим именем, в данном случае gslistdeclare, описанный выше. Параметр имя типа для declare должен быть простым именем. Используемый мтод макроопределения не может обрабатывать имена типов вроде name*, поэтому применяется typedef.

Использование вывода класса гарантирует, что все частные случаи обобщенного класса разделяют код. Этот метод можно применять только для создания классов объектов того же размра или меньше, чем базовый класс, который используется в маросе. gslist применяется в #7.6.2.

7.3.6 Ограниченные Интерфейсы

Класс slist – довольно общего характера. Иногда подобная общность не требуется или даже нежелательна. Ограниченные вды списков, такие как стеки и очереди, даже более обычны, чем сам обобщенный список. Такие структуры данных можно задать, не описав базовый класс как открытый. Например, очередь целых можно определить так:

#include «slist.h»

class iqueue : slist (* //предполагается sizeof(int)«=sizeof(void*)

public: void put(int a) (* slist::append((void*)a); *) int det() (* return int(slist::get()); *) iqueue() (**) *);

При таком выводе осуществляются два логически разделеных действия: понятие списка ограничивается понятием очереди (сводится к нему), и задается тип int, чтобы свести понятие очереди к типу данных очередь целых, iqueue. Эти два действия можно выполнять и раздельно. Здесь первая часть – это список, ограниченный так, что он может использоваться только как стек:

#include «slist.h»

class stack : slist (* public: slist::insert; slist::get; stack() (**) stack(ent a) : (a) (**) *);

который потом используется для создания типа «стек укзателей на символы»:

#include «stack.h»

class cp : stack (* public: void push(char* a) (* slist::insert(a); *) char* pop() (* return (char*)slist::get(); *) nlist() (**) *);

7.4 Добавление к Классу

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

Для производного класса можно определить данные и фунции дополнительно к тем, которые наследуются из его базового класса. Это дает альтернативную стратегию того, как обеспчить средства связанного списка. Заметьте, когда в тот slist, который определялся выше, помещается элемент, то создается slink, содержащий два указателя. На их создание тратится врмя, а ведь без одного из указателей можно обойтись, при услвии, что нужно только чтобы объект мог находиться в одном списке. Так что указатель next на следующий можно поместить в сам объект, вместо того, чтобы помещать его в отдельный обект slink. Идея состоит в том, чтобы создать класс olink с единственным полем next, и класс olist, который может обрабтывать указатели на такие звенья olink. Тогда olist сможет манипулировать объектами любого класса, производного от olink. Буква "o" в названиях стоит для того, чтобы напоминать вам, что объект может находиться одновременно только в одном списке olist:

struct olink (* olink* next;

*);

Класс olist очень напоминает класс slist. Отличие состит в том, что пользователь класса olist манипулирует объектми класса olink непосредственно:

class olist (* olink* last; public: void insert(olink* p); void append(olink* p); olink* get(); // ... *);

Мы можем вывести из класса olink класс name:

class name : public olink (* // ... *);

Теперь легко сделать список, который можно использовать без накладных расходов времени на размещение или памяти.