Альтернативні Інтерфейси

Після того, як описано засоби мови, які відносяться до похідних класів, обговорення знову може повернутися до вартим завданням. У класах, які описуються в цьому розділі, основна ідея полягає в те, що вони одного разу написані, а потім їх використовують програмісти, які не можуть змінити їх визначення. Фізично класи складаються з одного або більше заголовків файлів, що визначають інтерфейс, і одного або більше файлів, визначають реалізацію. Заголовки будуть поміщені кудись туди, звідки користувач може взяти їх копії за допомогою директиви # include. Файли, визначають реалізацію, звичайно компілюють і поміщають в бібліотеку.

Інтерфейс

Розглянемо таке написання класу slist для одноразово пов'язаного списку, за допомогою якого можна створювати як однорідні, так і неоднорідні списки об'єктів тих типів, які ще повинні бути визначені. Спочатку ми визначимо тип ent:

typedef void * ent;

Точна сутність типу ent несуттєва, але потрібно, щоб у ньому міг зберігатися покажчик. Тоді ми визначимо тип slink:

class slink (

friend class slist;

friend class slist_iterator;

slink * next;

ent e;

slink (ent a, slink * p) (e = a; next = p;)

);

В одній ланці може зберігатися один ent, і за допомогою нього реалізується клас slist:

class slist (

friend class slist_iterator;

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

public:

int insert (ent a);// додати в голову списку

int append (ent a);// додати у хвіст списку

ent get ();// повернутися і прибрати голову списку

void clear ();// прибрати всі ланки

slist () (last = 0;)

slist (ent a) (last = new slink (a, 0); last-> next = last;)

~ slist () (clear ();)

);

Хоча список очевидним чином реалізується як пов'язаний список, реалізацію можна змінити так, щоб використовувався вектор з ent "ов, не вплинувши при цьому на користувачів. Тобто, застосування slink "ов ніяк не видно в описах відкритих функцій slist" ов, а видно тільки в закритій частині і визначеннях функцій.

Реалізація

реалізують slist функції в основному прості. Єдина справжня складність - що робити у випадку помилки, якщо, наприклад, користувач спробує get () що-небудь з пустого списку. Тут наводяться визначення членів slist. Зверніть увагу, як зберігання покажчика на останній елемент кругового списку дає можливість просто реалізувати обидві дії append () та insert ():

int slist:: insert (ent a)

(

if (last)

last-> next = new slink (a, last-> next);

else (

last = new slink (a, 0);

last-> next = last;

)

return 0;

)

int slist:: append (ent a)

(

if (last)

last = last-> next = new slink (a, last-> next);

else (

last = new slink (a, 0);

last-> next = last;

)

return 0;

)

ent slist:: get ()

(

if (last == 0) slist_handler ( "get fromempty list ");

// взяти з пустого списку

slink * f = last-> next;

ent r f-> e;

if (f == last)

last = 0;

else

last-> next = f-> next;

delete f;

return f;

)

Зверніть увагу, як викликається slist_handler. Цей вказівник на ім'я функції використовується точно так само, як якщо б він був ім'ям функції. Це є короткою формою більш явною запису виклику:

(* slist_handler) ( "get fromempty list ");

І slist:: clear (), нарешті, видаляє зі списку всі елементи:

void slist:: clear ()

(

slink * l = last;

if (l == 0) return;

do (

slink * ll = l;

l = l-> next;

delete ll;

) while (l! = last);

)

Клас slist не забезпечує способу зазирнути в список, але тільки кошти для вставляння і видалення елементів. Однак обидва класу, і slist, і slink, описують клас slist_iterator як одного, тому ми можемо описати підходящий ітератор. Ось один, написаний в дусі цього пункту:

class slist_iterator (

slink * ce;

slist * cs;

public:

slist_iterator (slist & s) (cs = &s; ce = cs-> last;)

ent operator () () (

// для індикації кінця ітерації повертає 0

// для всіх типів не ідеальний, гарний для покажчиків

ent ret = ce? (ce = ce-> next) -> e: 0;

if (ce == cs-> last) ce = 0;

return ret;

)

);

Як Цим Користуватися

Фактично клас slist в написаному вигляді даремний. У Зрештою, навіщо можна використовувати список покажчиків void *? Штука в тому, щоб вивести клас з slist та отримати список тих об'єктів, які представляють інтерес в конкретній програмі. Уявімо компілятор мови на зразок C + +. У ньому широко будуть використовуватися списки імен, а ім'я - це щось на зразок

struct name (

char * string;

// ...

);

До списку будуть міститися покажчики на імена, а не самі об'єкти імена. Це дозволяє використовувати невелику інформаційне поле e slist "а, і дає можливість імені перебувати одночасно більше ніж в одному списку. Ось визначення класу nlist, який дуже просто виводиться з класу slist:

# include "slist.h"

# include "name.h"

struct nlist: slist (

void insert (name * a) (slist:: insert (a);)

void append (name * a) (slist:: append (a);)

name * get () ()

nlist (name * a): (a) ()

);

Опції нового класу або успадковуються від slist безпосередньо, або нічого не роблять крім перетворення типу. Клас nlist -- це ніщо інше, як альтернативний інтерфейс класу slist. Так як на самому справі тип ent є void *, немає необхідності явно перетворювати покажчики name *, які використовуються в якості фактичних параметрів.

Списки імен можна використовувати в класі, який представляє визначення класу:

struct classdef (

nlist friends;

nlist constructors;

nlist destructors;

nlist members;

nlist operators;

nlist virtuals;

// ...

void add_name (name *);

classdef ();

~ classdef ();

);

і імена можуть додаватися до цих списків приблизно так:

void classdef:: add_name (name * n)

(

if (n-> is_friend ()) (

if (find (& friends, n))

error ( "friend redeclared ");

else if (find (& members, n))

error ( "friend redeclared as member ");

else

friends.append (n);

)

if (n-> is_operator ()) operators.append (n);

// ...

)

де is_iterator () і is_friend () є функціями членами класу name. Фукнцію find () можна написати так:

int find (nlist * ll, name * n)

(

slist_iterator ff (* (slist *) ll);

ent p;

while (p = ff ()) if (p == n) return 1;

return 0;

)

Тут застосовується явне перетворення типу, щоб застосувати slist_iterator до nlist. Більш хороше рішення, - зробити ітератор для nlist "ов. Друкувати nlist може, наприклад, така функція:

void print_list (nlist * ll, char * list_name)

(

slist_iterator count (* (slist *) ll);

name * p;

int n = 0;

while (count ()) n ++;

cout <

slist_iterator print (* (slist *) ll);

while (p = (name *) print ()) cout < string << "n";

)

Обробка помилок

Є чотири підходи до проблеми, що ж робити, коли під час виконання общецелевое засіб на зразок slist стикається з помилкою (в C + + немає ніяких спеціальних засобів мови для обробки помилок):

Повертати неприпустиме значення і дозволити користувачеві його перевіряти;

Повертати додаткове значення стану і дозволити користувачеві перевіряти його;

Викликати функцію помилок, задану як частина класу slist; або

Викликати функцію помилок, яку імовірно надає користувач.

Для невеликої програми, написаної її єдиним користувачем, фактично немає ніяких особливих причин віддати перевагу одне з цих рішень іншим. Для кошти загального призначення ситуація зовсім інша.

Перший підхід, повертати неприпустиме значення, нездійсненний. Немає абсолютно ніякого способу дізнатися, що якийсь конкретний значення буде неприпустимим у всіх застосуваннях slist.

Другий підхід, повертати значення стану, можна використовувати в деяких класах (один з варіантів цього плану застосовується в стандартних потоках введення/виводу istream і ostream). Тут, однак, є серйозна проблема, раптом користувач не подбає перевірити значення стану, коли кошти не надто часто підводить. Крім того, засіб може використовуватися в сотні або навіть тисячі місць програми. Перевірка значення в кожному місці сильно ускладнить читання програми.

Третьому підходу, надавати функцію помилок, бракує гнучкості. Той, хто реалізує общецелевое засіб, не може дізнатися, як користувачі захочуть, щоб оброблялися помилки. Наприклад, користувач може віддавати перевагу повідомлення на датському або угорською.

Четвертий підхід, дозволити користувачеві задавати функцію помилок, має деяку привабливість за умови, що розробник надає клас у вигляді бібліотеки (# 4.5), в якій містяться стандартні функції обробки помилок. Рішення 3 і 4 можна зробити більш гнучкими (і по суті еквівалентними), задавши покажчик на функцію, а не саму функцію. Це дозволить розробнику такого засобу, як slist, надати функцію помилок, діючу за умовчанням, і при цьому програмістам, які будуть використовувати списки, буде легко поставити свої власні функції помилок, якщо потрібно, і там, де потрібно.

Наприклад:

typedef void (* PFC) (char *);// покажчик на тип функція

extern PFC slist_handler;

extern PFC set_slist_handler (PFC);

Функція set_slist_hanlder () дозволяє користувачеві замінити стандартну функцію. Невизначений реалізація надає діючу за замовчуванням функцію обробки помилок, яка спочатку пише повідомлення про помилку в cerr, після чого завершує програму за допомогою exit ():

# include "slist.h"

# include

void default_error (char * s)

(

cerr <

exit (1);

)

Вона описує також покажчик на функцію помилок і, для зручності запису, функцію для її установки:

PFC slist_handler = default_error;

PFC set_slist_handler (PFC handler);

(

PFC rr = slist_handler;

slist_handler = handler;

return rr;

)

Зверніть увагу, як set_slist_hanlder () повертає попередній slist_hanlder (). Це робить зручним установку і переустановку обробників помилок на кшталт стека. Це може бути в основному корисним у великих програмах, в яких slist може використовуватися в кількох різних ситуаціях, у кожній з яких можуть, таким чином, ставити свої власні підпрограми обробки помилок.

Наприклад:

(

PFC old = set_slist_handler (my_handler);

// код, в якому у разі помилок в slist

// буде використовуватися мій обробник my_handler

set_slist_handler (old);// відновлення

)

Щоб зробити управління більш витонченим, slist_hanlder міг б бути зроблений членом класу slist, що дозволило б різним спискам мати одночасно різні обробники.

Узагальнені Класи

Очевидно, можна було б визначити списки інших типів (classdef *, int, char * і т.д.) точно так само, як було визначено клас nlist: простим висновком з класу slist. Процес визначення таких нових типів стомлюючий (і тому загрожує помилками), але за допомогою макросів його можна "механізувати". На жаль, якщо користуватися стандартним C препроцесором, це теж може виявитися обтяжливим. Однак отриманими в результаті макросами користуватися досить просто.

Ось приклад того, як узагальнений (generic) клас slist, названий gslist, може бути заданий як макрос. Спочатку для написання такої роду макросів включаються деякі інструменти з:

. html # include "slist.h"

# ifndef GENERICH

# include

# endif

Зверніть увагу на використання # ifndef для того, щоб гарантувати, що в одній компіляції не буде включено двічі. GENERICH визначений ст.

Після цього за допомогою name2 (), макросу з для конкатенації імен, визначаються імена нових узагальнених класів:

# 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) & a)

: ((slist &) 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 (описати) визначений ст. Він конкатенірует свої параметри і викликає макрос з такою назвою, у даному випадку gslistdeclare, описаний вище. Параметр ім'я типу для declare повинен бути простим ім'ям. Використаний метод макровизначеннями не може обробляти імена типів на зразок name *, тому застосовується typedef.

Використання виведення класу гарантує, що всі приватні випадки узагальненого класу поділяють код. Цей метод можна застосовувати тільки для створення класів об'єктів того ж розміру або менше, ніж базовий клас, який використовується в макросі.

Обмежені Інтерфейси

Клас 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 () ()

);

Список літератури

Для підготовки даної роботи були використані матеріали з сайту http://www.realcoding.net