WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 || 3 | 4 |   ...   | 6 |

«Практика программирования Б. Керниган, Р. Пайк Книга: ...»

-- [ Страница 2 ] --

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

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

Фланговый порядок (in-order) обхода выполняет операцию в данной вершине после просмотра ее левого поддерева и перед просмотром правого:

/* applyinorder: применение функции fn во время обхода дерева во фланговом порядке */ void applyinorder(Nameval *treep, void (*fn)(Nameval*, void*), void *arg) { if (treep == NULL) return;

applyinorder(treep->left, fn, arg);

(*fn)(treep, arg);

applyinorder(treep->right, fn, arg);

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

applyinorder(treep, printnv, "%s: %x\n");

Сразу намечается вариант сортировки: вставляем элементы в дерево, выделяем память под массив соответствующего размера, а затем используем фланговый обход для последовательного размещения их в массиве. Восходящий порядок (post order) обхода вызывает операцию для данной вершины после просмотра вершин детей:

* applypostorder: применение функции fn во время обхода дерева в восходящем порядке */ void applypostorder(Nameval *treep, void (*fn)(Nameval*, void*), void *arg) { if (treep == NULL) return;

applypostorder(treep->left, fn, arg);

applypostorder(treep->right, fn, arg);

(*fn)(treep, arg);

} Восходящий порядок применяется, когда операция для вершины зависит от поддеревьев. Примерами служат вычисление высоты дерева (взять максимум из высот двух поддеревьев и добавить единицу), обработка дерева в графическом пакете (выделить место на странице для каждого поддерева и объединить их в области для данной вершины), а также вычисление общего занимаемого места.

Нисходящий порядок (pre-order) используется редко, так что мы не будем его рассматривать.

На самом деле деревья двоичного поиска применяются редко, хотя В-деревья, обычно сильно разветвленные, используются для хранения информации на внешних носителях. В каждодневном программировании деревья часто используются для представления структур действий и выражений. Например, действие mid = (low + high) / 2;

может быть представлено в виде дерева синтаксического разбора (parse tree), показанного на рисунке ниже. Для вычисления значения дерева нужно обойти его в восходящем порядке и выполнить в каждой вершине соответствующее действие.

Более детально мы будем рассматривать деревья синтаксического разбора в главе 9.

Упражнение 2- Сравните быстродействие lookup и nrlookup. Насколько рекурсия медленнее итеративной версии?

Упражнение 2- Используйте фланговый обход для создания процедуры сортировки. Какова ее временная сложность? При каких условиях она может работать медленно? Как ее производительность соотносится с нашей процедурой quicksort и с библиотечной версией?

Упражнение 2- Придумайте и реализуйте набор тестов, удостоверяющих, что процедуры работы с деревьями корректны.

Хэш-таблицы Хэш-таблицы (hash tables) — одно из величайших изобретений информатики.

Сочетание массивов и списков с небольшой добавкой математики позволило создать эффективную структуру для хранения и* получения динамических данных.

Типичное применение хэш-таблиц -символьная таблица, которая ассоциирует некоторое значение (данные) с каждым членом динамического набора строк (ключей). Ваш любимый компилятор практически наверняка использует хэш-таблицу для управления информацией о переменных в вашей программе. Ваш web-браузер наверняка использует хэш-таблицу для хранения адресов страниц, которые вы недавно посещали, а при соединении вашего компьютера с Интернетом, вероятно, она применяется для оперативного хранения (cache — кэширования) недавно использованных доменных имен и их IP-адресов.

Идея состоит в том, чтобы пропустить ключ через хэш-функцию (hash function) для получения хэш-значения (hash value), которое было бы равномерно распределено по диапазону целых чисел приемлемого размера. Это хэш-значение используется как индекс в таблице, где хранится информация. Java предоставляет стандартный интерфейс к хэш-таб-лицам. В С и C++ обычно с каждым хэш-значением (или "bucket" -"корзиной") ассоциируется список элементов, которые обладают этим значением, как показано на следующем рисунке:

На практике хэш-функция предопределена, а массив соответствующего размера выделяется нередко даже во время компиляции. Каждый элемент массива — это список, который сцепляет вместе элементы, имеющие общее хэш-значение. Другими словами, хэш-таблица из п элементов — это массив списков, средняя длина которых равна п/'(размер_массива). Получение элемента является константной (О(1)) операцией, если мы взяли хорошую хэш-функцию и списки не становятся слишком большими.

Поскольку хэш-таблица — массив списков, то тип элементов для нее такой же, как и для списка:

typedef struct Nameval Nameval;

struct Nameval { char *name;

int value;

Nameval *next;

/* следующий в цепи */ };

Nameval *symtab[NHASH];

/* таблица символов */ Способы работы со списками из раздела 2.7 можно использовать для управления отдельными хэш-цепочками. Как только у вас есть хорошая хэш-функция, все становится легко: получаете цепочку и дальше спокойно проходите вдоль списка, ища подходящий элемент. Приведем текст процедуры поиска/вставки в хэш-таблицу.

Если элемент найден, то он возвращается. Если элемент не найден и задан флаг создания create, то lookup добавляет элемент в таблицу. Копия имени символа не создается — считается, что вызывающая сторона сама сделала себе надежную копию.

/* lookup: поиск имени в таблице;

возможна вставка */ Nameval* lookup (char *name, int create, int value) { int h;

Nameval *sym;

h = hash(name);

for (sym =-symtab[h];

sym != NULL;

sym = sym->next) if (strcmp(name, sym->name) == 0) return sym;

if (create) { sym = (Nameval *) emalloc(sizeof(Nameval));

sym->name = name;

/* считаем, что память уже выделена */ sym->value = value;

sym->next = symtab[h];

symtab[h] = sym;

} return sym;

} Поиск и возможная вставка комбинируются часто. Иначе приходится прилагать лишние усилия. Если писать if (lookup("name") == NULL) additem(newitem("name", value));

то хэш-функция вычисляется дважды.

Насколько большим должен быть массив? Основная идея заключается в том, что он должен быть достаточно большим, чтобы любая хэш-цепочка была бы длиной всего в несколько элементов и поиск занимал время О(1). Например, у компилятора размер массива должен быть порядка нескольких тысяч, так как в большом исходном файле — несколько тысяч строчек и вряд ли различных идентификаторов имеется больше, чем по одному на строчку кода.

Теперь нам нужно решить, что же наша хэш-функция, hash, будет вычислять. Она должна быть детерминированной, достаточно быстрой и распределять данные по массиву равномерно. Один из наиболее распространенных алгоритмов хэширования для строк получает хэш-значение, добавляя каждый байт строки к произведению предыдущего значения на некий фиксированный множитель (хэш). Умножение распределяет биты из нового байта по всему до сих пор не считанному значению, так что в конце цикла мы получим хорошую смесь входных байтов. Эмпирически установлено, что значения 31 и 37 являются хорошими множителями в хэш-функции для строк ASCII.

enum { MULTIPLIER = 31 };

/* hash: вычислить хэш-функцию строки */ unsigned int hash(char *str) { unsigned int h;

unsigned char *p;

h = 0;

for (p = (unsigned char *) str;

*p != '\0';

p++) h = MULTIPLIER * h + *p;

return h % NHASH;

} В вычислениях символы принимаются неотрицательными принудительно (тем, что используется тип unsigned char), так как ни в С, ни в C++ наличие знака у символов не регламентировано, а мы хотим, чтобы наша хэш-функция оставалась положительной.

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

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

Эксперименты показывают, что для большого числа разных строк трудно придумать хэш-функцию, которая работала бы гораздо лучше, чем эта, зато легко придумать такую, которая работает хуже. В ранних версиях Java была хэш-функция для строк, работавшая более эффективно, если строка была длинной. Хэш-функция работала быстрее, анализируя только 8 или 9 символов через равные интервалы в строках длиннее, чем 16 символов, начиная с первого символа. К сожалению, хотя хэш функция работала быстрее, у нее были очень плохие статистические показатели, что сводило на нет выигрыш в производительности. Пропуская части строки, она нередко выкидывала именно различающиеся части строк. Имена файлов начинаются с длинных идентичных префиксов — имен каталогов — и могут отличаться только несколькими последними символами (например,.Java и.class).

Адреса в Internet обычно начинаются с http://www. и заканчиваются на. html, поэтому все различия у них в середине. Хэш-функция частенько проходила только по неразличающейся части в имени, в результате чего образовывались более длинные хэш-цепочки, что замедляло поиск. Проблема была решена заменой хэш-функции на эквивалентную той, что мы привели выше (с мультипликатором 37), которая исследует каждый символ в строке.

Хэш-функция, которая неплохо подходит для одного набора данных (например, имен переменных), может плохо подходить для другого (адреса Internet), так что потенциальная хэш-функция должна быть протестирована на разных наборах типичных входных данных. Хорошо ли она перемешивает короткие строки? Длинные строки? Строки одинаковой длины с небольшими изменениями?

Хэшировать можно не только строки. Можно "смешать" три координаты частицы при физическом моделировании, тем самым уменьшив размер хранилища до линейной таблицы (0(количество точек)) вместо трехмерного массива (0(размер_по_х хразмер_nojj X размер_no_z)).

Один примечательный случай использования хэширования — программа Джерарда Холзманна (Gerard Holzmann) для анализа протоколов и параллельных систем Supertrace. Supertrace берет полную информацию о каждом возможном состоянии наблюдаемой системы и хэширует эту информацию для получения адреса единственного бита в памяти. Если этот бит установлен, то данное состояние наблюдалось и раньше;

если нет, то не наблюдалось. В Supertrace используется хэш-таблица длиной во много мегабайт, однако в каждой ячейке хранится только один бит. Цепочки не строятся;

если два разных состояния совпали по своей хэш функции, то программа этого не заметит. Supertrace рассчитана на то, что вероятность коллизии мала (она не обязана быть нулем, поскольку Supertrace использует вероятностные, а не детерминированные вычисления). Поэтому хэш функция здесь очень аккуратна;

она использует циклический избыточный код (cyclic redundancy check — CRC) — функцию, которая тщательно перемешивает данные.

Хэш-таблицы незаменимы для символьных таблиц, поскольку они предоставляют (почти всегда) доступ к каждому элементу за константное время. У них есть свои ограничения. Если хэш-функция плоха или размер массива слишком мал, то списки могут стать достаточно длинными. Поскольку списки не отсортированы, это приведет к линейному доступу (0(и)). Элементы нельзя напрямую получить в отсортированном виде, однако их легко подсчитать, выделить память под массив, заполнить его указателями на элементы и отсортировать их. Что и говорить, константное время операций поиска, вставка и удаление — это такое свойство хэш-таблицы, которого не достичь никакими другими технологиями.

Упражнение 2- Наша хэш-функция замечательна для повседневного хэширования строк. Однако на нарочно придуманных данных она может работать плохо. Сконструируйте набор данных, приводящий к плохому поведению нашей хэш-функции. Проще ли найти плохой набор для других значений NHASH?

Упражнение 2- Напишите функцию для доступа к последовательным элементам хэш-таблицы в несортированном порядке.

Упражнение 2- Измените функцию lookup так, что если средняя длина списка превысит некое значение х, то массив автоматически расширяется в у раз и хэш-таблица перестраивается.

Упражнение 2- Спроектируйте кэш-функцию для хранения координат точек в двумерном пространстве. Насколько легко ваша функция адаптируется к изменениям в типе координат, например при переходе от целого типа данных к значениям с плавающей точкой, или при переходе от декартовой к полярной системе координат, или при увеличении количества измерений?

Заключение При выборе алгоритма нужно сделать несколько шагов. Во-первых, следует изучить существующие алгоритмы и структуры данных. Подумайте, какой объем данных может обработать программа. Если задача предполагает скромные размеры данных, то выбирайте простые технологии;

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

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

У каждой операции есть ожидаемое время выполнения, которое часто определяет, насколько выбранный тип данных или его реализация подходит для конкретного приложения. Массивы предоставляют доступ к элементам за константное время, но зато плохо изменяют свои размер;

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

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

Есть еще множество изощренных структур данных для специальных задач, однако этот базовый набор вполне достаточен для написания подавляющего большинства программ Дополнительная литература Серия книг "Алгоритмы" Боба Седжвика (Bob Sedgewick. Algorithms. Addison-Wesley) содержит доступные сведения о большом числе полезных алгоритмов. В третьем издании "Алгоритмов на C++" (Algorithms in C++, 1998) идет неплохое обсуждение хэш-функций и размеров хэш-таблиц. "Искусство программирования" Дона Кнута (Don Knuth. The Art of Computer Programming. Addison-Wesley) — первейший источник для строгого анализа многих алгоритмов;

в третьем томе (2nd ed., 19981) рассматриваются поиск и сортировка.

Программа Supertrace описана в книге Джерарда Холзманна "Дизайн и проверка протоколов" (Gerard Holzmann. Design and Validation of Computer Protocols. Prentice Hall, 1991).

Ион Бентли и Дуг Мак-Илрой описывают создание скоростной и устойчивой версии быстрой сортировки в статье "Конструирование функции сортировки" (Jon Bentley, Doug Mcllroy. Engineering a sort function. Software - Practice and Experience, 23, 1, p.

1249-1265, 1993).

Проектирование и реализация • Алгоритм цепей Маркова • Варианты структуры данных • Создание структуры данных в языке С • Генерация вывода • Java • C++ • Awk и Perl • Производительность • Уроки • Дополнительная литература Покажите мне свои блок-схемы и спрячьте таблицы, и я ничего не пойму. Покажите мне таблицы, и блок-схемы мне не понадобятся — все будет очевидно и так.

Фредерик П. Брукс-мл. Мифический человекомесяц Согласно приведенной цитате из классической книги Брукса, проектирование структур данных — центральный момент в создании программы. После того как структуры данных определены, алгоритмы, как правило, стремятся сами встать на свое место, и кодирование становится относительно простым делом.

Это, конечно, слишком упрощенный, но тем не менее верный взгляд. В предыдущей главе мы разобрали основные структуры данных;

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

Одним из аспектов этой точки зрения является то, что выбор конкретного языка программирования оказывается сравнительно неважным для общего проектирования. Мы сначала спроектируем программу абстрактно, а потом реализуем ее на С, Java, C++, Awk и Perl. Сравнив реализации, мы увидим, как тот или иной язык может облегчать или, наоборот, затруднять кодирование и в каких аспектах выбор языка не является важным. Выбранный для реализации язык может, конечно, чем-то украсить программу, но не доминирует в ее разработке.

Проблема, которую мы будем решать, необычна, однако в общем виде она типична для большинства программ: некие данные поступают в программу, некие данные программа выдает на выходе, а обработка данных требует некоторого мастерства.

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

Программа, случайным образом выбирающая буквы (и пробелы — для разделения "слов"), выдавала бы что-нибудь вроде xptmxgn xusaja afqnzgxl Ihidlwcd rjdjuvpydrlwnjy что, естественно, не слишком нас устраивает. Если присвоить буквам вес, соответствующий частоте их появления в нормальном тексте, мы получим что нибудь такое:

idtefoae tcs trder jcii ofdslnqetacp t ola что звучит не лучше. Набор слов, выбранных случайным образом из словаря, тоже не будет иметь особого смысла:

polydactyl equatorial splashily jowl verandah circumscribe Для того чтобы получить более сносный результат, нам нужна статистическая модель с более утонченной структурой. Например, можно рассматривать частоту вхождения целых фраз. Но где нам взять такую статистику?

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

Алгоритм цепей Маркова Элегантный способ выполнить подобную обработку - использовать технику, известную как алгоритм цепей Маркова. Ввод можно представить себе как последовательность перекрывающихся фраз;

алгоритм разделяет каждую фразу на две части: префикс, состоящий из нескольких слов, и следующее за ним слово — суффикс (или окончание). Алгоритм цепей Маркова создает выходные фразы, выбирая случайным образом суффикс, следующий за префиксом;

все это в соответствии со статистикой текста-оригинала (в нашем случае). Хорошо выглядят фразы из трех слов, когда префикс из двух слов используется для подбора слова суффикса:

присвоить w, и w2 значения двух первых слов текста печатать W-, и w цикл:

случайным образом выбрать w3 из слов, следующих за префиксом w, w2 в тексте печатать w заменить да/ и w2 на w2 и w-s повторить цикл Для иллюстрации сгенерируем случайный текст, основываясь на нескольких предложениях из эпиграфа к этой главе и используя префикс из двух слов:

Show your flowcharts and conceal your tables and I will be mystified.

Show your tables and your flowcharts will be obvious, (end) Вот несколько пар слов, взятых из этого отрывка, и слова, которые следуют за ними:

Префикс Show your your flowcharts flowcharts and flowcharts will your tables will be be mystified be obvious Подходящие суффиксы flowcharts tables and will conceal be and and mystified, obvious.

Show (end) Обработка этого текста по предлагаемому алгоритму markov' начинается с того, что будет напечатано Show your, после чего случайным образом будет выбрано или flowcharts, или tables. Если будет выбрано первое слово, то текущим префиксом станет your flowcharts, а следующим словом будет выбрано and или will. Если же выбранным окажется tables, то после него последует слово and. Так будет продолжаться до тех пор, пока не будет сгенерирована фраза заданного размера или в качестве суффикса не будет выбрано слово-метка конца ввода (end).

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

сохраняется стиль прототипа и привносится достаточно своеобразия.

Что такое слово? Очевидный ответ — последовательность символов алфавита, однако нам было бы желательно сохранить и пунктуационные различия, то есть различать "words" и "words.". Приписывание знаков препинания к словам повышает качество генерируемого текста, вводя в него пунктуацию, а следовательно (косвенным образом), и грамматику, влияет на выбор слов;

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

Исходя из выбранного метода можно сказать, что все слова, фразы из двух слов и фразы из трех слов должны присутствовать во вводимом тексте, но появятся новые фразы из четырех и более слов. Ниже приведены несколько предложений, сгенерированных программой, разработке которой посвящена данная глава, полученных на основе текста седьмой главы книги "И восходит солнце" Эрнеста Хемингуэя:

As I started up the undershirt onto his chest black, and big stomach muscles bulging under the light. "You see them?" Below the line where his ribs stopped were two raised whate welts.

"See on the forehead.""Oh, Brett, I love you.""Let's not talk. Talking's all bailge. I'm going away tomorrow"."Tomorrow?""Yes. Didn't I say so?I am". " Let's have a drink, them."

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

Варианты структуры данных На какой размер вводимого текста мы должны рассчитывать? Насколько быстро должна работать программа? Представляется логичным, чтобы программа была в состоянии считать целую книгу, так что нам надо быть готовыми к размеру ввода в п = 100 000 слов и более. Вывод должен составлять сотни, а возможно, и тысячи слов, а работать программа должна несколько секунд, но отнюдь не минут. Имея 100 слов вводимого текста, надо признать, что п получается достаточно большим, так что для того, чтобы программа работала действительно быстро, алгоритм придется писать довольно сложный.

Для того чтобы начать генерировать текст, алгоритм markov должен сначала просмотреть весе введенный фрагмент, поэтому исходный текст нам придется каким-то образом сохранять. Первая возможность — ввести полностью исходный текст и сохранить его как длинную строку, но нам явно нужно разбить его на отдельные слова. Если сохранить его как массив указателей на слова, генерация вывода будет происходить просто: для выбора нового слова надо просканировать введенный текст и посмотреть, какие существуют слова-суффиксы для только что введенного префикса, и выбрать из них случайным образом одно. Однако это будет означать сканирование всех 100 000 слов ввода для генерации каждого нового слова;

при размере выводимого текста в 1000 слов необходимо осуществить сотни миллионов сравнений строк, а это вовсе не быстро.

Другая возможность — хранить только уникальные слова исходного текста вместе со списком, указывающим, где именно они появлялись в оригинале. В этом случае мы сможем находить устраивающие нас слова более быстро. Мы могли бы использовать хэш-таблицу вроде той, что обсуждалась в главе 2, однако та версия не соответствует специфическим требованиям алгоритма markov, для которого нам надо по заданному префиксу быстро находить все возможные суффиксы.

Нам нужна структура данных, которая бы более успешно представляла префикс и ассоциированные с ним суффиксы. Программа будет работать в два прохода: при проходе ввода будет создаваться структура данных, представляющая фразы, а при проходе вывода эта структура будет использоваться для случайной генерации текста. При обоих проходах нам надо будет отыскивать префикс (причем быстро отыскивать!): при первом — для обновления его суффиксов, а при втором — для случайного выбора одного из связанных с ним суффиксов. Из этих требований логично вырисовывается такой вид хэш-таблицы: ключами ее являются префиксы, а значениями -наборы (множества) суффиксов для соответствующего префикса.

Для целей описания мы зафиксируем длину префикса в два слова, так что каждое выводимое слово будет базироваться на двух предшествующих. Количество слов в префиксе не влияет на проектирование, и программа сможет обрабатывать префиксы с любым количеством слов, но выбрав это число сейчас, мы просто сделаем разговор более конкретным. Префикс и множество всех возможных для него суффиксов мы назовем состоянием (state), что является стандартным термином для алгоритмов, связанных с марковскими цепями.

Для каждого заданного префикса мы должны сохранить все употребляемые после него суффиксы, чтобы потом иметь возможность их использовать. Суффиксы не упорядочены и добавляются по одному зараз. Мы не знаем их количества заранее, поэтому нам потребуется структура ] данных, которая могла бы увеличиваться легко и эффективно;

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

Что делать, если фраза встречается более одного раза? Например, фраза "может появиться дважды" может появиться дважды, а фраза "может появиться единожды" — только единожды. В таком случае можно поместить слово "дважды" два раза в список суффиксов для префикса "может появиться" или один раз, но при этом установить соответствующий суффиксу счетчик в 2. Мы попробовали и со счетчиками, и без них;

без счетчиков проще, поскольку при добавлении суффикса не надо проверять, нет ли его уже в списке. Эксперименты показали, что разница в скорости при обоих способах практически незаметна.

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

Теперь следует решить, как представлять сами слова. Простейший способ — хранить их как отдельные строки. Поскольку в большинстве текстов много слов появляется более одного раза, для сохранения места лучше использовать еще одну хэш-таблицу — для отдельных слов, каждое из которых будет храниться лишь единожды. Это ускорит хэширование (помещение в хэш-таблицу) префиксов, поскольку мы сможем сравнивать указатели, а не отдельные символы: уникальные строки будут иметь уникальные адреса. Проектирование этой структуры мы оставим вам для самостоятельных упражнений;

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

Создание структуры данных в языке С Начнем с реализации на С. Для начала надо задать некоторые константы:

enum { NPREF = 2, /* количество слов в префиксе */ NHASH = 4093, /* размер массива хэш-таблицы состояний */ MAXGEN = /* максимум генерируемых слов */ };

В этом описании определяются количество слов в префиксе (NPREF), размер массива хэш-таблицы (NHASH) и верхний предел количества генерируемых слов (MAXGEN). Если NPREF — константа времени компиляции, а не переменная времени исполнения, то управление хранением упрощается. Мы задали очень большой размер массива, поскольку программа должна быть способна воспринимать очень большие документы, возможно, даже целые книги. Мы выбрали NHASH = 4093, так что если во введенном. тексте имеется 10 000 различных префиксов (то есть пар слов), то среднестатистическая цепочка будет весьма короткой — два или три префикса. Чем больше размер, тем короче будет ожидаемая длина цепи и, следовательно, тем быстрее будет осуществляться поиск. Эта программа создается для развлечения, поэтому производительность ее не критична, однако если мы сделаем слишком маленький массив, то программа не сможет обработать текст ожидаемого размера за разумное время;

если же сделать его слишком большим,'он может не уложиться в имеющуюся память.

Префикс можно хранить как массив слов. Элементы хэш-таблицы будут представлены как тип данных State, ассоциирующий список Suffix с префиксом:

typedef struct State State;

typedef struct Suffix Suffix;

struct State { /* список префиксов + суффиксы */ char *pref[NPREFJ;

/* слова префикса */ Suffix *suf;

/* список суффиксов */ State *next;

/* следующий в хэш-таблице */ };

struct Suffix { /* список суффиксов */ char *word;

/* суффикс */ Suffix *next;

/* следующий суффикс в списке */ };

State *statetab[NHASH];

/* хэш-таблица состояний */ Графически структура данных выглядит так:

Нам потребуется хэш-функция для префиксов, которые являются массивами строк.

Нетрудно преобразовать хэш-функцию из главы 2, сделав цикл по строкам в массиве, таким образом хэшируя конкатенацию этих строк:

/* hash: вычисляет хэш-значение для массива из NPREF строк */ unsigned int hash(char *s[NPREF]) { unsigned int h;

unsigned char *p;

int i;

/* hash: вычисляет хэш-значение для массива из NPREF строк */ unsigned int hash(char *s[NPREF]) { unsigned int h;

unsigned char *p;

int i;

Выполнив схожим образом модификацию алгоритма lookup, мы завершим реализацию хэш-таблицы:

/* lookup: ищет префикс;

создает его при необходимости. */ /* возвращает указатель, если префикс существует или создан;

*, /* NULL в противном случае. */ /* при создании не делает strdup, так что строки /* не должны изменяться после помещения в таблицу. */ State* lookup(char *prefix[NPREF], int create) { int i, h;

State *sp;

h = hash(prefix);

for (sp = statetabfh];

sp != NULL;

sp = sp->next) { for (i = 0;

i,< NPREF;

i++) if (strcmp(prefix[i], sp->pref[i]) != 0) break;

if (i == NPREF) /* нашли'*/ return sp;

I> if (create) { sp = (State *) emalloc(sizeof(State));

for (i = 0;

i < NPREF;

i++) sp->pref[i] = prefix[i];

sp->suf = NULL;

sp->next = statetabfh];

statetab[h] = sp;

} return sp;

} Обратите внимание на то, что lookup не создает копии входящей строки при создании нового состояния, просто в sp->pref [ ] 'сохраняются указатели. Те, кто использует вызов lookup, должны гарантировать, что впоследствии данные изменены не будут. Например, если строки находятся в буфере ввода-вывода, то перед тем, как вызвать lookup, надо сделать их копию;

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

Теперь нам надо прочитать файл и создать хэш-таблицу:

/* build;

читает ввод, создает таблицу префиксов */ void build(char *prefix[NPREF], FILE *f) { char buf[100], fmt[10];

/* создать форматную строку:

%s может переполнить buf */ sprintf(fmt, "%%%ds", sizeof(buf)-1);

while (fscanf(f, fmt, buf) != EOF) add(prefix, estrdup(buf));

} Необычный вызов sprintf связан с досадной проблемой, присущей f scant, — если бы не эта проблема, функция f scanf идеально подошла бы для нашего случая. Все дело в том, что вызов fscanf с форматом %s считывает следующее ограниченное пробелами слово из файла в буфер, но без проверки его длины: слишком длинное слово может переполнить входной буфер, что приведет к разрушительным последствиям. Если буфер имеет размер 100 байтов (что гораздо больше того, что ожидаешь встретить в нормальном тексте), мы можем использовать формат %99s (оставляя один байт на заключительный ' \0'), что будет означать для fscanf приказ остановиться после 99 байт. Тогда длинное слово окажется разбитым на части, что некстати, но вполне безопасно. Мы могли бы написать ? enum { BUFSIZE = 100 };

? char fmtrj = "%99s";

/1 BUFSIZE-1./ однако это потребовало бы двух констант для одного, довольно произвольного значения — размера буфера;

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

Аргументы build — массив prefix, содержащий предыдущие NPREF введенных слов и указатель FILE. Массив prefix и копия введенного слова передаются в add, которая добавляет новый элемент в хэш-таблицу и обновляет префикс:

/* add: добавляет слово в список суффиксов, обновляет префикс */ void add(char *prefix[NPREF], char *suffix) { State *sp;

sp = lookup(prefix, 1);

/* создать, если не найден */ addsuffix(sp, suffix);

/* сдвиг слов вниз в префиксе */ memmove(prefix, prefix+1, (NPREF-1)*sizeof(prefix[0]));

prefix[NPREF-1] = suffix;

} Вызов memmove — идиоматический способ удаления из массива. В префиксе элементы с 1 по NPREF-1 сдвигаются вниз на позиции с 0 по NPREF-2, удаляя первое слово и освобождая место для нового слова в конце.

Функция addsuf fix добавляет новый суффикс:

/* addsuffix: добавляет в состояние. */ /* Суффикс впоследствии не должен меняться */ void addsuffix (State *sp, char *suffix) { Suffix *suf;

suf = (Suffix *) emalloc (sizeof(Suffix));

suf->word = suffix;

suf->next = sp->suf;

sp->suf = suf;

} Мы разделили процесс обновления состояния на две функции — add просто добавляет суффикс к префиксу, тогда как addsuffix выполняет тесно связанное с реализацией действие — добавляет слово в список суффиксов. Функция add вызывается из build, но addsuffix используется только изнутри add — это та часть кода, которая может быть впоследствии изменена, поэтому лучше выделить ее в отдельную функцию, даже если вызываться она будет лишь из одного места.

Генерация вывода Теперь, когда структура данных построена, пора переходить к следующему шагу — генерации нового текста. Основная идея остается неизменной: у нас есть префикс, мы случайным образом выбираем один из возможных для него суффиксов, печатаем его, затем обновляем префикс. Это повторяющаяся часть обработки;

нам еще надо продумать, как начинать и как заканчивать алгоритм. Начать будет нетрудно, если мы запомним слова первого префикса и начнем с них. Закончить алгоритм также нетрудно;

для этого нам понадобится слово-маркер. Прочтя весь вводимый текст, мы можем добавить некий завершитель — "слово", которое с гарантией не встретится ни в одном тексте:

build(prefix, stdin);

add(prefix, NONWORD);

В этом фрагменте NONWORD — некоторое значение, которое точно никогда не встретится в тексте. Поскольку по нашему определению слова разделяются пробелами, на роль завершителя подойдет "слово", равносильное пробелу, но отличное от него, например символ перевода строки:

char NONWORD[] = "\n";

/* никогда не встретится */ Еще одна проблема — что делать, если вводимого текста недостаточно для запуска алгоритма? Для решения этой проблемы существуют два принципиальных подхода — либо прерывать работу программы, если введенного текста недостаточно, либо считать, что для генерации хватит любого фрагмента, и просто не утруждать себя проверкой. Для данной программы лучше выбрать второй подход.

Можно начать процесс генерации с создания фиктивного префикса, который даст гарантию, что для работы программы всегда хватит вводимого текста. Для начала можно инициализировать все значения массива префиксов словом NONWORD. Это даст дополнительное преимущество — первое слово во вводимом файле будет первым суффиксом нашего вымышленного префикса, так что в генерирующем цикле печатать надо будет только суффиксы.

На случай, если генерируемый текст окажется непредсказуемо большого размера, можно встроить ограничитель — прерывать алгоритм после вывода заданного количества слов или при появлении NONWORD в качестве суффикса.

Добавление нескольких NONWORD в концы структур данных значительно упрощает основные циклы программы — это хороший пример использования специальных значений для маркировки границ — сигнальных меток (sentinel).

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

Функция generate использует алгоритм, который мы только что описали в общих словах. Она генерирует текст по слову в строке;

эти слова можно группировать в более длинные строки при помощи любого текстового редактора — в главе 9 будет показано простое средство для такого форматирования — процедура f mt.

Благодаря использованию в начале и в конце строк NONWORD, generate начинает и заканчивает работу без проблем:

/* generate: генерирует вывод по одному слову в строке */ void generate(int nwords) { State *sp;

Suffix *suf;

char *prefix[NPREF], *w;

int i, nmatch;

» for (i = 0;

i < NPREF;

i++) /* начальные префиксы */ prefix[i] = NONWORD;

for (i = 0;

i < nwords;

i++) { sp = lookup(prefix, 0);

nmatch = 0;

for (suf = sp->suf;

suf != NULL;

suf = suf->next) if (rand() % ++nmatch == 0) /* prob = 1/nmatch */ w = suf->word;

if (strcmp(w, NONWORD) == 0) break;

printf("%s\n", w);

memmove(prefix, prefix+1, (NPREF-1)*sizeof(prefix[0]));

prefix[NPREF-1] = w;

} } Обратите внимание на алгоритм случайного выбора элемента, когда число всех элементов нам неизвестно. В переменной nmatch подсчитывается количество совпадений при сканировании списка. Выражение rand() ++nmatch == увеличивает nmatch и является истинным с вероятностью 1/nmatch. Таким образом, первый подходящий элемент будет выбран с вероятностью 1, второй заменит его с вероятностью 1/2, третий заменит выбранный из предыдущих с вероятностью 1/3 и т.

п. В каждый момент времени каждый из k просмотренных элементов будет выбран с вероятностью i/k.

Вначале мы устанавливаем prefix в стартовое значение, которое с гарантией присутствует в хэш-таблице. Первые найденные значения Suffix будут первыми словами документа, поскольку только они следуют за стартовым префиксом. После этого суффикс выбирается случайным образом. В цикле вызывается lookup для поиска в хэш-таблице элемента (множества суффиксов), соответствующего данному префиксу;

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

Если выбранный суффикс оказывается NONWORD, то все заканчивается, поскольку это означает, что мы достигли состояния, относящегося к концу введенного текста.

Если суффикс не NONWORD, то мы его печатаем, а далее с помощью вызова memmove удаляем первое слово из префикса и делаем суффикс вторым словом нового префикса, после чего цикл повторяется.

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

/* markov main: генерация случайного текста */ /* по алгоритму цепей Маркова */ int main(void) { int i, nwords = MAXGEN;

char *prefix[NPREF];

/* текущий вводимый префикс */ for (i = 0;

i < NPREF;

i++) /* начальный префикс */ prefixfi] = NONWORD;

build(prefix, stdin);

add(prefix, NONWORD);

generate(nwords);

return 0;

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

Расплачиваться за это приходится тем, что программист вынужден выполнять большую работ}»;

: он сам должен выделять и освобождать память, создавать хэш таблицы\1 связные списки и т. п. С — инструмент с остротой бритвы: с его помощью можно создать и элегантную программу, и кровавое месиво.

Упражнение 3- Алгоритм случайного выбора элемента из списка неизвестной длины зависит от качества генератора случайных чисел. Спроектируйте и осуществите эксперименты для проверки метода на практике.

Упражнение 3- Если вводимые слова хранятся в отдельной хэш-таблице, то каждое слово окажется записанным лишь единожды, следовательно — экономится место. Оцените, сколько именно — измерьте какие-нибудь фрагменты текста. Подобная организация позволит нам сравнивать указатели, а не строки в хэш-цепочках префиксов, что выполняется быстрее. Реализуйте этот вариант и оцените изменения в быстродействии и размере используемой памяти.

Упражнение 3- Удалите выражения, которые помещают сигнальные метки NONWORD в начало и конец данных, и измените generate так, чтобы она нормально запускалась и останавливалась без их использования. Убедитесь, что вывод корректен для О, 1, 2, 3 и 4 слов. Сравните код с использованием сигнальных меток и код без них.

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

с ними ассоциированы функции, называемые методами.

Java имеет более богатую библиотеку, чем С. В частности, эта библиотека включает в себя набор классов-контейнеров (container classes) для группировки существующих объектов различными способами. В качестве примера можно привести класс Vector, который представляет собой динамически растущий массив, где могут храниться любые объекты типа Object. Другой пример— класс Hashtable, с помощью которого можно сохранять и получать значения одного типа, используя объекты другого типа в качестве ключей.

В нашем приложении экземпляры класса Vector со строками в качестве объектов — самый естественный способ хранения префиксов и суффиксов. Так же естественно использовать и класс Hashtable, ключами в котором будут векторы префиксов, а значениями — векторы суффиксов. Конструкции подобного рода называются отображениями (тар) префиксов на суффиксы;

в Java нам не потребуется в явном виде задавать тип State, поскольку Hashtable неявным образом сопоставляет префиксы и суффиксы. Этот дизайн отличается от версии С, где мы создавали структуры State, в которых соединялись префиксы и списки суффиксов, а для получения структуры State использовали хэширование префикса.

Hashtable предоставляет в наше распоряжение метод put для хранения пар ключ значение и метод get для получения значения по заданному ключу:

Hashtable h = new HashtableQ;

h.put(key, value);

Sometype v = (Sometype) h.get(key);

В нашей реализации будут три класса. Первый класс, Prefix, содер,-жит слова префиксов:

class Prefix { public Vector pref;

// NPREF смежных слов из ввода...

Второй класс, Chain, считывает ввод, строит хэш-таблицу и генерирует вывод;

переменные класса выглядят так:

class Chain { static final int NPREF = 2;

// размер префикса static final String NONWORD = "\hf";

// "слово", которое не может встретиться в тексте Hashtable statetab = new Hashtable();

// ключ = Prefix, значение = suffix Vector Prefix prefix = new Prefix(NPREF, NONWORD);

// начальный префикс Random rand = new Random();

Третий класс — общедоступный интерфейс;

в нем содержится функция main и происходит начальная инициализация класса Chain:

class Markov { static final int MAXGEN = 10000;

// максимальное количество // генерируемых слов public static void main(String[] args.) throws lOException { Chain chain = new ChainQ;

int nwords = MAXGEN;

chain.build(System.in);

chain.generate(nwords);

} } После того как создан экземпляр класса Chain, он в свою очередь создает хэш таблицу и устанавливает начальное значение префикса, состоящее из NPREF констант NONWORD. Функция build использует библиотечную функцию StreamTokenizer для разбора вводимого текста на слова, разделенные пробелами.

Первые три вызова перед основным циклом устанавливают значения этой функции, соответствующие нашему определению термина "слово":

// Chain build: создает таблицу состояний из потока ввода void build(InputStream in) throws lOException i \ StreamTokenizer st = new StreamTokenizer(in);

st.resetSyntax();

// удаляются правила по умолчанию st.wordChars(0, Character.MAX_VALUE);

// включаются все st.whitespaceChars(0, ' ');

//литеры, кроме пробелов while (st.nextToken() != st.TT_EOF) add(st.sval);

add(NONWORD);

} Функция add получает из хэш-таблицы вектор суффиксов для текущего префикса;

если их не существует (вектор есть null), add создает новый вектор и новый префикс для сохранения их в таблице. В любом случае эта функция добавляет новое слово в вектор суффиксов и обновляет префикс, удаляя из него первое слово и добавляя в конец новое.

// Chain add: добавляет слово в список суффиксов, обновляет префикс void add(String word) { Vector suf = (Vector) statetab.get(prefix);

if (suf == null) { suf = new Vector();

statetab.put(new Prefix(prefix), suf);

} suf.addElement(word);

prefix.pref.removeElementAt(O);

prefix, pref.addElement( word);

} Обратите внимание на то, что если suf равен null, то add добавляет в хэш-таблицу префикс как новый объект класса Pref ix, а не собственно pref ix. Это сделано потому, что класс Hashtable хранит объекты по ссылкам, и если мы не сделаем копию, то можем перезаписать данные в таблице. Собственно говоря, с этой проблемой мы уже встречались при написании программы на С.

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

// Chain generate: генерирует выходной текст void generate(int nwords) { prefix = new Prefix(NPREF, NONWORD);

for (int i = 0;

i < nwords;

i++) {Vector s = (Vector) statetab.get(prefix);

int r =Math.abs (rand.nextlnt()) % s.size();

String suf = (String) s.elementAt(r);

if (suf.equals(NONWORD))break;

System.out.println (suf);

prefix.pref.removeElementAt(O);

prefix.pref.addElement(suf);

} } Два конструктора Prefix создают новые экземпляры класса в зависимости от передаваемых параметров. В первом случае копируется существующее значение типа Prefix, а во втором префикс создается из п копий строки;

этот конструктор используется для создания NPREF копий NONWORD при инициализации префикса:

// конструктор Prefix: создает копию существующего префикса Prefix(Prefix p) { pref = (Vector) p.pref.clone();

} // конструктор Prefix: n копий строки str Prefix(int n, String str) { pref = new Vector();

for (int i = 0;

i < n;

i++) pref.addElement(str);

} Класс P refix имеет также два метода, hashCode и equals, которые неявно вызываются из Hashtable для индексации и поиска по табллце. Нам пришлось сделать Prefix полноценным классом как раз из-за этих двух методов, которых требует Hashtable, иначе для него можно было бы использовать Vector, как мы сделали с суффиксом.

Метод hashCode создает отдельно взятое хэш-значение, комбинируя набор значений hashCode для элементов вектора:

static final int MULTIPLIER =31;

// для hashCode() // Prefix hashCode:

генерирует хэш-значение // на основе всех слов префикса public int hashCode() { int h = 0;

for (int i = 0;

i < pref.sizeO;

i++) h = MULTIPLIER *h + pref,elementAt(i).hashCode();

return h;

} Метод equals осуществляет поэлементное сравнение слов в двух npeфиксах:

// Prefix equals:

сравнивает два префикса на идентичность слов public boolean equals(0bject о) { Prefix p = (Prefix) о;

for (int 1 = 0;

i < pref.size();

i++) if (!pref.elementAt(i).equals (p.pref.elementAt(i))) return false;

return true;

} Программа на Java гораздо меньше, чем ее аналог на С, при этом больше деталей проработано в самом языке — очевидными примерами являются классы Vector и Hashtable. В общем и целом управление хранением данных получилось более простым, поскольку вектора растут, когда' нужно, а сборщик мусора (garbage collector — специальный автоматический механизм виртуальной машины Java) сам заботится об освобождении неиспользуемой памяти. Однако для того, чтобы использовать класс Hashtable, нам пришлось-таки самим писать функции hashCode и equals, так что нельзя сказать, что язык Java заботился бы обо всех деталях.

Сравнивая способы, которыми программы на С и Java представляют < и обрабатывают одни и те же структуры данных, следует отметить, что в версии на Java лучше разделены функциональные обязанности. При таком подходе нам, например, не составит большого труда перейти от использования класса Vector к использованию массивов. В версии С каждый блок связан с другими блоками: хэш таблица работает с массивами, которые обрабатываются в различных местах;

функция lookup четко ориентирована на конкретное представление структур State и Suffix;

размер массива префиксов вообще употребляется практически всюду.

Пропустив эту программу с исходным (химическим) текстом и форматируя сгенерированный текст с помощью процедуры f mt, мы получили следующее:

% Java Markov

Watch it dry. The water goes into the air. When water goes into the air it evaporates. Tie a damp clotTf to one end of a solid or liquid. Look around.

What are the solid things?

Chemical changes take place when something burns.

If the burning material has.liquids, they are stable and the sponge rise.

It looked like dough, but it is burning. Break up the lump of sugar into small pieces and put them together again in the bottom of a liquid.

Упражнение 3- Перепишите Java-версию markov так, чтобы использовать массив вместо класса Vector для префикса в классе Prefix.

C++ Третий вариант программы мы напишем на C++. Поскольку C+ + является почти что расширением С, на нем можно писать как на С (с некоторыми новыми удобствами в обозначениях), а наша изначальная С-версия будет вполне нормальной программой и для C++. Однако при использовании C++ было бы более естественно определить классы для объектов программы — что-то вроде того, что мы сделали на Java — это позволит скрыть некоторые детали реализации. Мы решили пойти даже дальше и использовать библиотеку стандартных шаблонов STL (Standard Template Library), поскольку в ней есть некоторые встроенные механизмы, которые могут выполнить значительную часть необходимой работы. ISO-стандарт C++ включает в себя STL как часть описания языка.

STL предоставляет такие контейнеры, как векторы, списки и множества, а также ряд основных алгоритмов для поиска, сортировки, добавления и удаления элементов данных. Благодаря использованию шаблонов C++ каждый алгоритм STL работает со всевозможными видами контейнеров, включая как типы, описанные пользователем, так и встроенные типы данных. Контейнеры реализованы как шаблоны C++, которые инстанцируются для конкретных типов данных;

например, контейнер vector может использоваться для создания конкретных типов vector или vector. Все операции, описанные в библиотеке для vector, включая стандартные алгоритмы сортировки, можно использовать для таких "производных" типов данных.

В дополнение к контейнеру vector, который схож с Vector в Java, STL предоставляет контейнер deque (дек, гибрид очереди и стека). Дек — это двусторонняя очередь, которая как раз подходит нам для работы с пре-_ фиксами: в ней содержится NPREF элементов, и мы можем выкидывать первый элемент и добавлять в конец новый, обе операции — за время О(1). Дек STL — более общая структура, чем требуется нам, поскольку она позволяет выкидывать и добавлять элементы с обоих концов, но характеристики производительности указывают на то, что нам следует использовать именно ее.

В STL существует также в явном виде и основанный на сбалансированных деревьях контейнер тар, который хранит пары ключ-значение и осуществляет поиск значения, ассоциированного с любым ключом, за 0(log n). Отображения, возможно, не столь эффективны, как О(1) кэш-таблицы, но приятно то, что для их использования не надо писать вообще никакого кода. (Некоторые библиотеки, не входящие в стандарт C++, содержат контейнеры hash или hash_map — они бы подошли просто идеально.) Кроме всего прочего, мы будем использовать и встроенные функции сравнения, в данном случае они будут сравнивать строки, используя отдельные строки префикса (в которых мы храним отдельные слова!).

Имея в своем распоряжении все перечисленные компоненты, мы пишем код совсем гладко. Вот как выглядят объявления:

typedef deque Prefix;

map > statetab;

// prefix-> suffixes Как мы уже говорили, STL предоставляет шаблон дека;

запись deque обозначает дек, элементами которого являются строки. Поскольку этот тип встретится в программе несколько раз, мы использовали typedef для присвоения ему осмысленного имени Prefix. А вот тип тар, хранящий префиксы и суффиксы, появится лишь единожды, так что мы не стали давать ему уникального имени;

объявление тар описывает переменную statetab, которая является отображением префиксов на векторы строк. Это более удобно, чем в С или Java, поскольку нам не потребуется писать хэш-функцию или метод equals.

В основном блоке инициализируется префикс, считывается вводимый текст (из стандартного потока ввода, который в библиотеке C++ lost ream называется cin), добавляется метка конца ввода и генерируется выходной текст — совсем как в предыдущих версиях:

// markov main: генерация случайного текста // по алгоритму цепей Маркова int main(void) { int nwords = MAXGEN;

Prefix prefix;

// текущий вводимый префикс for (int i = 0;

i < NPREF;

i++) // начальные префиксы add(prefix, NONWORD);

build(prefix, ciri>r"~ add(prefix, NONWORD);

generate(nwords);

return 0;

} Функция build использует библиотеку lost ream для ввода слов по одному:

// build: читает слова из входного потока, // создает таблицу состояний void build (Prefix& prefix, istream& in) { string buf;

while (in » buf) add(prefix, buf);

} Строка buf будет расти по мере надобности, чтобы в ней помещались вводимые слова произвольной длины.

В функции add более явно видны преимущества использования STL:

// add: добавляет слово в список суффиксов, обновляет п void add (Prefix& prefix, const strings s) { if (prefix.size() == NPREF) { statetab[prefix].push_back(s) ;

prefix.pop_front();

} prefix.push_back(s);

} Как вы видите, выражения выглядят совсем не сложно;

происходящее "за кулисами" тоже вполне доступно пониманию простого смертного. Контейнер тар переопределяет доступ по индексу (операцию[ ]) для того, чтобы он работал как операция поиска. Выражение statetab[prefix] осуществляет поиск в statetab по ключу prefix и возвращает ссылку на искомое значение;

если вектора еще не существует, то создается новый. Функция push_back — такая функция-член класса имеется и в vector, и в deque — добавляет новую строку в конец вектора или дека;

pop^f ront удаляет ("выталкивает") первый элемент из дека.

Генерация результирующего текста осуществляется практически так же, как и в предыдущих версиях:

// generate: генерирует вывод - по слову на строку void generate(int nwords) { Prefix prefix;

int i;

for (i = 0;

i < NPREF;

i++) // начальные префиксы add (prefix, NONWORD);

for (i = 0;

i < nwords;

i++) { vector& suf = statetab[prefix];

const string& w = suf[rand() % suf.size()];

if (W == NONWORD) break;

cout « w « "\n";

prefix.pop_front();

// обновляется префикс prefix.push_back(w);

} } Итак, в результате именно эта версия выглядит наиболее понятно и элегантно — код компактен, структура данных ясно видна, а алгоритм абсолютно прозрачен. Но, как и за все хорошее в жизни, за это надо платить — данная версия работает гораздо медленнее, чем версия, написанная на С;

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

Упражнение 3- Одно из главных преимуществ использования STL состоит в той простоте, благодаря которой можно экспериментировать с различными структурами данных. Попробуйте изменить эту версию, используя различные структуры данных для префиксов, списка суффиксов и таблицы состояний. Посмотрите, как при этом изменяется производительность.

Упражнение 3- Перепишите программу на C++ так, чтобы в ней использовались только классы и тип данных string — без каких-либо дополнительных библиотечных средств. Сравните то, что у вас получится, по стилю кода и скорости работы с нашей STL-версией.

AWK и PERL Чтобы завершить наши упражнения, мы написали программу еще и на двух популярных языках скриптов — Awk и Perl. В них есть возможности, необходимые для нашего приложения, — ассоциативные массивы и методы обработки строк.

Ассоциативный массив (associative array) — это подходящий контейнер для кэш таблицы;

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

в Perl есть как массивы, индексируемые стандартным образом, целочисленными индексами, так и ассоциативные массивы, которые называются "хэшами" (hashes), — из их названия сразу становится ясен способ их внутренней реализации.

Предлагаемые версии на Awk и Perl рассчитаны только на работу с префиксами длиной в два слова.

# markov.awk: алгоритм цепей Маркова для префиксов из 2 слов BEGIN { MAXGEN = 10000;

NONWORD = "\n"> w1 = w2 = NONWORD }.

{ for (i = 1;

i <= NF;

i++) { # читать все словаstatetab [w1,w2,++nsuffix[w1,w2]] = $i wl = w w2 = $1 } } END { Statetab[w1,w2,++nsuffix[w1,w2]] = NONWORD ft добавить метку конца ввода w1 = w2 = NONWORD for (i = 0;

i < MAXGEN;

i++) { # генерируем г = int(rand()*nsuffix[w1,w2]) + 1 # nsuffix >= 1 p = statetab[w1,w2, r] if (p == NONWORD) exit print p w1 = w2 # идти дальше по цепочке w2 =.p } ) Awk — язык, функционирующий по принципу "образец-действие": входной поток читается по строке за раз, каждая строка сравнивается с образцом, для каждого совпадения выполняется соответствующее дей-Ствие. Существуют два специальных образца-— BEGIN и END, которые вызываются, соответственно, перед первой строкой ввода и после последней.

Действие — это блок выражений, заключенный в фигурные скобки. В Awk-версии в блоке BEGIN инициализируется префикс и пара других переменных.

Следующий блок не имеет образца, поэтому он по умолчанию вызывается для каждой новой строки ввода. Awk автоматически разделяет каждую вводимую строку на поля (ограниченные пробелами слова), имеющие имена от $1 до $NF;

переменная NF — это количество полей. Выражение Statetab[w1,w2,++nsuffix[w1,w2]] = $i создает отображение префиксов в суффиксы. Массив nsuffix считает суффиксы, а элемент nsuf f ix[w1, w2] считает количество суффиксов, ассоциированных с префиксом. Сами суффиксы хранятся в элементах массива statetab[w1,w2, 1], statetab[w1, w2, 2] и т. д.

Блок END вызывается на выполнение после тогсц как весь ввод был считан. К этому моменту для каждого префикса существует элемент nsuffix, содержащий количество суффиксов, и, соответственно, существует именно столько элементов statetab, содержащих сами суффиксы.

Версия Perl выглядит похожим образом, но в ней для хранения суффиксов используется безымянный массив, а не третий индекс;

для обновления же префикса используется множественное присваивание. В Perl для обозначения типов переменных применяются специальные символы: $ обозначает скаляр, @ — индексированный массив, квадратные скобки [ ] используются для индексации массивов, а фигурные скобки { } — для индексации хэшей.

# markov.pl: алгоритм цепей Маркова для префиксов из 2 слов SMAXGEN = 1000;

$NONWORD = "\п";

$w1 = $w2 = $NONWORD;

# начальное состояние while (о) { n читать каждую строку ввода foreach (split) { push((s>{$statetab{$w1} {$w2} }, $_);

($w1, $w2) = ($w2, $_);

it множественное присваивание } I-push(@{$statetab{$w1} {$w2} }, $NONWORD);

# добавить метку конца ввода $w1 = $w2 = $NONWORD;

for ($i =0;

$i < $MAXGEN;

$i++) { $suf = $statetab{$w1} {$w2};

# ссылка на массив $r = int(rand @$suf);

n @$suf - количество элементов exit if (($t = $suf"->[$r]) eq $NONWORD);

print "$t\n";

($w1, $w2) = ($w2, $t);

# обновить префикс } Как и в предыдущей программе, отображение хранится при помощи переменной statetab. Центральным моментом программы является выражение push(@{$statetab{$w1}{$w2}}, $_);

которое дописывает новый суффикс в конец (безымянного) массива, хранящегося в statetab{$w1}{$w2). На этапе генерации $statetab{$w1}{$w2} является ссылкой на массив суффиксов, a$suf->[$r] указывает на суффикс, хранящийся под номером r.

Программы и на Awk, и на Perl гораздо короче, чем любая из трех предыдущих версий, но их тяжелее адаптировать для обработки префиксов, состоящих из произвольного количества слов. Ядро программ на С и C++ (функции add и generate) имеет сравнимую длину, но выглядит более понятно. Тем не менее языки скриптов нередко являются хорошим выбором для экспериментального программирования, для создания прототипов и даже для производственного использования в случаях, когда время счета не играет большой роли.

Упражнение 3- Попробуйте преобразовать приложения на Awk и Perl так, чтобы они могли обрабатывать префиксы произвольной длины. Попробуйте определить, как это скажется на быстродействии программ.

Производительность Теперь можно сравнить несколько вариантов программы. Мы засекали время счета на библейской Книге Псалмов (версия перевода King James Bible), в которой содержится 42 685 слов (5238 уникальных слов, 22 482 префикса). В тексте довольно много повторяющихся фраз ("Blessed is the..."), так что есть списки суффиксов, имеющие более 400 элементов, и несколько сотен цепей с десятками суффиксов, и это хороший набор данных для теста.

Blessed is the man of the net. Turn thee unto me, and raise me up, that I may tell all my fears. They looked unto him, he heard.

My praise shall be blessed. Wealth and riches shall be saved.

Thou hast dealt well with thy hid treasure: they are cast into a standing water, the flint into a standing water, and dry ground into watersprings.

Приведенная таблица показывает время в секундах, затрачиваемое на j генерацию 10 000 слов;

тестирование проводилось на машине 250 MHz MIPS R10000 с операционной системой Irix 6.4 и на машине Pentium II 400 MHz со 128 мегабайтами памяти под Windows NT. Время выполнeния почти целиком определяется объемом вводимого текста;

генерация происходит несравненно быстрее. В таблице приведен также примерный размер программы в строках исходного кода.

Строки исходного 250 MHz RlOOOO(c) 400 MHz Pentium II (c) кода С 0.36 0.30 Java 4.9 9.2 C++/STL/deque 2.6 11.2 C++/STL/list 1.7 1.5 Awk 2.2 2.1 Perl 1.8 1.0 Версии С и C++ компилировались с включенной оптимизацией, а программы Java запускались с включенным JIT-компилятором (Just-In-Time, "своевременная" компиляция). Время, указанное для версий С и C++ под Irix, — лучшее врейя из трех возможных компиляторов;

сходные результаты были получены и для машин Sun SPARC и DEC Alpha.

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

Что-то явно не так с версией STL/deque под Windows. Эксперименты показали, что дек, представляющий префиксы, поедает практически все время выполнения, хотя в нем никогда не содержится более двух элементов;

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

Переход же с отображения (тар) на (нестандартный) контейнер hash под Irix не приносит никаких изменений (на машине с Windows у нас не было реализации hash).

В пользу замечательного принципа проектирования библиотеки STL говорит тот факт, что для внесения этих изменений нам было достаточно заменить слово list на слово deque, а слово hash на слово тар в двух местах и скомпилировать программу заново. Мы пришли к выводу, что STL, которая является новым компонентом C++, все еще страдает некоторыми недоделками в реализации части своих элементов.

Производительность при выборе различных версий STL или изменении используемых структур данных меняется непредсказуемым образом. То же самое можно отнести и к Java, где реализации также быстро меняются.

В тестировании программы, которая выдает в качестве результата что-то объемное, да к тому же выбранное случайным образом, есть доля творческого вызова. Как узнать, правильно ли программа работает? Всегд;

ли она работает правильно? В главе 6, посвященной тестированию, м: дадим ряд советов на этот счет и расскажем, как мы тестировали наш;

программу.

Уроки Программа markov имеет длинную историю. Первая версия была на-1 писана Доном Митчелом, адаптирована Брюсом Эллисом и применялась для разнообразной забавной деконструктивистской деятельности на протяжении 1980-х годов. Она не имела никакого развития до тех пор, пока мы не решили использовать ее для иллюстрации университетского курса по проектированию программ. Однако и мы, вместо того чтобы сдуть пыль с оригинала, заново переписали ее на С, чтобы живее прочувствовать связанные с ней проблемы. После этого мы написали ее на ряде других языков, в каждом случае используя присущие тому или иному языку идиомы для выражения одной и той же основной идеи. После прочтения курса мы не раз еще переписывали программу, добиваясь предельной ясности и идеального вида.

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

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

Архитектура программы коренится в принципиальной структуре данных. Структуры данных, конечно, не определяют каждую деталь, но формируют общее решение.

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

Большое преимущество программ на объектно-ориентированных языках вроде C++ или Java состоит в том, что, внеся в них совсем незначительные изменения, можно создать структуры данных, подходящие для новых объектов: вместо английского текста можно использовать, например, программы (где пробелы будут уже значимыми символами), или музыкальные ноты, или даже щелчки мыши и выборы пунктов меню для генерации тестовых последовательностей.

Конечно, несмотря на то что структуры данных различаются слабо, программы на разных языках достаточно сильно отличаются друг от друга по размеру исходного кода и быстродействию. Грубо говоря, программы, написанные на языках высокого уровня, будут более медленными, чем программы на языках низкого уровня, хотя оценку можно дать только качественную, но не количественную. Использование больших строительных блоков, таких как STL в C++ или ассоциативные массивы и обработка строк в скриптовых языках, приводит к более компактному коду и серьезно сокращает время на создание приложения. Как мы уже отмечали, за удобство приходится платить, хотя проблемы с быстродействием не имеют большого значения для программ типа рассмотренной, поскольку выполняется она всего несколько секунд.

Менее понятно, однако, как оценить ослабление контроля над программой и понимания происходящего со стороны программиста, когда размер "заимствованного" кода становится настолько большим, что отследить все нюансы становится невозможно. STL-версия — это как раз тот самый случай: ее производительность непредсказуема, и нет простых способов как-то с этим разобраться. Немногие из нас обладают достаточным запасом сил и энергии, чтобы разыскать источник трудностей и исправить ошибки.

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

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

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

п.). Если кто-то уже описал эти структуры или алгоритмы и создал библиотеку, то нам это только на руку;

наша C++ версия выигрывала как раз за счет этого.

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

после того как структуры данных определены, код проектируется и пишется гораздо проще.

Трудно сначала спроектировать программу целиком, а потом уже писать;

создание реальных программ всегда включает в себя повторения и эксперименты. Процесс непосредственного написания программы вынуждает программиста уточнять решения, которые до этого существовали лишь в общем виде. Для нашей программы это весьма актуально — она претерпела множество изменений в деталях. Изо всех сил старайтесь начинать с чего-нибудь простого, внося улучшения, диктуемые опытом. Если бы нашей целью было просто реализовать алгоритм цепей Маркова для развлечения — тексты бывают довольно забавными, — мы практически наверняка написали бы его на Awk или Perl, причем даже не позаботившись навести глянец, который мы вам продемонстрировали, — и на этом успокоились бы.

Однако код для настоящего промышленного приложения требует го-'j раздо больших затрат, чем код прототипа. Если к представленным здесь программам относиться как к промышленной реализации (поскольку они были отлажены и тщательно оттестированы), то усилия на создание промышленной версии будут на один-два порядка больше, чем при написании программы для собственного использования.

Упражнение 3- Мы видели множество версий этой программы, написанных на различных языках программирования, включая Scheme, Tel, Prolog, Python, Generic Java, ML и Haskell;

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

Дополнительная литература Библиотека стандартных шаблонов описана во множестве книг, включая "Генерацию программ и STL" Мэтью Остерна (Matthew Austern. Generic Programming and the STL.

Addison-Wesley, 1998).

Для изучения самого языка C++ лучшим пособием является "Язык программирования C++" Бьёрна Страуструпа (Bjarne Stroustrup. The C++ Programming Language. 3rd ed. Addison-Wesley, 1997)2, для изучения Java — "Язык программирования Java" Кена Арнольда и Джеймса Гос-линга (Ken Arnold and James Gosling. The Java Programming Language. 2mt ed. Addison-Wesley, 1998). Лучшее, на наш взгляд, описание Perl при- • ведено в "Программировании на Perl" Ларри Уолла, Тома Кристиансена и Рэндала Шварца (Larry Wall, Tom Christiansen and Randal Schwartz. Programming Perl. 2nd ed. O'Reilly, 1996).

В принципе, можно говорить о существовании неких шаблонов проектирования (design patterns) — действительно, в большинстве программ используется лишь ограниченное количество принципиальных проектировочных решений — точно так же, как существует лишь несколько базовых структур данных;

с некоторой натяжкой можно сказать, что это аналог идиоматического кода, о котором мы говорили в первой главе. Эта идея лежит в основе книги Эриха Гаммы, Ричарда Хелма, Ральфа Джонсона и Джона Влиссайдеса "Разработка шаблонов: элементы по вторноиспользуемого объектно-ориентированного программного обеспечения" (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, 1995).

Авантюрные приключения программы markov (которая изначально называлась shaney) были описаны в разделе "Computing Recreations" журнала Scientific American за ию^ь 1989 года. Статья была перепечатана в книге Дьюдни "Магическая машина" (А. К. Dewdney. The Magic Machine. W. H. Freeman, 1990).

Интерфейсы • Значения, разделенные запятой • Прототип библиотеки • Библиотека для распространения • Реализация на C++ • Принципы интерфейса • Управление ресурсами • Abort, Retry, Fail?

• Пользовательские интерфейсы • Дополнительная литература И до того, как буду строить стену, я должен знать, Что огораживаю я: внутри или снаружи, - И что не нарушаю чьих-то прав.

Есть нечто, что не терпит ограждений, Ломая их Роберт Фрост. Починка стены Суть проектирования — сбалансировать конфликтующие цели и ограничения. Когда вы пишете небольшую программу для собственного пользования, вы, конечна, можете сами выбирать конкретные решения, этот выбор не затронет ничего и никого, кроме вас. Но если ваш код будет использоваться кем-то еще, каждое решение имеет более широкие последствия.

Среди проблем, которые надо решить при проектировании, стоит выделить следующие.

• Интерфейсы: какой доступ и какой сервис предлагается? Интерфейс, в сущности, является соглашением между поставщиком (программистом) и потребителем. В идеале мы должны предоставлять унифицированные и удобные средства, имеющие достаточно возможностей для того, чтобы их было легко использовать, и в то же время не настолько большие, чтобы стать громоздкими.

• Сокрытие информации: какая информация доступна, а какая — нет?

Интерфейс должен предоставлять прямой доступ к компонентам, скрывая при этом детали реализации, — с тем чтобы их можно было изменять, не затрагивая пользователя.

• Управление ресурсами: кто отвечает за управление памятью и другими ограниченными ресурсами? Здесь главными проблемами являются выделение и освобождение памяти и управление совместно используемой информацией.

• Обработка ошибок: кто обнаруживает ошибки, кто сообщает о них| и каким образом все это делается? Какие попытки восстановления предпринимаются при обнаружении ошибки?

В главе 2 мы рассмотрели составные части, из которых строится система, — структуры данных. В главе 3 мы узнали, как объединять их в небольшие программы.

Теперь наше внимание сосредоточится на интерфейсах между компонентами, получаемыми из разных источников. В этой главе мы проиллюстрируем проектирование интерфейсов созданием библиотеки функций и структур данных для решения одной хорошо известной задачи. Попутно мы познакомим вас с некоторыми принципами проектирования. Как правило, при проектировании приходится принимать огромное количество решений, но большинство из них делается почти бессознательно. Из-за незнания базовых принципов и возникают те малопонятные интерфейсы, которые ежедневно так досаждают программистам.

Значения, разделенные запятой Значения, разделенные запятой (Comma-Separated Values — CSV), — так называется естественный и широко распространенный способ представления табличных данных. Каждая строка таблицы соответствует строке текста;

поля в строке разделены запятыми. Таблица из главы 3, представленная в формате CSV, начиналась бы так:

,"250MHz","400MHz","Строки", "R10000","Pentium II","исходного кода" С,0.36 sec,0.30 sec, Java,4.9,9.2, Этот формат используется для чтения и записи различными программами, работающими с электронными таблицами. Используется он и на некоторых Web страницах, например для выдачи справок о биржевых котировках. Одна из популярных страниц с биржевыми курсами представляет информацию примерно так:

Биржевой символ Последние торги Изменения Объем LU 2:19РМ 86-1/4 +4-1/16 +4,94 % 5 804 Т 2:19РМ 60-11/16 -1-3/16 -1,92% MSFT 2:24РМ 106-9/16 +1-3/8 + 1,31 % Загружаемый табличный формат Получать значения с помощью Web-браузера удобно, но долго. Вы запускаете браузер, ждете, потом на вас вываливается поток рекламы, вы выбираете список котировок, опять ждете, ждете, ждете, опять лицезрее-те рекламу и т. д. — и все для того, чтобы получить несколько чисел. Для дальнейшей обработки значений вам придется повторить весь процесс еще не один раз, а между тем, выбрав ссылку "Download Spreadsheet Format" (скачать в табличном формате), вы сразу получите файл, содержащий в основном ту же самую информацию в виде данных в формате CSV — примерно такого вида (здесь строки откорректированы нами по длине):

"LU", 86. 25, "11/4/1998,", "2:19PM",+4. 0625, 83.9375,86.875,83.625, "Т",60.6875,"11/4/1998", "2:19PM",-1.1875, 62.375,62.625,60.4375, "MSFT",106.5625,"11/4/1998","2:24PM", +1. 375, 105:8125,107.3125, 105.5625, Сразу ясно, что второй способ проще: за вас работает компьютер. Браузеры позволяют вашему компьютеру получать доступ к данным с удаленного сервера, но гораздо лучше получать данные без необходимости муторного личного участия.

Надо отметить, что на самом деле все нажимания на кнопки — не более чем некая текстовая процедура: браузер читает некий HTML, вы вводите некий текст, и браузер отсылает его на сервер, получая в ответ какой-то новый HTML. Имея нормальные инструменты и язык программирования, нетрудно добиться получения информации в автоматическом режиме. Вот текст программы на языке Tel, обращающейся к Web сайту биржевых курсов и возвращающей данные в формате CSV, предваренные несколькими заголовочными строками:

8 getquotes.tcl: биржевые курсы для Lucent, AT&T, Microsoft set so [socket quote.yahoo.com 80] ;

# соединение с сервером set q Yd/quotes.csv?s=LU+T+MSFT&f=sl1d1t1c1ohgv" puts $so "GET $q HTTP/1.0\r\n\r\n" ;

# послать запрос flush $so puts [read $so] Таинственная последовательность f =..., следующая за аббревиатурами биржевых сводок, — недокументированная управляющая строка (аналог первого аргумента printf), определяющая, какие данные требуется получить. Экспериментальным путем мы выяснили, что s задает код акций, 11 — последнюю цену, d — изменение цены по сравнению со вче-' рашним днем и т. п. Важны здесь не конкретные детали, которые могут всячески меняться, а открывающаяся возможность автоматизации получения нужной информации и преобразования ее в нужный вид без участия пользователя.

Пусть работает железный агрегат.

Для того чтобы запустить getquotes, вам потребуются какие-то доли секунды, — это несравненно быстрее, чем возиться с браузером.

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

В нескольких последующих разделах мы создадим три версии библиотеки для чтения и преобразования данных CSV. Попутно мы обсу-! дим аспекты, неизбежно возникающие при проектировании программ, взаимодействующих с другими программами. Так, например, оказалось, что стандартного определения CSV не существует, поэтому наша реализация не может базироваться на точной спецификации, — это обычная ситуация при проектировании интерфейсов.

Прототип библиотеки Вряд ли нам удастся получить удачный проект библиотеки интерфейса с первой попытки. Как написал однажды Фред Брукс (Fred Brooks), "заранее планируйте выкинуть первую версию — все равно придется". Брукс писал о больших системах, но суть остается той же и для любой нормальной программы. Как правило, до тех пор пока вы не создали первой версии и не поработали с ней, трудно представить себе все аспекты работы программы настолько хорошо, чтобы спроектировать достойный продукт.

Исходя из этих соображений, мы начнем создавать библиотеку CSV с версии "на выброс", с прототипа. В первой версии мы проигнорируем многие проблемы, которые должны быть решены в грамотной библиотеке, однако она будет достаточно полной, чтобы ее можно было использовать, и с помощью этой версии мы поближе познакомимся с задачей.

Начнем с функции csvgetline, которая считывает одну строку данных CSV из файла в буфер, разделяет ее на поля массива, удаляет кавычки и возвращает количество полей. В течение многих лет мы уже не раз писали что-то подобное на различных языках, так что задание нам знакомо. Вот версия-прототип на С;

мы пометили код вопросами, потому что это всего-навсего прототип:

? char buf[200];

/* буфер вводимой строки */ ? char *field[20];

/* поля */ ?

? /* csvgetline: читает и разбирает строку, */ ? /* возвращает количество полей */ ? /* пример ввода: "LU", 86. 25, "11/4/1998", "2:19РМ", +4. 0625 */ ? int csvgetline(FILE *fin) ? { ? int nfield;

« ? char *p, *q;

?

? if (fgets(buf, sizeof(buf), fin) == NULL) ? return -1;

? nfield = 0;

? for (q = buf;

(p=strtok(q, ",\n\r")) != NULL;

q = NULL) ? field[nfield++] = unquote(p);

? return nfield;

? } Комментарий в начале функции включает в себя пример формата ввода, воспринимаемого функцией;

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

Формат CSV слишком сложен, чтобы разбирать его с помощью scanf, поэтому мы использовали функцию strtok из стандартной библиотеки С. Каждый вызов strtok(p, s) возвращает указатель на первую лексему (token) из строки р, состоящую из символов, не входящих в s;

st rtok обрывает эту лексему, заменяя следующий символ исходной строки нулевым байтом. При первом вызове strtok первым аргументом является сканируемая строка;

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

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

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

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

? /* unquote: удаляет открывающие и закрывающие кавычки */ ? char *unquote(char *p) ? { ? if (p[0] == ") { ? if (p[strlen(p)-1] == ) ? p[strlen(p)-1] = '\О';

? p++;

?

} ? return p;

?

} При выводе printf заключает поля в парные простые кавычки;

это зрительно разделяет поля и помогает выявить ошибки некорректной обработки пробелов.

Мы можем прогнать через этот тест результаты работы getquotes. tcl:

% getquotes.tcl | csvtest поле[0] = 'LIT поле[1] = '86.375' поле[2] = '11/5/1998' поле[3] = 'V.01PM' поле[4] = '-0.125' поле[5] = '86' поле[6] = '86.375' поле[7] = '85.0625' поле[8] = '2888600' поле[0] = 'Т' v поле[1] = '61..0625'...

(Заголовки.HTTP мы убрали.) Итак, у нас'есть прототип, который, кажется, в состоянии работать с данными вроде приведенных выше. Однако теперь было бы логично опробовать его на чем-то еще (особенно если мы планируем распространять эту библиотеку). Мы нашли еще один Web-сайт, позволяющий скачать биржевые котировки и получить файл с той же, собственно, информацией, но представленной в несколько иной форме: для разделения записей вместо символа йеревода строки используется символ возврата каретки (\г), а в конце файла завершающего возврата каретки нет. Выглядят новые данные так (мы отформатировали их, чтобы они умещались на странице):

"Ticker","Price","Change","Open", "Prev Close","Day High", "Day Low", "52 Week High","52 Week Low","Dividend", "Yield","Volume","Average Volume","P/E" "LIT,86.313,-0.188,86.000,86.500, 86.438,85.063,108.50, 36.18,0.16,0.1,2946700, 9675000, N/A "T",61.125,0.938,60.375,60.188,61.125, 60.000, 68. 50, 46.50,1.32,2.1,3061000, 4777000,17. "MSFT",107.000,1.500,105.313,105.500, 107.188,105.250, 119.62,59.00, N/A,N/A,7977300,16965000,51. При таком вводе наш прототип позорно провалился.

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

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

Что ж, пришло время переработать проект.

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

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

• Предполагается, что ввод состоит из строк, оканчивающихся символом перевода строки.

• Поля разделены запятыми;

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

• Вводимая строка не сохраняется;

в процессе генерации полей она переписывается.

• При переходе от одной строки к следующей никакие данные не сохраняются;

если что-то надо запоминать, то следует создавать копию.

• Доступ к полям осуществляется через глобальную переменную — массив field, который используется совместно функцией csvget-line и функцией, которая ее вызвала;

нет никакого контроля доступа к содержимому полей или указателям. Не предусмотрено никаких средств для предотвращения доступа за последнее поле.

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

• Функция csvgetline читает только из уже открытых файлов;

открытие лежит целиком на совести вызывающего кода.

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

• Возвращаемое значение есть количество полей в строке;

для подсчета этого значения строка должна быть разделена на поля. Не предусмотрено никакого механизма для определения ошибок конца файла.

• Нет никакой возможности изменить ни одно из перечисленных свойств, не внося изменений в код.

В этом длинном, но далеко не полном списке приведены те решения, которые мы приняли на этапе проектирования, — и каждое решение навсегда вплетено в код.

Это приемлемо для временной версии, разбирающей файлы известного формата, поступающие из одного конкретного источника. Но что будет, если формат изменится, или запятая появится внутри кавычек, или сервер выдаст длинную строку или много полей?

Может показаться, что со всем этим нетрудно справиться, ведь "библиотека" мала и, в конце концов, является всего лишь прототипом. Представьте, однако, что этот код, пролежав в забвении месяцы или годы, в какой-то момент станет частью большой программы, спецификации которой будут/ меняться. Как адаптируется csvgetline?

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

Библиотека для распространения Теперь с учетом того, чему мы научились на опыте прототипа, попробуем создать библиотеку общего назначения. Наиболее очевидные требования такие: csvgetline должна быть более устойчива, то есть уметь обрабатывать и длинные строки, и большое количество полей;

более осторожно надо подойти и к синтаксическому разбору полей.

Для создания интерфейса, который могли бы использовать и другие люди, мы должны выработать решения по аспектам, перечисленным в начале главы:

интерфейсы, сокрытие деталей, управление ресурсами и обработка ошибок;

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

Интерфейс. Мы выработали решение о трех базовых операциях:

char *csvgetline(FILE *): читает новую CSV строку;

char *csvf ield(int n): возвращает n-е поле текущей строки;

int csvnf leld(void): возвращает число полей в текущей строке.

Какое значение должна возвращать csvgetline? Желательно, чтобы она возвращала побольше полезной информации;

тогда напрашиваете* возвращение того же количества полей, как и в прототипе. Но тогда количество полей будет подсчитываться даже в случае, если поля эти больше использоваться не будут. Еще один вариант возврата — длина вводимой строки, но это значение зависит от того, включать ли в длину завершающий символ перевода строки. После ряда экспериментов мы пришли к выводу, что csvgetline должна возвращать указатель на оригинальную строку ввода или NULL, если был достигнут конец файла.

Мы будем удалять символ перевода строки из конца строки, возвращаемой csvgetline, так как, если понадобится, его можно без труда вписать обратно.

С определением поля дело обстоит довольно сложно;

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

Поле является последовательностью из нуля или более символов. Поля разделены запятыми. Открывающие и завершающие пробелы (пропуски) сохраняются. Поле может быть заключено в двойные кавычки, в этом случае оно может содержать запятые. Поля, заключенные в двойные кавычки, могут содержать символы двойных кавычек, представляемые парой последовательных двойных кавычек, — то есть CSV поле "х""у" определяет строку х"у. Поля могут быть пустыми;

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

Поля нумеруются с нуля. Как быть, если пользователь запросит несуществующее поле, вызвав csvfield(-l) или csvfield( 100000)? Мы могли бы возвращать "" (пустую строку), поскольку это значение можно выводить или сравнивать;

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

Однако этот способ не предоставляет возможности отличить пустое поле от несуществующего. Второй вариант — выводить сообщение об ошибке или даже прерывать работу;

несколько позже мы объясним, почему так делать нежелательно.

Мы решили возвращать NULL — общепринятое в С значение для несуществующей строки.

Сокрытие деталей. Библиотека не будет накладывать никаких ограничений ни на длину вводимой строки, ни на количество полей. Чтобы осуществить это, либо вызывающая сторона должна предоставить память, либо вызываемая сторона (то есть библиотека) должна ее зарезервировать. Посмотрим, как это организовано в сходных библиотеках: при вызове функции f gets ей передается массив и максимальный размер;

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

Только функция csvgetline занимается управлением памятью;

вне ее ничего о методах организации памяти не известно. Лучше всего осуществлять такую изоляцию через интерфейс функции: получается (то есть видно снаружи), что csvgetline читает следующую строку — вне зависимости от ее размера, csvfield(n) возвращает указатель на байты п-го поля текущей строки, a csvnf ields возвращает количество полей в текущей строке.

Мы должны будем наращивать память по мере появления длинных строк или большого количества полей. Детали того, как это происходит, спрятаны в функциях csv;

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

Если пользователь вызывает только csvgetline, то нет надобности разделять строку на поля;

это можно сделать по специальному требованию. Происходит ли разделение полей ретиво (eager, непосредственно при чтении строки), лениво (lazy, только когда нужно посчитать количество полей) или очень ленива (very lazy, выделяется только запрошенное поле) — еще одна деталь реализации, скрытая от пользователя.

Управление ресурсами. Мы должны решить, кто отвечает за совместно используемую информацию.

Возвращает ли csvgetline исходные данные или делает копию? Мы решили, что csvgetline возвращает указатель на исходные данные, которые будут перезаписаны при чтении следующей строки. Поля будут созданы в копии введенной строки, и csvf ield будет возвращать указатель на поле в копии строки. При таких соглашениях пользователь должен сам создавать дополнительную копию, если какая-то конкретная строка или поле должны быть сохранены или изменены, и пользователь же отвечает за высвобождение этой памяти после того, как необходимость в ней отпадет.

Кто открывает и закрывает файл ввода? Кто бы ни открывал вводимый файл, он же должен его закрыть;

парные действия должны выполняться на одном уровне или в одном и том же месте. Мы будем исходить из предположения, что csvgetline вызывается с указателем FILE, определяющим уже открытый файл;

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

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

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

Ошибки и недопонимание при разделении ответственности за управление совместно используемыми ресурсами — характерный источник ошибок.

Обработка ошибок. Когда csvgetline возвращает NULL, не существует способа отличить выход на конец файла от ошибки вроде нехватки памяти;

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

Надо принять за постулат, что функции библиотеки не должны просто прерывать исполнение при возникновении ошибки;

статус ошибки должен быть возвращен вызывающей стороне. Также не следует печатать сообщения или выводить окна диалога, поскольку функции библиотеки могут исполняться в системах, где такие сообщения будут мешать чему-то еще. Обработка ошибок — тема, достойная отдельного обсуждения, и мы еще вернемся к ней далее в этой главе.

Спецификация. Все описанные выше решения и допущения должны быть собраны воедино в спецификацию, описывающую средства, предоставляемые csvgetline, и методы ее использования. В больших проектах спецификация должна предшествовать реализации, при этом, как правило, разные люди и даже разные организации создают спецификацию и пишут код. Однако на практике эти работы часто производят параллельно — тогда спецификация и код эволюционируют совместно;

иногда же "спецификация" пишется уже после разработки программы, чтобы приблизительно описать, что же делает код.

Самый грамотный подход — писать спецификацию как можно раньше и (как делали мы) пересматривать ее по мере реализации кода. Чем тщательнее и вдумчивее будет написана спецификация, тем больше вероятность создать хороший продукт.

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

В нашем случае спецификация будет включать в себя прототипы функций и детальное описание их поведения, сделанных допущений и распределения ответственности:

Поля разделены запятыми.

Поле может быть заключено в двойные кавычки: "...".

Поле, заключенное в кавычки, может содержать запятые,но не символы перевода строки.

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

"" и пустая строка равно представляют пустое поле. Предваряющие и заключительные пробелы сохраняются.

char *csvgetline(FILE *f);

читает одну строку из файла ввода f;

подразумевается, что строки во вводе оканчиваются символами \г, \п, \г\пилиЕОЕ.

возвращает указатель на строку (символы конца строки удаляются) или NULL, если достигнут EOF.

строки могут иметь произвольную длину;

возвращается NULL, если превышен резерв памяти, строки рассматриваются как память, доступная только для чтения;

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

char *csvfield(int n);

поля нумеруются начиная с 0. возвращает n-е поле из последней строки, прочитанной csvgetline;

возвращает NULL, если n отрицательно или лежит за последним полем, поля разделяются запятыми.

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

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

возвращает NULL, если превышается резерв памяти, поля рассматриваются как память, доступная только для чтения;

для сохранения или изменения содержимого вызывающая сторона должна сделать копию, при вызове до csvgetline поведение не определено.

int csvnfield(void);

возвращает количество полей в последней строке, прочитанной csvgetIi ne. при вызове до csvget line поведение не определено.

Представленная спецификация все еще оставляет некоторые вопро- < сы открытыми. Например, какие значения должны возвращать csvf ield и csvnf ield, если они вызваны после того, как csvgetline натолкнулась на EOF? Разрешить подобные головоломки непросто даже для маленькой I программы, а для больших систем — исключительно трудно, но очень важно хотя бы попробовать с ними справиться. В противном случае вы рискуете обнаружить пробелы и недочеты уже в ходе реализации проекта.

Остаток параграфа посвящен новой реализации csvgetl i ne, которая COOT- | ветствует нашей спецификации. Библиотека разбита на два файла — заголовочный csv. h и файл воплощения csv. с. В заголовочном файле содержатся объявления функций, то есть представлена общедоступная часть интерфейса. В csv. с содержится собственно рабочий код библиотеки — реализации функций.

Пользователи включают csv. h в свой исходный код и компонуют свой скомпилированный код со скомпилированной версией csv. с;

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

/* csv.h: интерфейс библиотеки csv */ extern char *csvgetline(FILE *f);

/* читает очередную строку */ extern char *csvfield(int n);

/* возвращает поле номер n */ extern int csvnfield(void);

/* возвращает количество полей */ Внутренние переменные, в которых хранится текст, и внутренние функции вроде split объявлены статическими (static), так что они видны только внутри содержащего их файла. Это простейший способ сокрытия информации в программе на С.

enum { NOMEM = -2 };

/* сигнал о нехватке памяти */ static char *line = NULL;

/* вводимые символы */ static char *sline = NULL;

/* копия строки для split */ static int maxline = 0;

/* размер line[] и sline[] */ static char **field = NULL;

/* указатели полей */ static int maxfield = 0;

/* размер fieldf] */ static int nfield = 0:

/* количество полей в field[] */> static char fieldsep[] = ",-";

/* символы - разделители полей */ Переменные инициализируются также статически. Эти начальные значения используются для проверки необходимости создания или наращивания массивов.

Эти объявления описывают простую структуру данных. Массив line содержит вводимую строку;

массив sline создается путем копирования символов из line и вставки разделителя после каждого поля. Массив field указывает на значения в sline.

На диаграмме показано состояние этих трех массивов после того, как была обработана строка ab, "cd", "e""f",, "g, h". Заштрихованные элементы в sline не являются частью какого-либо поля.

А вот как выглядит сама функция csvgetline:

/* csvgetline: получаем одну строку, */ /* при необходимости наращиваем память.

*/ /* Пример ввода: "LU", 86.25,"11/4/1998", "2:19РМ",+4.0625 */ char *csvgetline(FILE *fin) int i, с;

char *newl, *news;

if (line == NULL1) { /*при первом вызове выделяется память*/ maxline = maxfield = 1;

line = (char *) malloc(maxline);

sline = (char *) malloc(maxline);

field = (char **) malloc(maxfield* sizeof(field[0]));

if (line == NULL || sline == NULL | 'field == NULL) { reset ();

return NULL;

/* нехватка памяти */ for (i=0;

(c=getc(fin))!=EOF & & !endofline(fin,c);

i++) { if (i >= maxline-1) { /* увеличение строки */ maxline *= 2;

/* удвоение текущего размера */ if (newl == NULL) { reset();

return NULL;

/* нехватка памяти */ } line = newl;

news = (char *) realloc(sline, maxline);

if (news == NULL) { reset();

return NULL;

/* нехватка памяти */ } sline = news;

} line[i] = c;

} line[i] = ДО';

if (splitO == NOMEM) { reset();

return NULL;

/* нехватка памяти */ } return (с == EOF && i == 0) ? NULL : line;

} Поступающая строка накапливается в строке line, которая при необходимости наращивается, вызывая realloc;

при каждом увеличении размер удваивается, как в параграфе 2.6. Массив sline всегда увеличивается до размера line;

csvgetline вызывает split для создания в отдельном массиве field указателей на поля — этот массив также при необходимости наращивается.

Мы привыкли начинать с очень маленьких массивов и увеличивать их по потребности, чтобы иметь гарантию, что код увеличения массива был выполнен.

Если выделения памяти не происходит, мы вызываем reset для восстановления глобальных значений в их первоначальное состояние, чтобы дать шанс на успех последующему вызову csvgetline:

/* reset: возвращает переменные в начальные значения */ static void reset(void) { free(line);

/* free(NULL) разрешено в ANSI С */ free(sline);

free(field);

line = NULL;

sline = NULL;

field = NULL;

maxline = maxfield = nfield = 0;

} Функция endof line нужна для выявления и обработки ситуаций, когда вводимая строка заканчивается символами возврата каретки, перевода строки, ими обоими вместе или даже EOF:

/* endofline: выявляет и уничтожает \г, \n, \r\n, EOF */ static int endofline(FILE *fin, int c) { int eol;

/eol = (c=='\r' I c=='\n');

if (c == Af) { с = getc(fin);

if (с != Дп' && с != EOF) ungetc(c, fin);

/* прочитано слишком далеко;

*/ /* с возвращается обратно */ } return eol;

} Здесь необходима отдельная функция, поскольку стандартные функции ввода не обрабатывают все многообразие нетривиальных форматов, встречающихся в реальных условиях.

Наш прототип использовал st rtok для определения следующего поля поиском символа-разделителя, которым в принципе является запятая. Однако при таком подходе невозможно обрабатывать запятые, находящиеся внутри кавычек. В split необходимо внести глобальные изменения (хотя ее интерфейс и не изменится).

Представьте себе такие строки ввода:

" " " " " ' ' " " ' ' ' ' Каждая строка содержит по три пустых поля. Для того чтобы split была в состоянии корректно интерпретировать такие строки и им подобные, ее реализацию придется глобально усложнить, — это классический пример того, как особые случаи и граничные условия оказываются доминирующими в программе.

/* split: разделяет строки на поля */ static int spiit(void) { char *p, **newf;

char *sepp;

/* указатель на временный символ-разделитель */ int sepc;

/* временный символ-разделитель */ nfield = 0;

if (line[0] == ДО') return 0;

strcpy(sline, line);

p = sline;

do { if (nfield >= maxfield) { maxfield *= 2;

/* удвоить текущий размер массива */ newf = (char **) realloc(field, - maxfield * sizeof(field[0]));

if (newf == NULL) return NOMEM;

field = newf;

if (*p == "') sepp = advquoted(++p);

/* пропуск первой кавычки */ else sepp = p + strcspn(p, fieldsep);

sepc = sepp[0];

sepp[0] = '\0';

/* окончить поле */ field[nfield++] = p;

p = sepp + 1;

} while (sepc == ',.');

return nfield;

} В теле цикла массив указателей на поля при необходимости увеличивается, после этого вызывается очередная функция, осуществляющая поиск и обработку следующего поля. Если поле начинается с двойной кавычки, advquoted находит поле и возвращает указатель на разделитель, которым поле заканчивается. В противном случае для поиска следующей запятой мы используем библиотечную функцию strcspn(p, s), которая ищет в строке р следующее вхождение любого из символов строки s;

возвращает эта функция количество пропущенных символов.

Двойные кавычки внутри поля представляются парой смежных двойных кавычек;

функция advquoted сжимает такую комбинацию до одной кавычки, а также удаляет кавычки, обрамляющие поле. Дополнительный код добавлен в попытке справиться с правдоподобным вводом, не подходящим под спецификацию, — таким, например, как "abc"def. В подобных случаях мы добавляем в конец поля все, что заключено между второй кавычкой и следующим разделителем. Оказывается, Microsoft Excel использует схожий алгоритм.

/* a'dvquoted: для поля, обрамленного кавычками;

*/ /*/ возвращает указатель на следующий разделитель */ s/atic char *advquoted(char *p) / int i, j;

for (i = j = 0;

p[j] != ДО';

i++, j++) { if (p[j] == '"' && p[++j] != "") { /* копировать до следующего разделителя или \0 */ int k = strcspn(p+j, fieldsep);

memmove(p+i, p+j, k);

i += k;

j += k;

break;

} p[i] = Ptj];

} P[i] = ЛО';

return p + j';

} Поскольку входная строка уже разделена, то реализация csvfield и csvnfield становится тривиальной:

/* csvfield: возвращает указатель на n-е поле */ char *csvfield(int n) { if (n < 0 | n >= nfield) return NULL;

return fieldfn];

} /* csvnfield: возвращает количество полей */ int csvnfield(void) { return nfield;

} Наконец мы можем модифицировать тестирующую программу и проверить эту версию библиотеки: поскольку копия строки ввода сохраняется (чего в прототипе не было), появилась возможность распечатывать сначала исходную строку, а потом уже полученные поля:

/* csvtest main: тестирует CSV библиотеку */ int main(void) { int i;

char *line;

while ((line = csvgetline(stdin)) != NULL) { printf("line = '%s'\n", line);

for (i = 0;

i < csvnfield();

i++) printf("field[%d] = '%s'\n", i, csvfield(i)) } return 0;

} На этом версия на С завершена. Она обрабатывает строки произвольной длины и делает нечто осмысленное даже при некорректном вводе. В результате нам пришлось написать в четыре раза больше кода, чем в прототипе, при этом некоторые фрагменты получились довольно запутанными. Подобное увеличение объема и сложности кода — совершенно типично для перехода от прототипа к полноценному продукту.

Упражнение 4- При разделении полей возможно несколько уровней "ленивости" - -разделять сразу все поля, но только после получения запроса на конкретное поле, выделять только запрошенное поле и, наконец, разделять все поля до запрошенного. Рассмотрите потенциальные преимущества и недостатки перечисленных способов;

реализуйте их и замерьте скорость работы каждого.

Упражнение 4- Добавьте новые возможности в библиотеку. Сделайте так, чтобы:

а) разделитель мог принадлежать к произвольному классу символов;

б) для разных полей существовали разные разделители;

в) разделитель был заменен на регулярное выражение (см. главу 9). На что будет похож получившийся интерфейс?

Упражнение 4- В нашей реализации библиотеки мы применили статическую инициализацию, используемую в С в качестве основы для одноразового переключения: если на входе указатель есть NULL, то выполняется инициализация. Можно, однако, сделать и по другому: заставить пользователя вызывать некотору/ю специальную функцию инициализации — в ней, кстати, могут содержаться некоторые рекомендованные начальные значения для массивов. Попробуйте написать версию, которая объединяла бы все достоинства обоих подходов. Какую роль в вашей версии будет играть reset?

Упражнение 4- Спроектируйте и реализуйте библиотеку для записи данных в формате CSV.

Простейшая версия может просто брать массив строк и печатать их с кавычками и запятыми. Более интересный вариант — использовать форматные строки как printf.

В главе 9 вы найдете некоторые полезные советы.

Реализация на C++ В этом разделе мы напишем версию библиотеки CSV на C++, в которой постараемся преодолеть некоторые ограничения, имеющиеся в С~версии. Нам придется внести некоторые изменения в спецификацию, главным из которых станет то, что функции будут теперь обрабатывать строки C++ вместо массивов символов С.

Использование строк C++ автоматически решит некоторые проблемы, связанные с хранением данных, поскольку управлением памятью вместо нас займутся библиотечные функции. Так, в частности, функции работы с полями будут возвращать строки, которые затем могут изменяться вызывающей стороной, — проект получится более гибким, чем в предыдущей версии.

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

class Csv { // читает и разбирает CSV // пример ввода: "LIT, 86. 25, "11/4/1998", "2:19РМ", +4. public:

Csv(istream& fin = cin, string sep = ",") :

fin(fin), fieldsep(sep) {} int getline(string&);

string getfield(int n);

int getnfieldO const { return nfield;

} private:

istream& fin;

// указатель на файл ввода string line;

// вводимая строка vector field;

// строки полей int nfield;

// количество полей string fieldsep;

// символы разделителей int split();

int endofline(char);

int advplain(const string& line, string& fid, int);

int advquoted(const string& line, string& fid, int);

};

Для конструктора определены параметры, принимаемые по умолчанию, — такой объект Csv будет читать из стандартного входного потока и использовать обычный символ-разделитель;

эти параметры можно изменить, задав другие значения в явном виде.

Для работы со строками класс использует не строки С, а стандартные С++-классы st ring и vector. Для типа st ring не существует невозможного состояния — "пустая" строка означает всего лишь строку нулевой длины, и нет никакого значения, эквивалентного по своему смыслу NULL, который бы мы использовали как сигнал достижения конца файла. Таким образом, Csv: :getline возвращает введенную строку через аргумент, передаваемый по ссылке, используя возвращаемое значение для сообщений о конце файла или ошибках.

// getline: получает одну строку, // по мере необходимости наращивает размер int Csv::getline(string& str) { char c;

for (line = "";

fin.get(c) && !endofline(c);

) line += c;

split();

str = line;

return !fin.eof();

} Операция += здесь переопределяется, чтобы добавлять символ в строку.

Несколько меньше изменений потребуется вносить в endof line. Нам точно так же придется считывать ввод посимвольно, поскольку ни одна из стандартных функций ввода не может обработать все многообразие вариантов.

// endofline: ищет и удаляет \r', \n, \r\n или EOF int Csv::endofline(char с) { int eol;

eol = (c==Ar' || c=='\n');

if (с == V) {, fin.get(c);

if (!fin.eof() && с != '\n',) fin.putback(c);

// слишком много прочитали > return eol;

} А вот как выглядит новая версия функции split:

// split: разделяет строку на поля int Csv::split() { string fid;

int i, j;

nfield = 0;

if (line.lengthO == 0) return 0;

i = 0;

do { if (i < line.length() && line[i] == '".') j = advquoted(line, fid, ++i);

// пропуск кавычки else j = advplain(line, fid, i);

if (nfield >= field.size()) field.push^back(fld);

else field[nfield] = fid;

nfield++;

i = j + 1;

} while (j < line.length());

return nfield;

} Поскольку strcspn не работает со строками C++, нам надо изменить и split, и advquoted. Новая версия advquoted для поиска следующего вхождения символа разделителя использует стандартную С++-функ-цию find_first_of. Вызов s.

find_first_of (fieldsep, j) ищет в строке s первое вхождение любого символа из fieldsep, начиная с позиции ]. Если вхождение найдено не было, возвращается индекс, лежащий за концом строки, так что нам надо будет вернуть его обратно в должный диапазон. Внутренний цикл for в advquoted добавляет в поле fid все символы, расположенные до ближайшего разделителя.

// advquoted: для полей, заключенных в кавычки;

// возвращает индекс следующего разделителя int Csv::advquoted(const string& s, string& fid, int i) { int j;

fid = "";

for (j = i;

j < s.length();

j++) { if (S[j] == "&& s[++j] != ") { int k = s.find_first_of(fieldsep, j);

if (k > s.length()) // разделитель не найден k = s.length();

for (k -= j;

k-- > 0;

) fid += s[j++];

break;

} Функция find_first_of используется также и в новой функции advplain, которая обрабатывает обычные, не заключенные в кавычки поля. Еще раз подчеркнем, что необходимость в этом обусловлена тем, что функции языка С вроде strcspn не могут быть применены к строкам C++, которые представляют собой совершенно особый тип данных.

// advplain: для полей, не заключенных в кавычки, // возвращает индекс следующего разделителя int Csv::advplain(const strings s, strings fid, int i) { int j;

j = s.find_first_of(fieldsep, i);

// поиск разделителя if (j > s.lengthO) // разделитель не найден j = s.lengthO;

fid = string(s, i, j-i);

return j;

} И снова, как и в предыдущей версии, Csv::getfield абсолютно тривиальна, a Csv:

:getnfield настолько коротка, что воплощена прямо в описании класса.

// getfield: возвращает n-e поле string Csv::getfield(int n) { if (n < 0 n >= nfield) return "";

else return field[n];

} Тестовая программа представляет собой несколько упрощенный йа-риант предыдущей версии:

// Csvtest main: тестирует класс Csv int main(void) { string line;

Csv csv;

while (csv.getline(line) != 0) { cout « "Строка = '" « line <<"'\n";

for (int i = 0;

i < csv.getnfieldQ;

i++) cout « "Поле[" « i « "] = '" « csv.getfield(i) « '"\n";

} return 0;

} Использование библиотеки в C++ незначительно отличается от версии на С. В зависимости от компилятора новая версия в сравнении с С-версией дает замедление от 40 % до четырех раз на большом файле из 30 000 строк примерно по 25 полей на строку. Как мы уже выясняли при оценке быстродействия программы markov, подобный разброс зависит от степени проработанности используемых библиотек. Последнее, что остается добавить: исходный код версии C++ получился примерно на 20 % короче.

Упражнение 4- Введите в версию C++ оператор [ ], чтобы к полям можно было обращаться как к csv[i].

Упражнение 4- Напишите библиотеку CSV на Java, а затем сравните все три версии с точки зрения простоты и ясности, надежности и скорости.

Упражнение 4- Перепишите C++ версию кода CSV с использованием класса STL iterator.

Упражнение 4- Версия на C++ предоставляет возможность нескольким независимым экземплярам Csv работать одновременно, никак не мешая друг другу, — в этом выразилось важное достоинство инкапсуляции всего состояния объекта, экземпляры которого можно порождать многократно. Измените версию на С так, чтобы добиться подобного эффекта;

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

Принципы интерфейса В предыдущих параграфах мы прорабатывали детали некоего интерфейса.

Сформулируем теперь в общих чертах, что же такое интерфейс. Интерфейс -- это детализированная, описанная граница взаимодействия между кодом, предоставляющим некоторые возможности, и кодом, который эти возможности использует. Интерфейс определяет, что именно предоставляет своему пользователю некоторый законченный блок кода, каким образом функции (а может быть, и какие-то элементы данных) из этого блока могут быть использованы в остальной части программы. Интерфейс CSV предоставляет пользователю три функции: чтение строки, получение поля и возврат количества полей. Кроме них, пользователь не может получить от нашего кода ничего.

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

Прячьте детали реализации. Реализация, которая стоит за интерфейсом, должна быть скрыта от остальной части программы — с тем чтобы ее можно было изменять, не затронув при этом ничего снаружи. Для этого принципа существует несколько терминов: сокрытие информации (hiding), инкапсуляция, абстракция, модульность и т. п.;

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

Базовые библиотеки большинства языков программирования дают хорошо известные примеры реализации этого принципа, хотя и не всегда удачно разработанные. Одна из наиболее известных среди них — это стандартная библиотека ввода-вывода в С, в ней содержится несколько десятков функций для открытия, закрытия, чтения, записи и другой обработки файлов. Реализация файлового ввода-вывода скрыта в типе данных FILE*;

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

Если заголовочный файл содержит только название структуры, а не полное ее описание, то такой тип называют иногда непрозрачным типом, поскольку свойства его неизвестны, а все операции осуществляются через указатель.

Избегайте глобальных переменных;

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

Мы настоятельно рекомендуем не делать видимыми никаких данных ни в каком виде, — если пользователи смогут по своему желанию менять значения переменных, то чересчур сложно будет сохранять целостность и непротиворечивость данных. С помощью интерфейсов функций достаточно просто задавать жесткие правила доступа, однако этот прин- | цип часто нарушается.

Предопределенные потоки ввода-вывода вроде | stdin и stdout практически всегда определяются как элементы глобального массива структур FILE:

extern FILE iob[_NFILE];

# define stdin (&iob[0]) # define stdout (&iob[1]) # define stderr (&iob[2]) Таким образом, реализация получается абсолютно прозрачной, при ;

этом, несмотря на то что stdin, stdout и stderr выглядят как переменные, присваивать им никаких значений нельзя. Специфическое имяiob основано на соглашении ANSI С, гласящем, что два подчеркивания используются в начале тех имен служебных переменных, которые должны | быть видны. Таким образом, выбранное нами имя, скорее всего, не будет I конфликтовать с именами внутри самой программы.

Классы в C++ и Java — еще более удачные механизмы для сокрытия информации;

их можно считать центральными средствами правильного I использования этих языков. Классы-контейнеры из ЗТЬдля C++, которые мы использовали в главе 3, заходят еще дальше: за исключением некоторых данных о производительности, никакой информации о деталях | реализации не имеется, — следовательно, разработчики библиотеки могут использовать абсолютно любые механизмы.

Ограничьтесь небольшим набором независимых примитивов. Интерфейс должен предоставлять все необходимые возможности, но не более того;

части интерфейса по возможности не должны перекрывать друг друга в плане функциональности. С одной стороны, лучше иметь большое количество функций в библиотеке —.тогда можно подобрать любую необходимую комбинацию. С другой стороны, чем больше интерфейс, тем труднее его написать и поддерживать в дальнейшем, а кроме того, неоправданно большие размеры могут привести к тому, что его будет трудно изучить и, следовательно, использовать оптимально. "Интерфейсы прикладных программ" (Application Program Interfaces, или API) зачастую настолько велики, что ни один смертный, похоже, не в состоянии освоить их целиком.

Для удобства использования некоторые интерфейсы предоставляют несколько способов для выполнения той или иной операции;

с этой тенденцией надо бороться.

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

char с;

putc(c, fp);

fputc(c, fp);

fprintf(fp, "%c", e);

fwrite(&c, sizeof(char), 1, fp);

Pages:     | 1 || 3 | 4 |   ...   | 6 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.