Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Стили и методы программирования. Учебное пособие для СПО
.pdf
break;
default: return;
}
}
}
Листинг 10.2.3. Длины слов: использование процедур для
описания состояний.
Следует обратить внимание на то, что программа наглядна, строго
соответствует таблице автомата. Можно сказать, что граф автомата
определяет распределенную по состояниям схему потоковой обработки.
На самом деле она гораздо лучше подходит модели вычислений в
состояниях, а не на переходах. Более того, эта программа при
небольшом увеличении числа состояний быстро теряет наглядность,
если программировать на переходах, поскольку следующие состояния
упрятаны внутри соответствующих процедур, но сохранит ее, если
программировать в состояниях.
Таким образом, мы пришли к тому, что в рамках стандартной методики
программирования все решения имеют некоторые недостатки. Надо
искать другое, и здесь стоит вспомнить пословицу (на самом деле
отражающую один из приемов творческого мышления): "Новое - хорошо
забытое старое". Поищем решение среди того, что забраковано
стандартными методиками.
Проанализировав граф автомата или таблицу, можно заметить, что в
данном примере, наряду с циклом потоковой обработки, имеется еще
один цикл: передача управления между состояниями. Это причина, изза которой в двух предыдущих вариантах появились присваивание
переменной State значения и выбор выполняемого фрагмента по этому
значению.
Особенность последовательностей действий
State = <значение>;
switch ( State )
которая выполняется всякий раз в конце действий, ассоциированных с
Стили и методы программированияНепейвода Н.Н.
171
состояниями (точнее - реализаций действий в программах), в том, что в
каждой точке программы, где встречается данное присваивание, можно
точно указать результат динамически следующего оператора
переключения, причем эта информация не зависит от обрабатываемого
потока и может быть определена до вычислений статически.
А нельзя ли использовать это явно для организации управления
конечным автоматом? Можно, это демонстрирует четвертый вариант
решения обсуждаемой задачи.
Вариант 4. Матрица переходов и вектор-функций, соответствующих
состояниям
4)
program funcgoto;
{$APPTYPE CONSOLE} {$T+}
uses SysUtils;
type P=procedure;
type Pp= ^P;
const maxstate = 7;
const maxcond = 3;
type states = 1.. maxstate;
conds = 1.. maxcond;
type table = array [states, conds] of states;
type act = array [states] of P;
const gotos: table = ((2,2,2),(3,2,4),(3,5,6),(3,2,7),(3,2,4),(3,2,7),(1,1,1));
var Symbol: char;
var Cnt: integer;
var Inf, Outf: text;
var state: states;
procedure Start;
begin
Cnt:=0;
AssignFile(Inf, 'input.txt');
Reset(Inf);
AssignFile(Outf, 'output.txt');
Rewrite(Outf);
end;
Стили и методы программированияНепейвода Н.Н.
172
procedure Finish;
begin
Closefile(Inf);
Closefile(Outf);
Abort;
end;
procedure St1;
begin
{No actions}
end;
procedure St2;
begin
write(outf,Symbol);
Inc(Cnt);
end;
procedure St4;
begin
writeln(outf,' - ',Cnt);
Cnt:=0;
end;
const actions: act = (Start, St1,St2,St1,St4,St4,Finish);
begin
state:=1;
while true do begin
actions[state];
if (state <>1) and (state<>7) then begin read(inf,Symbol);
if Ord(Symbol)=10 then read(inf,Symbol) end;
if Symbol in ['a'..'z'] then state:= gotos[state,1];
if not(Symbol in ['a'..'z']) and (Ord(Symbol)<>13)
then state:=gotos[state,2];
if Ord(Symbol)=13 then state:=gotos[state,3];
end;
end.
Стили и методы программированияНепейвода Н.Н.
173
Листинг 10.2.4. Длины слов: массив функций и переходов
Это решение неплохое, но оно годится лишь для вычислений в
состояниях. Фактически оно резко расходится с канонами структурного
программирования, где даже не предполагалось переключение между
функциями внутри массива функций. Оно несколько утяжелено
деталями, связанными с отработкой особых состояний ввода входного
потока. Зато повторяющиеся действия не дублируются.
Рассмотрим последний вариант.
Вариант 5. Использование статической информации о разветвлениях
вычислений.
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
char symbol;
int cnt;
void main( void )
{
symbol = getchar ();
St1: if ('a'<=symbol && symbol <= 'z') {
printf ("%c", symbol);
cnt = 1;
symbol = getchar (); goto St2;
}
else if (symbol != '\n') {
symbol = getchar (); goto St1;
}
else /* (symbol == '\n') */ {symbol = getchar (); goto St3;};
St2: if ('a'<=symbol && symbol <= 'z') {
printf ("%c", symbol);
cnt++;
symbol = getchar (); goto St2;
}
else if (symbol != '\n') {
printf (" -%i\n", cnt);
symbol = getchar (); goto St1;
Стили и методы программированияНепейвода Н.Н.
174
}
else {
printf (" -%i\n", cnt);
symbol = getchar (); goto St3;
};
St3: if ('a'<=symbol && symbol <= 'z') {
printf ("%c", symbol);
cnt = 1;
symbol = getchar (); goto St2;
}
else if (symbol != '\n') {
symbol = getchar (); goto St1;
}
else /* (symbol == '\n') */ return;
}
Листинг 10.2.5. Длины слов: состояния - метки в программе.
В данном варианте исчезает необходимость вычисляемого перехода
(результат внедрения статической информации в текст программы), и,
как следствие, становятся избыточными описания типа States и
переменной State этого типа. В программе появляются операторы
безусловного перехода, из-за этого структура управления программы
полностью расходится с канонами структурного программирования, что
дает повод догматически мыслящим программистам и теоретикам
подвергать критике такой вариант программы. Но в данном случае
отступление от канонов структурного программирования полностью
оправдано, поскольку за счет специального расположения фрагментов
текста вся программа оказалась похожа на таблицу конечного автомата,
а структура передач управления копирует граф конечного автомата.
Более того, такое представление нейтрально по отношению к моделям
Мура и Мили. Таким образом, лишь после полного отхода от канонов
структурности программа стала адекватна своей спецификации.
Автоматизированное преобразование таблиц переходов
Если автоматизировать работу с табличным представлением, то прежде
всего требуется строго определить структуру данных, представляющих
таблицу переходов. Способ задания таблицы зависит от стратегии
Стили и методы программированияНепейвода Н.Н.
175
дальнейшей обработки. В частности, если вручную строится текстовое
представление таблицы, которое в дальнейшем преобразуется к
исполняемому виду, то приемлемо, например, такое представление.
_1 char symbol; // Чтение потока символов неявное
int cnt;
. . . // Инициализация _4 St1 _5
_1 St1 _2 'a'<=symbol && symbol <= 'z' _3 printf ("%c", symbol);
cnt = 1; _4 St2 _5
_1 _2 //symbol <'a' && 'z'< symbol && symbol != '\n'
_3
//Так как нужно печатать только слова,
//действий нет _4 St1 _5
_1 _2 failure _3
// symbol == '\n' не нужно читать _4 St3 _5
_1 St2 _2 'a'<=symbol && symbol <= 'z' _3 printf ("%c", symbol);
cnt++; _4 St2 _5
_1 _2 //(symbol <'a'||'z'< symbol)&&*/ symbol!='\n'
_3 printf (" - %i\n", Cnt); _4 St1 _5
_1 _2 failure _3 printf (" - %i\n", Cnt); _4 St3 _5
_1 St3 _2 'a'<=symbol && symbol <= 'z' _3 printf ("%c", symbol);
cnt = 1; _4 St2 _5
_1 _2 //symbol <'a' && 'z'< symbol && symbol != '\n'
_3
//Так как нужно печатать только слова,
//действий нет _4 St1 _5
_1 _2 failure _3
// symbol == '\n' не нужно читать _4 exit_5
_1 exit_2 // условие истина, но без неявного чтения потока
_3 return 0; _4 _5
Листинг 10.3.1. Программа в виде размеченного текста.
Здесь <_i>, i = 1, . . . , 5 обозначают позиции таблицы.
Эти сочетания символов, нигде в обычной программе не
встречающиеся, легко могут распознаваться препроцессором.
Размещаемые между ними последовательности символов разносятся по
соответствующим полям нужной структуры, которая, в зависимости от
выбранной стратегии, интерпретируется либо транслируется. С
Стили и методы программированияНепейвода Н.Н.
176
помощью этих сочетаний осуществляется разметка текста, которая дает
возможность распознавать и осмысливать его фрагменты. Стоит
обратить внимание на то, что за счет специального взаимного
расположения символов в данном тексте представляемая им таблица
автомата вполне обозрима. Если нет более подходящего представления,
то данную структуру можно рекомендовать для ввода.
Однако непосредственная интерпретация универсального текстового
размеченного представления довольно затруднительна.
Предпочтительнее, чтобы единицами интерпретации были бы сами
поля таблицы. Вообще, этому противоречит наличие в таблице полей,
значения которых - фрагменты исполняемого кода на языке
программирования (такая запись удобна для человека, так как для
заполнения таблицы не приходится прибегать ни к каким
дополнительным соглашениям). На самом деле противоречие возникает
только для поля действий, поскольку последовательности символов
между <_2> и <_3> имеют ясно выраженную семантику: это проверка
условия. Если всегда рассматривать условия как проверку того, чему
равен входной символ, то вполне понятны, легко задаются,
распознаются и интерпретируются специальные обозначения:
перечисления значений, их диапазоны и т.д. Трактовка этих
обозначений не вызывает осложнений, а потому подобные приемы
кодирования применяются довольно часто.
Если говорить о полях действий, то их представление для большинства
языков программирования плохо разработано. Данное обстоятельство
препятствует использованию автоматного программирования:
кодирование действий усложняет обработку. Но если в языке можно
задавать подпрограммы как данные, то описание структуры таблицы,
которое будет согласовано с дальнейшей трансляцией или
интерпретацией, возможно, в частности, в языках функционального
программирования (семейство LISP и ML) и в языке Prolog. Но
функциональное и сентенциальное программирование хорошо
интерпретируют лишь частные случаи таблиц.
Пусть тип T_StructTableLine описывает структуру одной строки
таблицы, а вся таблица представлена в виде массива Table таких
структур. Пусть далее iSt - переменная, используемая для
индексирования массива Table, некоторые из ее значений
Стили и методы программированияНепейвода Н.Н.
177
представляют состояния конечного автомата (но не все, а только те, к
которым определен переход!). Наконец, пусть
int handler ( int );
-обработчик строки (ее интерпретатор или транслятор),
<понимающий> структуру T_StructTableLine, специфицируемый
как функция, при выполнении которой должно быть определено
очередное значение iSt. Значение iSt, не указывающее ни на какую
строку таблицы, служит сигналом для завершения обработки (при
желании можно заняться кодированием того, как завершилась обработка
с помощью задания различных таких значений).
Тогда схема программы, которая оперирует с таблицей с помощью
функции handler, может быть задана следующим циклом:
iSt = 0;
do {
iSt = handler ( iSt );
}
while ( OUTSIDE ( iSt ) );
Понятно, что выбор массива в качестве представления автомата
непринципиален. Допустимо, а иногда и предпочтительнее, работать со
списком строк. Также непринципиален способ вычисления предиката
OUTSIDE, проверяющего условие окончания цикла, хотя он и зависит
от выбранного представления автомата. Возможность не рассматривать
явно имена состояний, напротив, принципиальна: тот факт, что строки
таблицы сгруппированы вокруг (поименованных) состояний, ничего не
значит ни для обработки, ни для интерпретации, поскольку у конечного
автомата следующее состояние всегда определяется явно.
Логика функции handler, интерпретирующей таблицу, проста. Для
правильной таблицы, не содержащей состояний, в которых возможны
неопределенные переходы, она строится следующим образом:
1. Извлечь значение Table[iSt] ;
2. Активизировать вычисление условия обрабатываемой строки
таблицы;
Стили и методы программированияНепейвода Н.Н.
178
3. Если условие истинно, то
активизировать подпрограмму действий;
читать очередной символ;
завершить handler со значением, извлекаемым из поля
следующего состояния;
4. Если условие ложно, то
iSt++ ;
Перейти к 1;
Осталось предусмотреть детали для заключительных состояний, но это
сделать уже легко.
Таким образом, нужно научиться описывать структуру строки таблицы.
На языке C++/С# эта задача может решаться довольно просто:
struct T_StructTableLine
{
// поле для имени состояния избыточно
int (*condition)(); // поле условия
void (*action)(); // поле действия
int ref;
// поле перехода: индекс строки таблицы,
// которая будет обрабатываться следующей,
// или признак завершения процесса
}
Сама таблица описывается следующим образом:
T_StructTableLine Table[]
или
T_StructTableLine Table [Размер таблицы]
если значения строк задаются вне этого описания.
Однако сразу же видно ограничивающее соглашение, которое пришлось
принять в связи с особенностями языка реализации: все условия и все
действия оформлены как функции, тогда как задача, по своей сути, этого
не требует. Более того, отделенное от таблицы описание функций,
Стили и методы программированияНепейвода Н.Н.
179
предписываемое языком С++/C#, резко снижает выразительность
представления:
int Cond_St1_1() - условие в Table[1]
и
void Act_St1_1() - действие в Table[1] (строка 1 состояния
St1 );
int Cond_St1_2() - условие в Table[2]
и
void Act_St1_2() - действие в Table[2] (строка 2 состояния
St1 );
и т. д.
Еще один неприятный момент данного представления - невозможность
единообразно с действиями представить их общий контекст (нулевая
строка таблицы), а поскольку инициализацию естественно
рассматривать как задание предварительных действий, готовящих
собственно обработку, то ее предпочтительнее соединять с контекстом,
а не с функциями, реализующими проверки и действия.
Последний недостаток неустраним ни в каком языке, если проверки и
действия трактовать как процедуры, которые работают в общем
контексте, задаваемом в заголовке таблицы. Так что лучше сразу
отказаться от описания этого контекста в рамках таблицы (задание
инициализации в ней возможно). Что касается первого недостатка, то
он носит почти синтаксический характер, и если бы можно было
задавать тела процедур как значения полей структур, то наглядность
представления можно было бы сохранить. В языковом оформлении,
похожем на С/С++/C#, это выглядело бы как следующее присваивание
значения Table в качестве инициализации.
Table[]= {
{{return true;}, /* инициализация */, 1},
/*St1*/{{return 'a'<=symbol &&
Стили и методы программированияНепейвода Н.Н.
180
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]