8.3.1 Список с принудительной связью

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

Начнем с типа slink, определяющего поле связи в односвязном списке:

struct slink { slink* next; slink() { next = 0; } slink(slink* p) { next = p; }

Теперь можно определить класс, который может содержать объекты любого, производного от slink, класса:

class slist base {

public:

int insert(slink*); int append(slink*);

slink* get();

добавить в начало списка добавить к концу списка удалить

и возвратить начало списка

Такой класс можно назвать списком с принудительной связью, поскольку его можно использовать только в том случае, когда все элементы имеют поле slink, которое используется как указатель на slist base. Само имя slist base (базовый односвязный список) говорит, что этот класс будет использоваться как базовый для односвязных списочных классов. Как обычно, при разработке семейства родственных классов возникает вопрос, как выбирать имена для различных членов семейства. Поскольку имена классов не могут перегружаться, как это делается для имен функций, для обуздания размножения имен перегрузка нам не поможет.

Класс slist base можно использовать так:

void f()

slist base slb; slb.insert(new slink); ...

slink* p = slb.getO;

...

delete p;

Но поскольку структура slink не может содержать никакой информации помимо связи, этот пример не слишком интересен. Чтобы воспользоваться slist base, надо определить полезный, производный от slink, класс. Например, в трансляторе используются узлы дерева программы name (имя), которые приходится связывать в список:

class name : public slink {

void f(const char* s)

slist base slb; slb.insert(new name(s)); ...

name* p = (name*)slb.get();

Приведение в функции Islist::get() совершенно оправдано и надежно, поскольку в классе Islist гарантируется, что каждый объект в списке действительно имеет тип T или тип производного от T класса. Отметим, что slist base является частным базовым классом Islist. Мы нет хотим, чтобы пользователь случайно натолкнулся на ненадежные детали реализации.

Имя Islist (intrusive singly linked list) обозначает односвязный список с принудительной связью. Этот шаблон типа можно использовать так:

void f(const char* s)

Islist<name> ilst; ilst.insert(new name(s));

name* p = ilst.getO;

...

delete p

Попытки некорректного использования будет выявлены на стадии трансляции:

class expr : public slink {

void g(expr* e)

Islist<name> ilst; ilst.insert(e);

ошибка: Islist<name>::insert(), а нужно name*

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

...

delete p;

Здесь все нормально, но поскольку определение класса slist base дано через структуру slink, приходится использовать явное приведение типа для преобразования значения типа slink*, возвращаемого функцией slist base::get(), в name*. Это некрасиво. Для большой программы, в которой много списков и производных от slink классов, это к тому же чревато ошибками. Нам пригодилась бы надежная по типу версия класса slist base:

template<class T>

class Islist : private slist base { public:

void insert(T* a) { slist base::insert(a); } T* get() { return (T*) slist base::get(); }

время он обеспечивает большую гибкость и компактность выражений.

К сожалению, объект может попасть в Islist только, если он является производным от slink. Значит нельзя иметь список Islist из значений типа int, нельзя составить список из значений какого-то ранее определенного типа, не являющегося производным от slink. Кроме того, придется постараться, чтобы включить объект в два списка Islist ($$6.5.1).

8.3.2 Список без принудительной связи

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

template<class T> struct Tlink : public slink { T info;

Tlink(const T& a) : info(a) { }

Класс Tlink<T> хранит копию объектов типа T помимо поля связи, которое идет от его базового класса slink. Отметим, что используется инициализатор в виде info(a), а не присваивание info=a. Это существенно для эффективности операции в случае типов, имеющих нетривиальные конструкторы копирования и операции присваивания ($$7.11). Для таких типов (например, для String) определив конструктор как

Tlink(const T& a) { info = a; }

мы получим, что будет строиться стандартный объект String, а уже затем ему будет присваиваться значение. Имея класс, определяющий связь, и класс Islist, получить определение списка без принудительной связи совсем просто:

template<class T>

class Slist : private slist base { public:

void insert(const T& a)

{ slist base::insert(new Tlink<T>(a)); } void append(const T& a)

{ slist base::append(new Tlink<T>(a)); }

T get();

...

template<class T> T Slist<T>::get()

Tlink<T>* lnk = (Tlink<T>*) slist base::get(); T i = lnk->info; delete lnk; return i;

Работать со списком Slist так же просто, как и со списком Ilist. Различие в том, что можно включать в Slist объект, класс которого не является производным от slink, а также можно включать один объект в два списка:

void f(int i)

Slist<int> lst1; Slist<int> lst2; lst1.insert(i);