Чтение онлайн

Рассмотрим класс name, который использовался в примерах table. Его можно было бы определить так:

struct name (* char* string; name* next; double value;

name(char*, double, name*); ~name; *);

Программист может воспользоваться тем, что размещение и освобождение объектов заранее известного размера можно обрбатывать гораздо эффективнее (и по памяти, и по времени), чем с помощью общей реализации new и delete. Общая идея состоит в том, чтобы предварительно разместить «куски» из объектов name, а затем сцеплять их, чтобы свести выделение и освободение к простым операциям над связанным списком. Переменная nfree является вершиной списка неиспользованных name:

const NALL = 128; name* nfree;

Распределитель, используемый операцией new, хранит рамер объекта вместе с объектом, чтобы обеспечить правильную работу операции delete. С помощью распределителя, специализрованного для типа, можно избежать этих накладных расходов. Например, на моей машине следующий распределитель использует для хранения name 16 байт, тогда как для стандартного распрделителя свободной памяти нужно 20 байт. Вот как это можно сделать:

name::name(char* s, double v, name* n) (* register name* p = nfree; // сначала выделить

if (p) nfree = p-»next; else (* // выделить и сцепить name* q = (name*)new char[ NALL*sizeof(name) ]; for (p=nfree= amp;q[NALL-1]; q«p; p–) p-»next = p-1; (p+1)-»next = 0; *)

this = p; // затем инициализировать string = s; value = v; next = n; *)

Присвоение указателю this информирует компилятор о том, что программист взял себе управление, и что не надо использвать стандартный механизм распределения памяти. Конструктор name::name обрабатывает только тот случай, когда name рамещается посредством new, но для большей части типов это всегда так. В #5.5.8 объясняется, как написать конструктор для обработки как размещения в свободной памяти, так и других видов размещения.

Заметьте, что просто как

name* q = new name[NALL];

память выделять нельзя, поскольку это приведет к бескнечной рекурсии, когда new вызовет name::name.

Освобождение памяти обычно тривиально:

name::~name (* next = nfree; nfree = this; this = 0; *)

Присваивание указателю this 0 в деструкторе обеспечивет, что стандартный распределитель памяти не используется.

Когда в конструкторе производится указателю this, значние this до этого присваивания неопределено. Таким образом, ссылка на член до этого присваивания неопределена и скорее всего приведет к катастрофе. Имеющийся компилятор не пытается убедиться в том, что присваивание указателю this происходит на всех траекториях выполнения:

mytype::mytype(int i) (* if (i) this = mytype_alloc; // присваивание членам *);

откомпилируется, и при i==0 никакой объект размещен не будет.

Конструктор может определить, был ли он вызван операцией new, или нет. Если он вызван new, то указатель this на входе имеет нулевое значение, в противном случае this указывает на пространство, уже выделенное для объекта (например, на стек). Поэтому можно просто написать конструктор, который выделяет память, если (и только если) он был вызван через new. Напрмер:

mytype::mytype(int i) (* if (this == 0) this = mytype_alloc; // присваивание членам *);

Эквивалентного средства, которое позволяет деструктору решить вопрос, был ли его объект создан с помощью new, не имеется, как нет и средства, позволяющего ему узнать, вызвала ли его delete, или он вызван объектом, выходящим из области видимости. Если для пользователя это существенно, то он может сохранить где-то соответствующую информацию для деструктора. Другой способ – когда пользователь обеспечивает, что объекты этого класса размещаются только соответствующим образом. Если удается справиться с первой проблемой, то второй способ интреса не представляет.

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

Когда пользователь берет управление распределением и овобождением памяти, он может конструировать объекты размеры, которых во время компиляции недетерминирован. В предыдущих примерах вмещающие (или контейнерные – перев.) классы vector, stack, intset и table реализовывались как структуры доступа фиксированного размера, содержащие указатели на реальную пмять. Это подразумевает, что для создания таких объектов в свободной памяти необходимо две операции по выделению памяти, и что любое обращение к хранимой информации будет содержать дополнительную косвенную адресацию. Например:

class char_stack (* int size; char* top; char* s; public: char_stack(int sz) (* top=s=new char[size=sz]; *) ~char_stack (* delete s; *) // деструктор void push(char c) (* *top++ = c; *) char pop (* return *–top; *) *);

Если каждый объект класса размещается в свободной памти, это делать не нужно. Вот другой вариант:

class char_stack (* int size; char* top; char s[1]; public: char_stack(int sz); void push(char c) (* *top++ = c; *) char pop (* return *–top; *) *);

char_stack::char_stack(int sz) (* if (this) error(«стек не в свободной памяти»); if (sz « 1) error(„размер стека « 1“); this = (char_stack*) new char[sizeof(char_stack)+sz-1]; size = sz; top = s; *)

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

1. (*1) Модифицируйте настольный калькулятор из Главы 3, чтобы использовать класс table.

2. (*1) Разработайте tnode (#с.8.5) как класс с контрукторами, деструкторами и т.п. Определите дерево из tnode'ов как класс с конструкторами, деструкторами и т.п.

3. (*1) Преобразуйте класс intset (#5.3.2) в множество строк.

4. (*1) Преобразуйте класс intset в множество узлов node, где node – определяемая вами структура.

5. (*3) Определите класс для анализа, хранения, вычислния и печати простых арифметических выражений, состоящих из целых констант и операций +, -, * и /. Открытый итерфейс должен выглядеть примерно так:

class expr (* // ... public: expr(char*); int eval; void print; *) Параметр строка конструктора expr::expr является выржением. Функция expr::eval возвращает значение выражния, а expr::print печатает представление выражения в cout. Программа может выглядеть, например, так: