Абельсон Х., Сассман Д.Д. Структура и интерпретация компьютерных программ

Подождите немного. Документ загружается.

3.3. Моде лирование при помощи изменяемых данных

241

Покажите, какая структура окружений создается последовательностью действий

(define acc (make-account 50))

((acc ’deposit) 40)

((acc ’withdraw) 60)

Где хранится внутреннее со с тояние acc? Предположим, что мы определяем еще один счет

(define acc2 (make-account 100))

Каким образом удается не смешивать внутренние состояния двух счетов? Какие части структуры

окружений общие у acc и acc2?

3.3. Моделирование при помощи изменяемых данных

В главе 2 составные данные использовались как средство построения вычислитель-

ных объектов, состоящих из нескольких частей, с целью моделирования объектов ре-

ального мира, обладающих несколькими свойствами. В этой главе мы ввели дисципли-

ну абстракции данных, согласно которой структуры данных описываются в терминах

конструкторов, которые создают объекты данных, и селекторов, которые о беспечивают

доступ к частям составных объектов. Однако теперь мы знаем, что есть еще один аспект

работы с данными, который остался незатронутым в главе 2. Желание моделировать

системы, которые состоят из объектов, обладающих изменяющимся состоянием, вызы-

вает потребность не только создавать составные объекты данных и иметь доступ к их

частям, но и изменять их. Чтобы моделировать объекты с изменяющимся состоянием,

мы будем проектировать абстракции данных, которые, помимо конструкторов и селек-

торов, включают мутаторы (mutators), модифицирующие объекты данных. Например,

моделирование банковской системы требует от нас способности изменять балансы сче-

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

операцией

(set-balance! hсчетi hновое-значениеi)

которая присваивает балансу указанного счета указанное значение. Объекты дан-

ных, для которых определены мутаторы, называются изменяемыми объектами данных

(mutable data objects).

В главе 2 в качестве универ сального «клея» для построения составных данных мы

ввели пары. Этот раздел мы начинаем с определения мутаторов для пар, так, чтобы пары

могли служить строительным материалом для построения изменяемых объектов данных.

Мутаторы значите льно увеличивают выразительную силу пар и позволяют нам строить

структуры данных помимо последовательностей и деревьев, с которыми мы имели дело

в разделе 2.2. Кроме того, мы строим несколько примеров моделей, где сложные системы

представляются в виде множества объектов, обладающих внутренним состоянием.

242

Глава 3. Модульность, объекты и состояние

c d

a b

e f

Рис. 3.12. Списки x: ((a b) c d) и y: (e f).

3.3.1. Изменяемая списковая структура

Базовые операции над парами — cons, car и cdr — можно использовать для по-

строения списковой структуры и для извлечения частей списковой структуры, однако

изменять списковую структуру они не позволяют. То же верно и для операций со спис-

ками, которые мы до сих пор использовали, таких, как append и list, поскольку эти

последние можно определить в терминах cons, car и cdr. Для модификации списковых

структур нам нужны новые операции.

Элементарные мутаторы для пар называются setcar! и set-cdr!. Setcar! при-

нимает два аргумента, первый из которых обязан быть парой. Он модифицирует эту

пару, подс тавляя вместо указателя car указатель на свой второй аргумент

В качестве примера предположим, что переменная x имеет значением список ((a

b) c d), а переменная y список (e f), как показано на рисунке 3.12. Вычисление

выражения (set-car! x y) изменяе т пару, с которой связана переменная x, заменяя

ее car на значение y. Резул ьтат этой операции показан на рисунке 3.13. Структура

x изменилась, и теперь ее можно записать как ((e f) c d). Пары предс тавляющие

список (a b), на которые указывал замененный указатель, теперь отделены от исходной

структуры

Сравните рисунок 3.13 с рис. 3.14, на котором представлен результат выполнения

(define z (cons y (cdr x))), где x и y имеют исходные значения с рис. 3.12.

Здесь переменная z оказывается связана с новой парой, созданной операцией cons;

список, который является значением x, не меняется.

Операция set-cdr! подобна set-car!. Единственная разница состоит в том, что

заменяется не указатель car, а ук азатель cdr. Результат применения (set-cdr! x y)

Значения, которые возвращают set-car! и set-cdr!, зависят от реализации. Подобно set!, эти опе-

рации должны использоваться исключительно ради своего побочного э ффекта.

Здесь мы видим, как операции изменения данных могут создавать «мусор», который не является частью

никакой доступной структуры. В разделе 5.3.2 мы увидим, что системы управления памятью Лиспа включа-

ют сборщик мусора (garbage collector), который находит и освобождает память, используемую ненужными

парами.

3.3. Моде лирование при помощи изменяемых данных

243

c d

a b

e f

Рис. 3.13. Результат применения (set-car! x y) к спискам, изображенным на

рис. 3.12.

c d

a b

e f

Рис. 3.14. Результат применения (define z (cons y (cdr x)) к спискам, показан-

ным на рис. 3.12.

244

Глава 3. Модульность, объекты и состояние

c d

a b

e f

Рис. 3.15. Результат применения (set-cdr! x y) к спискам с рис. 3.12.

к спискам, изображенным на рис. 3.12, показан на рис. 3.15. Здесь указатель cdr в

составе x заменился указателем на (e f). Кроме того, список (c d), который был

cdr-ом x, оказывается отделенным от структуры.

Cons создает новую списковую структуру, порождая новые пары, а setcar! и set-

cdr! изменяют существующие. В сущности, мы могли бы реализовать cons при помощи

этих двух мутаторов и процедуры get-new-pair, которая возвращает новую пару,

не являющуюся частью никакой существующей списковой структуры. Мы порождаем

новую пару, присваиваем ее ук азателям car и cdr нужные значения, и возвращаем

новую пару в качестве результата cons

(define (cons x y)

(let ((new (get-new-pair)))

(set-car! new x)

(set-cdr! new y)

new))

Упражнение 3.12.

В разделе 2.2.1 была введена следующая процедура для добавления одного списка к другому:

(define (append x y)

(if (null? x)

(cons (car x) (append (cdr x) y))))

Append порождает новый список, по очереди наращивая элементы x в начало y. Процедура

append! подобна append, но только она является не конструктором, а мутатором. Она скле-

ивает списки вместе, изменяя последнюю пару x так, что ее cdr становится равным y. (Вызов

append! с пустым x является ошибкой.)

Get-new-pair — одна из операций, которые требуется предоставить как часть системы управления

памятью в рамках реализации Лиспа. Мы рассмотрим эти вопросы в разделе 5.3.1.

3.3. Моде лирование при помощи изменяемых данных

245

(define (append! x y)

(set-cdr! (last-pair x) y)

Здесь last-pair — процедура, которая возвращает последнюю пару своего аргумента:

(define (last-pair x)

(if (null? (cdr x))

(last-pair (cdr x))))

Рассмотрим последовательность действий

(define x (list ’a ’b))

(define y (list ’c ’d))

(define z (append x y))

(a b c d)

(cdr x)

hответi

(define w (append! x y))

(a b c d)

(cdr x)

hответi

Каковы будут пропущенные hответыi? О бъясните, нарисовав стрелочные диаграммы.

Упражнение 3.13.

Рассмотрим следующую процедуру make-cycle, которая пользуется last-pair из упражне-

ния 3.12:

(define (make-cycle x)

(set-cdr! (last-pair x) x)

Нарисуйте стрелочную диаграмму, которая изображает структуру z, созданную таким кодом:

(define z (make-cycle (list ’a ’b ’c)))

Что случится, если мы попробуем вычислить (last-pair z)?

Упражнение 3.14.

Следующая процедура, хотя и сложна для понимания, вполне может оказаться полезной:

(define (mystery x)

(define (loop x y)

246

Глава 3. Модульность, объекты и состояние

a b

Рис. 3.16. Список z1, порождаемый выражением (cons x x).

a b

Рис. 3.17. Список z2, порождаемый выражением (cons (list ’a ’b) (list ’a

’b)).

(if (null? x)

(let ((temp (cdr x)))

(set-cdr! x y)

(loop temp x))))

(loop x ’()))

Loop пользуется «временной» переменной temp, чтобы сохранить старое значение cdr пары x,

поскольку set-cdr! на следующей строке его разрушает. Объясните, что за задачу выполняет

mystery. Предположим, что переменная v определена выражением (define v (list ’a ’b

’c ’d). Нарисуйте диаграмму, которая изображает список, являющийся значением v. Допустим,

что теперь мы выполняем (define w (mystery v)). Нарисуйте стрелочные диаграммы, кото-

рые показывают структуры v и w после вычисления этого выражения. Что будет напечатано в

качестве значений v и w?

Разделение данных и их идентичность

В разделе 3.1.3 мы упоминали теоретические вопросы «идентичности» и «изменения»,

которые возникают с появлением присваивания. Эти вопро сы начинают иметь практиче-

ское значение тогда, когда отдельные пары разделяются (are shared) между различными

объектами данных. Рассмотрим, например, структуру, которая создается таким кодом:

(define x (list ’a ’b))

(define z1 (cons x x))

3.3. Моде лирование при помощи изменяемых данных

247

Как показано на рис. 3.16, z1 представляет собой пару, в которой car и cdr указывают

на одну и ту же пару x. Разделение x между car и cdr пары z1 возникает оттого, что

cons реализован простейшим способом. В общем случае построение списков с помощью

cons приводит к возникновению сложносвязанной сети пар, в которой многие пары

разделяются между многими различными структурами.

В противоположность рис. 3.16, рис. 3.17 показывает структуру, которая порождается

кодом

(define z2 (cons (list ’a ’b) (list ’a ’b)))

В этой структуре пары двух списков (a b) различны, притом, что сами символы разде -

ляются

Если мы рассматриваем z1 и z2 как списки, они представляют «один и тот же»

список ((a b) a b). Вообще говоря, разде ление данн ых невозможно заметить, если

мы работаем со списками только при помощи операций cons, car и cdr. Однако если

мы вводим мутаторы, работающие со списковой структурой, разделение данных начинает

иметь значение. Как пример случая, когда разделение влияет на результат, рассмотрим

следующую процедуру, которая изменяет car структуры, к которой она применяется:

(define (set-to-wow! x)

(set-car! (car x) ’wow)

Несмотря на то, что z1 и z2 имеют «одинаковую» структуру, применение к ним проце-

дуры set-to-wow! дает различные результаты. В случае с z1 изменение car влияе т и

на cdr, поскольку здесь car и cdr — это одна и та же пара. В случае с z2, car и cdr

различны, так что set-to-wow! изменяет только car:

((a b) a b)

(set-to-wow! z1)

((wow b) wow b)

((a b) a b)

(set-to-wow! z2)

((wow b) a b)

Один из способов распознать разделение данных в списковых структурах — это вос-

пользоваться предик атом eq?, который мы ввели в разделе 2.3.1 как метод проверки

двух символов на равенство. В более общем случае (eq? x y) проверяет, являются

ли x и y одним объектом (то есть, равн ы ли x и y друг другу как указатели). Так что,

Пары различаются потому, что каждый вызов cons порождает новую пару. Символы разделяются; в

Scheme существует только один символ для каждого данного имен и. Поскольку Scheme не дает возможности

изменять символ, это разделение невозможно заметить. Заметим, кроме того, что именно разделение позволяет

нам сравнивать символы при помощи eq?, который просто проверяет равенство указателей.

248

Глава 3. Модульность, объекты и состояние

если z1 и z2 определены как на рисунках 3.16 и 3.17, (eq? (car z1) (cdr z1))

будет истинно, а (eq? (car z2) (cdr z2)) ложно.

Как будет видно в последующих разделах, с помощью разделения данных мы значи-

тельно расширим репертуар структур данных, которые могут быть представлены через

пары. С другой стороны, разделение сопряжено с риском, поскольку изменения в од-

них структурах могут затрагивать и другие структуры, разделяющие те части, которые

подвергаются изменению. Операции изменения set-car! и set-cdr! нужно использо-

вать осторожно; е сли у нас нет точного понимания, какие из наших объектов разделяют

дан ные, изменение может привести к неожиданным результатам

Упражнение 3.15.

Нарисуйте стрелочные диаграммы, объясняющие, как set-to-wow! действует на структуры z1

и z2 из этого раздела.

Упражнение 3.16.

Бен Битобор решил написать процедуру для подсчета числа пар в лю бой списковой структуре.

«Это легко, — думает он. — Число пар в любой структуре есть число пар в car плюс число пар в

cdr плюс один на текущую пару». И он пишет следующую процедуру:

(define (count-pairs x)

(if (not (pair? x))

(+ (count-pairs (car x))

(count-pairs (cdr x))

1)))

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

списковые структуры ровно из трех пар, для которых Бенова процедура вернет 3; вернет 4; вернет

7; вообще никогда не завершится.

Упражнение 3.17.

Напишите правильную версию процедуры count-pairs из упражнения 3.16, которая возвращает

число различных пар в любой структуре. (Подсказка: просматривайте структуру, поддерживая при

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

Упражнение 3.18.

Напишите процедуру, которая рассматривает список и определяет, содержится ли в нем цикл, то

есть, не войдет ли программа, которая попытается добраться до конца списка, продвигаясь по

полям cdr, в бесконечный цикл. Такие списки порождались в упражнении 3.13.

Тонкости работы с разделением изменяемых данных отражают сложности с понятием «идентичности» и

«изменения», о которых мы говорили в разделе 3.1.3. Там мы отметили, что введение в наш язык поня-

тия изменения требует, чтобы у составного объекта была «индивидуальность», которая представляет собой

нечто отличное от частей, из которых он состоит. В Лиспе мы считаем, что именно эта «индивидуальность»

проверяется предикатом eq?, то есть сравнением указателей . Поскольку в большинстве реализаций Лиспа

указатель — это, в сущности , адрес в памяти, мы «решаем проблему» определения индивидуальности объ-

ектов, постановив, что «сам» объект данных есть информация, хранимая в некотором наборе ячеек памяти

компьютера. Для простых лисповских программ этого достаточно, но такой метод не способен разрешить

общий вопрос «идентичности» в вычислительных моделях.

3.3. Моде лирование при помощи изменяемых данных

249

Упражнение 3.19.

Переделайте упражнение 3.18, используя фиксированное количество памяти. (Тут нужна доста-

точно хитрая идея.)

Изменение как присваивание

Когда мы вводили понятие составных данных, в разделе 2.1.3 мы заметили, что пары

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

(define (cons x y)

(define (dispatch m)

(cond ((eq? m ’car) x)

((eq? m ’cdr) y)

(else (error "Неопределенная операция -- CONS" m))))

dispatch)

(define (car z) (z ’car))

(define (cdr z) (z ’cdr))

То же наблюдение верно и для изменяемых данных. Изменяемые объекты данных мож-

но реал изовать при помощи процедур и внутреннего состояния. Например, можно рас-

ширить приведенную реализацию пар, так, чтобы set-car! и set-cdr! обрабаты-

вались по аналогии с реализацией банковских счетов через make-account из разде-

ла 3.1.1:

(define (cons x y)

(define (set-x! v) (set! x v))

(define (set-y! v) (set! y v))

(define (dispatch m)

(cond ((eq? m ’car) x)

((eq? m ’cdr) y)

((eq? m ’set-car!) set-x!)

((eq? m ’set-cdr!) set-y!)

(else (error "Неопределенная операция -- CONS" m))))

dispatch)

(define (car z) (z ’car))

(define (cdr z) (z ’cdr))

(define (set-car! z new-value)

((z ’set-car!) new-value)

(define (set-cdr! z new-value)

((z ’set-cdr!) new-value)

250

Глава 3. Модульность, объекты и состояние

Операция Результат

(define q (make-queue)

(insert-queue! q ’a) a

(insert-queue! q ’b) a b

(delete-queue! q) b

(insert-queue! q ’c) b c

(insert-queue! q ’d) b c d

(delete-queue! q) c d

Рис. 3.18. Операции над очередью.

Теоретически, чтобы описать поведение изменяемых данных, не требуется ничего,

кроме присваивания. Как только мы вводим в наш язык set!, мы сталкиваемся со всеми

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

Упражнение 3.20.

Нарисуйте диаграммы окружений, изображающие выполнение последовательно с ти выражений

(define x (cons 1 2))

(define z (cons x x))

(set-car! (cdr z) 17)

(car x)

с помощью вышеприведенной процедурной реализации пар. (Ср. с упражнением 3.11.)

3.3.2. Представление очередей

Мутаторы set-car! и set-cdr! позволяют нам строить из пар такие структуры,

какие мы не смогли бы создать только при помощи cons, car и cdr. В э том разде-

ле будет показано, как представить структуру данных, которая называется очередь. В

разделе 3.3.3 мы увидим, как реализовать структуру, называемую табл ицей.

Очередь (queue) представляет собой последовательность, в которую можно добавля ть

элементы с одного конца (он называется хвостом (rear)) и убирать с другого (он назы-

вается головой (front)). На рисунке 3.18 изображено, как в изначально пустую очередь

добавляются элементы a и b. Затем a убирается из очереди, в нее добавляются c и d,

потом удаляется b. Поскольку элементы удаляются всегда в том же порядке, в котором

они были добавлены, иногда очередь называют буфером FIFO (англ. ﬁrst in, ﬁrst out —

первым вошел, первым вышел).

С точки зрения абстракции данных, можно считать, что очередь определяется следу-

ющим набором операций:

С другой стороны, с точки зрения реализации, присваивание требует модификации окружения, которое

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

обладают равной мощностью: каждое из них можно реализовать при помощи другого.