Методические указания по курсовому проектированию для студентов направления 071900 Составители: А. Е. Докторов

СОДЕРЖАНИЕ: Р 17 курсовому проектированию для студентов направления 071900 / Сост.: А. Е. Докторов, Е. А. Докторова. – Ульяновск: Улгту, 2000. – 38 с

МИНИСТЕРСТВО ОБРАЗОВАНИЯ РФ

УЛЬЯНОВСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

РАЗРАБОТКА И ДОКУМЕНТИРОВАНИЕ ПРОГРАММ

МЕТОДИЧЕСКИЕ УКАЗАНИЯ ПО КУРСОВОМУ ПРОЕКТИРОВАНИЮ

ДЛЯ СТУДЕНТОВ НАПРАВЛЕНИЯ 071900

Составители: А.Е.Докторов,

Е.А.Докторова

Ульяновск 2000

УДК 681.3.08 (076)

ББК 32.973-01 я 7

Р 17

Рецензент доцент кафедры «Высшая математика», канд. техн. наук В.В. Селиванов

Одобрено секцией методических пособий научно-методического совета университета

Разработка и документирование программ: Методические указания по

Р 17 курсовому проектированию для студентов направления 071900 / Сост.: А.Е. Докторов, Е.А. Докторова. – Ульяновск: УлГТУ, 2000. – 38 с.

Составлены в соответствии с учебным планом направления 091700. Преследуют цель ориентировать студентов на содержание и порядок выполнения курсовой работы по программированию. Даются основные принципы и технология структурного программирования. Излагаются необходимые сведения по составу программной документации и требования к ней, соответствующие государственным стандартам ЕСПД. Работа подготовлена на кафедре ИВК.

УДК 681.3.08 (076)

ББК 32.973-01 я 7

© Оформление УлГТУ, 2000

© А.Е. Докторов,

Е.А. Докторова, 2000

Содержание

Содержание .................................................................................................... 3

ВВЕДЕНИЕ .................................................................................................... 4

1. ЦЕЛЬ КУРСОВОЙ РАБОТЫ ................................................................. 4

2. СУЩНОСТЬ СТРУКТУРНОГО ПРОГРАММИРОВАНИЯ .............. 5

2.1. Проектирование «сверху вниз» ......................................................... 5

2.2. Модульное программирование ......................................................... 6

2.3. Структурное кодирование .................................................................. 8

2.4. Технология структурного программирования ............................... 8

3. ДОКУМЕНТИРОВАНИЕ И СТАДИИ РАЗРАБОТКИ ПРОГРАММЫ 10

3.1. Общие сведения о ЕСПД ................................................................... 13

3.2. Содержание программных документов ......................................... 15

3.2.1. Техническое задание ....................................................................... 15

3.2.2. Текст программы ............................................................................ 16

3.2.3. Описание программы .................................................................... 16

3.2.4 Программа и методика испытаний ............................................... 17

3.2.5. Описание применения .................................................................... 17

3.3. Стадии разработки программы ...................................................... 18

4. ПРИМЕР РАЗРАБОТКИ ПРОГРАММЫ ............................................ 18

4.1. Постановка задачи ............................................................................ 18

4.2. Предварительный анализ задачи .................................................... 19

4.3. Проектирование программы ........................................................... 20

4.3.1. Подготовительный этап работы программы .......................... 21

4.3.2. Основной цикл работы программы .......................................... 30

4.3.3. Завершение работы программы ................................................ 35

5. ОФОРМЛЕНИЕ ПОЯСНИТЕЛЬНОЙ ЗАПИСКИ ............................ 36

СПИСОК ЛИТЕРАТУРЫ .......................................................................... 37

ВВЕДЕНИЕ

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

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

1. ЦЕЛЬ КУРСОВОЙ РАБОТЫ

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

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

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

2. СУЩНОСТЬ СТРУКТУРНОГО ПРОГРАММИРОВАНИЯ

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

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

Структурное программирование включает три главные составляю­щие:

1. Проектирование «сверху вниз».

2. Модульное программирование.

3. Структурное кодирование.

2.1. Проектирование «сверху вниз »

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

Сначала необходимо уяснить постановку задачи и четко ее из­ложить. Приступая к проектированию, нужно на естественном языке описать то, что надлежит сделать. До этого момента к программиро­ванию приступать нельзя, поскольку такая попытка заведомо будет обречена на провал. Считается, что правильная постановка задачи - это 90% ее решения.

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

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

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

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

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

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

2.2. Модульное программирование

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

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

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

1) программный модуль не содержал ошибок и не зависел от контекста, в котором он будет использоваться;

2) из модулей можно было формировать большие программы без каких-либо предварительных знаний о внутренней работе модуля.

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

Примерное наилучшее ограничение в размере модуля - не более 60 строк (допустимы исключения). Такая длина удобна для восприя­тия на странице или на дисплее.

Модули по возможности должны быть независимыми. Каждый мо­дуль должен не зависеть: а) от источника входных данных; б) от места назначения выходных данных и в) от предыстории. В противном слу­чае резко возрастает сложность системы. При соблюдении этих усло­вий изменение в одной подпрограмме не повлияет на остальную часть программы. Воздействие изменения в одном модуле на другую часть программы получило название волнового эффекта. Этот эффект сво­дится к минимуму уменьшением связей между модулями.

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

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

Разбиение на модули должно происходить на стадии проектиро­вания «сверху вниз». Для каждого модуля должны быть определены:

а) алгоритм решения задачи;

б) область допустимых входных значений;

в) область возможных выходных значений;

г) возможные побочные эффекты.

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

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

- главная процедура должна принимать все решения по управлению потоком данных для соответствующих обрабатывающих процедур;

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

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

2.3. Структурное кодирование

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

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

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

1) последовательности операторов;

2) выбора одного из двух операторов (IF THEN ELSE);

3) повторения оператора, пока выполняется некоторое условие.

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

2.4. Технология структурного программирования

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

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

Рекомендуемый вариант оформления функциональной спецификации может содержать разделы:

1) имя-заголовок (идентификатор модуля со списком формальных параметров);

2) назначение модуля;

3) неформальное описание (краткое изложение выполняемых функций);

4) ссылки (перечни вызывающих и вызываемых модулей);

5) алгоритм (с использованием псевдокодов или схем алгорит­мов);

6) данные (описание формальных параметров, глобальных и ло­кальных переменных с указанием структуры, типов и атрибутов раз­мерности).

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

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

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

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

3. ДОКУМЕНТИРОВАНИЕ И СТАДИИ РАЗРАБОТКИ ПРОГРАММЫ

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

При разработке программной докумен­тации нужно придерживаться государственных стандартов, объединен­ных в Единую систему программной документации (ЕСПД).

Согласно ГОСТ 19.101-77 «Виды программ и программных доку­ментов» программы делятся на компоненты и комплексы. Компонент - это программа, рассматриваемая как единое целое, выполняющая за­конченную функцию и применяемая самостоятельно или в составе комплекса. Комплекс - это программа, состоящая из двух или более компонентов и (или) комплексов, выполняющих взаимосвязанные функ­ции, и применяемая самостоятельно или в составе другого комплекса.

Указанный стандарт определяет в качестве программных документы, содержащие сведения, необходимые для разработки, изготовления, сопровождения и эксплуатации программы. Все документы делятся на две группы: программные (таблица1) и эксплуатационные (таблица 2).

Таблица 1

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

Таблица 2

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

Строгой регламентации перечня документов для каждой программы ГОСТ 19.101—77 не устанавливает, так как сложность программы и условия ее эксплуатации могут варьиро­ваться в таких широких пределах, что невозможно точно указать, какая именно документация должна быть разработана в каждом конкретном случае. По этой причине ГОСТ 19.101-77 допускает объединение отдельных видов эксплуатационных документов (за исключением ведомости эксплуатационных документов и форму­ляра).

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

Техническое задание* .

Описание программы.

Текст программы.

Программу и методику испытаний (тестирования).

Описание применения.

Поскольку вся документация, разрабатываемая в процессе вы­полнения курсовой работы, должна отвечать требованиям ЕСПД, ниже приводится необходимая часть содержания стандартов.

3.1. Общие сведения о ЕСПД

Согласно ГОСТ 19.001—93 «Единая система программной доку­ментации. Общие требования», ЕСПД - это комплекс государ­ственных стандартов, устанавливающих взаимоувязанные правила разработки, оформления и обращения программ и программной документации.

Регламентация указанных процессов обеспечивает возмож­ность:

- унификации программных изделий для взаимного обмена программами и применения ранее разработанных программ в но­вых разработках;

- снижения трудоемкости и повышения эффективности разработки, сопровождения, изготовления и эксплуатации про­граммных изделий;

- автоматизации изготовления и хранения программной документации.

Каждый документ должен иметь титульный лист и лист утвержде­ния. Правила их заполнения регламентируются ГОСТ 19.104-78 «Еди­ная система программной документации. Основные надписи».

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

Лист утверждения оформляется на каждый программный до­кумент на листах формата А4 (ГОСТ 2.301—68) независимо от вида документа, который может быть выполнен на любом носителе данных.

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

Программные документы подразделяются в зависимости от способа выполнения и характера применения на подлинники, дубликаты и копии (ГОСТ 2.102—68), предназначенные для разработки, сопровождения и эксплуатации программы.

Титульный лист заполняют по форме и правилам, установленным для листа утверждения.

Правила оформления последующих листов программных документов регламентируется ГОСТ 19.105—78 «Единая система программной документации. Общие требования к программной документации».

Согласно этому стандарту программный документ состоит из следующих условных частей:

- титульной;

- информационной;

- основной;

- регистрации изменений.

Титульная часть состоит из листа утверждения и титульного листа.

Информационная часть включает аннотацию и содержание (перечень разделов, подразделов с указанием номеров страниц). В аннотации приводятся сведения о назначении документа и краткое изложение его основной части.

Состав и структура основной части программного документа устанавливается другими стандартами ЕСПД (с частью из них мы познакомимся ниже).

Программные документы выполняют на листах формата А4 (ГОСТ 2.306-68).

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

лист утверждения;

титульный лист (первый лист документа);

информационная часть:

аннотация;

лист содержания;

основная часть:

текст документа (с рисунками, таблицами и т. п.);

приложения;

перечень терминов;

перечень сокращений;

перечень рисунков;

перечень таблиц;

предметный указатель;

перечень ссылочных документов;

перечень символов и числовых коэффициентов;

часть регистрации изменений;

лист регистрации изменений.

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

Рассматриваемый ГОСТ 19.106-78 устанавливает правила оформления, размещения в документе и нумерации текста, рисунков, таблиц и формул (из-за ограниченности объема методических указаний они здесь не приводятся).

Иллюстрированный материал, таблицы или текст вспомогательного характера допускается оформить в виде приложений. Приложения оформляют как продолжение данного документа или выпускают в виде отдельного документа. Каждое приложение должно начинаться с новой страницы с указанием в правом верхнем углу слова «ПРИЛОЖЕНИЕ» и иметь тематический заголо­вок, записываемый симметрично тексту прописными буквами. На прило­жения должны быть даны ссылки в основном документе. Все приложения должны быть перечислены в листе «Содержание».

3.2. Содержание программных документов

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

3.2.1. Техническое задание

Порядок построения и оформления технического задания (ТЗ) на разработку программы или программного изделия устанавли­вается ГОСТ 19.201-78 «Единая система программной документа­ции. Техническое задание. Требования к содержанию и оформле­нию».

На ТЗ оформляются лист утверждения и титульный лист. В документ не включаются информационная часть и лист регистра­ции изменений. Изменения и дополнения в Т3 на последующих стадиях разработки оформляют в виде дополнения к нему. ТЗ содержит следующие разделы:

- введение (наименование, краткая характеристика области применения программы и объекта, в котором исполь­зуют программу);

- основание для разработки (документы), на базе которых ведется разработка; организация, утвердившая этот документ, и дата его утверждения; наименование и (или) условное обозначение темы разработки;

- назначение разработки (функциональное и эксплуатационное назначение программы);

- требования к программе или программному изделию (см. ниже);

- требования к программной документации (состав и специальные требования к ней);

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

- стадии и этапы разработки (содержание работ на каж­дом этапе, сроки и исполнители);

- порядок контроля и приемки (виды испытаний и общие требования к приемке работы).

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

Раздел «Требования к программе или программному изделию» должен содержать подразделы:

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

- требования к надежности;

- условия эксплуатации (для выбранных типов носителей данных);

- требования к составу и параметрам технических средств (их основные технические характеристики);

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

- требования к маркировке и упаковке;

- требования к транспортировке и хранению;

- специальные требования.

3.2.2. Текст программы

Требования к содержанию и оформлению текста программы устанавливаются ГОСТ 19.401-78 «Единая система программной документации. Текст программы». Согласно этому стандарту составление информационной части (аннотации и содержания) является необязательным. Основная часть документа должна состоять из одного или нескольких разделов, которым даны наименования. Каждый из разделов реализуется одним из типов символической записи (например, запись на исходном языке). В символическую запись разделов рекомендуется включать комментарии.

3.2.3. Описание программы

Требования к описанию программы устанавливает ГОСТ 19.402—78 «Единая система программной документации. Описание программы». Согласно этому стандарту составление информационной части (аннотации и содержания) не обязательно. Описание программы должно включать разделы:

- общие сведения (обозначение и наименование про­граммы - программное обеспечение, необходимое для функционирования программы, языки программирования, на которых она написана);

- функциональное назначение (классы решаемых задач и/или назначение программы и сведения о функциональ­ных ограничениях на применение);

- описание логической структуры (алгоритм программы, используемые методы, структура программы с описанием функции составных частей и связи между ними, связи программы с другими программами);

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

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

- входные данные (характер и организация, формат, опи­сание и способ кодирования входных данных);

- выходные данные (то же, что и для входных данных).

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

3.2.4 Программа и методика испытаний

Требования к программе и методике испытаний устанавлива­ются ГОСТ 19.301-79 «Единая система программной документа­ции. Программа и методика испытаний». Согласно этому стандарту составление информационной части не обязательно. Документ должен содержать разделы:

- объект испытаний (наименование, область применения и обозначение испытуемой программы);

- цель испытания;

- требования к программе (требования, подлежащие про­верке во время испытаний и заданные в ТЗ на про­грамму);

- требования к программной документации (состав про­граммной документации, предъявляемой на испытания, а также специальные требования, если они заданы в ТЗ на программу);

- средства и порядок испытаний (технические и про­граммные средства, используемые во время испытаний, а также порядок их проведения);

- методы испытаний (описания проверок с указанием ре­зультатов проведения испытаний — перечней тестовых примеров, контрольных распечаток тестовых примеров и т. п.).

3.2.5. Описание применения

Требования к описанию применения программы определены ГОСТ 19.502—78 «Единая система программной документации. Описание применения».

Составление информационной части является обязательным.

Текст документа должен включать разделы:

- назначение программы (возможности программы, ее основные характеристики, ограничения, накладываемые на область применения программы);

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

- описание задачи (определения задачи и методы ее ре­шения);

- входные и выходные данные.

3.3. Стадии разработки программы

Стадии разработки программ и программной документации ус­танавливаются ГОСТ 19.102-77 «Единая система программной документации. Стадии разработки».

Стадии разработки должны быть следующие:

1. Техническое задание.

2. Эскизный проект.

3. Технический проект.

4. Рабочий проект.

5. Внедрение.

Этапы и содержание работ должны соот­ветствовать приведенным в таблице в ГОСТ 19.102-77.

Примечания:

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

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

4. ПРИМЕР РАЗРАБОТКИ ПРОГРАММЫ

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

4.1. Постановка задачи

Задание. Разработать программу для автоматизации заполнения таблицы.

Форма таблицы задается в отдельном текстовом файле.

Например, это файл Tab_Form.txt, имеющий вид:

Price-list (Процессоры)

N п/п	Фирма изготовитель	Частота, МГц	Дополнительные сведения	Кол-во	Цена	Сумма
…………….
Перемещение по таблице клавишами стрелок. Для изменения содержимого поля - Enter. Выход из программы - Esc.

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

а) целое число;

б) перечисляемый тип;

в) целое число;

г) строка;

д) целое число;

е) и ж) действительное число.

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

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

4.2. Предварительный анализ задачи

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

1. Чтение данных из текстового файла.

2. Запись данных в текстовый файл.

3. Преобразование из текста в соответствующий тип в структуре типа запись (для хранения в процессе работы программы).

4. Преобразование из соответствующего типа в текст (для вывода на экран или в текстовый файл).

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

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

4.3. Проектирование программы

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

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

Исходя из этих соображений, общую структуру программы представим в виде:

Листинг 1

procedure Init; { Инициализация }

begin

end;

procedure Run; { Основной цикл }

begin

end;

procedure Done; { Завершение работы }

begin

end;

begin { Начало основной программы }

Init; {Инициализация }

Run; { Основной цикл }

Done; { Завершение работы }

end; { Конец основной программы }

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

4.3.1. Подготовительный этап работы программы

На этапе инициализации необходимо выполнить:

1) считывание и распечатку на экране формы таблицы;

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

3) считывание данных из таблицы и размещение их в одномерном массиве записей.

Первое действие при работе по первому пункту состоит только лишь в чтении из текстового файла и распечатки его содержимого на экране:

Листинг 2

uses Crt;

procedure Init; { Инициализация }

var F:Text; S:string;

begin

ClrScr; { Очистить экран }

{ Открыть файл для чтения и проверить правильность открытия }

Assign(F,Tab_Form.txt);

{$I-} { Убрать автоматический контроль за открытием файла }

Reset(F);

{$I+} { Установить автоматический контроль за открытием файла }

if IOResult0 then

begin

writeln(Не найден файл Tab_Form.txt.); writeln(Программа завершает работу.);

writeln(Для продолжения нажмите любую клавишу.); ReadKey; Halt(1); end;

{ Распечатать форму таблицы на экране }

repeat

ReadLn(F,S); WriteLn(S); until EOF(F);

end;

procedure Run; { Основной цикл }

begin

repeat

until KeyPressed;

end;

procedure Done; { Завершение работы }

begin

ClrScr; end;

begin { Начало основной программы }

Init; { Инициализация }

Run; { Основной цикл }

Done; { Завершение работы }

end. { Конец основной программы }

Учитывая, что будем открывать не только файл формы таблицы, но и файл таблицы, а также то, что необходимо будет не только чтение, но и запись в файл таблицы, изменим процедуру инициализации. При этом однотипные действия объединим в одну процедуру. Одной из таких процедур оказывается процедура открытия текстового файла OpenTextFile. Вводим также тип, который определяет направление пересылки данных: чтение - из файла в программу, запись - из программы в файл. При этом изменится процедура Init и будет завершен первый пункт этапа инициализации (считывание и распечатка на экране формы таблицы). Теперь, чтобы выделить изменения, листинг не будет приводиться целиком, а будет содержать измененные части (пропуски текста программы будут обозначены многоточием).

Листинг 3

type Directions=(ReadFile,WriteFile); { Направление чтение/запись }

...

{ Процедура открытия текстового файла }

procedure OpenTextFile( FileName:String; { Имя файла }

var F:Text; { Файловая переменная }

Direction:Directions); { Направление }

var OK:boolean; { Открытие файла прошло успешно }

begin { OpenTextFile }

Assign(F,FileName); OK:=True;

case Direction of

ReadFile: { Открытие файла для чтения }

begin

{$I-} Reset(F); {$I+}

if IOResult0 then

begin

ClrScr; writeln(Не найден файл ,FileName,.); OK:=False;

end;

end;

WriteFile: { Открытие файла для записи }

begin

{$I-} ReWrite(F); {$I+}

if IOResult0 then

begin

ClrScr; writeln(Ошибка открытия ,FileName,.); OK:=False; end;

end;

end; { Case }

if not OK then

begin

writeln(Программа завершает работу.);

writeln(Для продолжения нажмите любую клавишу.); ReadKey; Halt(1); end;

end; { OpenTextFile }

...

{ Процедура инициализации }

procedure Init;

{ Процедура чтения формы таблицы из файла }

procedure ReadTableForm;

var F:Text; S:string;

begin

OpenTextFile(Tab_Form.txt,F,ReadFile);

repeat

readln(F,S); writeln(S); { Чтение и распечатка очередной строки }

until EOF(F);

Close(F);

end;

begin { Init }

ClrScr; { Очистить экран }

ReadTableForm; { Чтение формы таблицы из файла }

end; { Init } …

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

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

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

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

Nrow - Количество строк в таблице.

Ncol - Количество столбцов в таблице.

InitRow - Начальная строка данных в таблице.

ColPos - Массив положений столбцов на экране.

Листинг 4

{ Глобальные константы, определяющие максимальный размер таблицы }

const

MaxRows=20;{ Максимальное количество строк }

MaxCols=10; { Максимальное количество столбцов }

type

{ Тип для массива местоположений столбцов таблицы на экране }

ColumnsPositionsArray=array[1..MaxCols] of byte;

{ Перечисляемый тип для описания фирмы-изготовителя }

Corporations=(Intel,AMD,Cyrix);

{ Массив имен фирм-изготовителей }

const CorpName:array[Intel..Cyrix] of string=(Intel,AMD,Cyrix);

type

Processor=record { Тип записи в строке таблицы }

N:byte; { Номер по порядку }

Corp:Corporations; { Наименование фирмы }

Freq:word; { Частоты }

Notice:string; { Замечания }

Count:word; { Количество }

Price:real; { Цена }

Summ:real; { Сумма }

end;

{ Тип массива записей в таблице }

ProcessorArray=array[1..MaxRows] of Processor;

...

{ Процедура подготовки программы к работе (инициализации) }

procedure Init( { П а р а м е т р ы п р о ц е д у р ы }

var X, { Номер столбца в таблице }

Y, { Номер строки в таблице }

Nx, { Количество строк в таблице }

Ny, { Количество столбцов в таблице }

InitY:byte; { Номер начальной строки в таблице на экране}

var Xpos:ColumnsPositionsArray; { Массив координат столбцов}

var P:ProcessorArray); { Массив записей в таблице }

{ Процедура чтения формы таблицы из файла }

procedure ReadTableForm;

var F:Text; S:string; TableEnd:boolean; X,Y:byte;

{ Процедура определения координаты начала столбца }

procedure ColumnsPositions;

var Xp:byte;

begin { ColumnsPositions }

InitY:=Y; Nx:=1; Xpos[Nx]:=2;

for Xp:=2 to length(s) do

if s[Xp]=chr(197) { Признак конца очередного столбца +}

then begin inc(Nx); Xpos[Nx]:=Xp+1; end;

Xpos[Nx+1]:=Xp+1; { Начало следующего столбца }

end; { ColumnsPositions }

begin { ReadTableForm }

Ny:=0; Nx:=0; Y :=0; X :=0;

InitY:=0; TableEnd:=False;

OpenTextFile(Tab_Form.txt,F,ReadFile);

repeat

readln(F,S); writeln(S); { Чтение и распечатка очередной строки }

if s[1]=chr(192) then TableEnd:=True; { Признак конца таблицы }

if (InitY0)and(not TableEnd) then inc(Ny); { Счет строк таблицы }

if s[1]=chr(195) then ColumnsPositions; {Определение координат столбцов}

until EOF(F);

Close(F);

end; { ReadTableForm }

...

{ Глобальные переменные }

var

Nrow, { Количество строк в таблице }

Ncol, { Количество столбцов в таблице }

InitRow {Координата начальной строки данных таблицы на экране}

:byte;

ColPos: { Положение столбца на экране }

ColumnsPositionsArray;

begin { Основная программа }

{ Инициализация }

Init(Ncol,Nrow,InitRow,ColPos);

Run; { Основной цикл }

Done; { Завершение работы }

end. { Основная программа }

Теперь можно перейти к последнему пункту инициализации - чтению данных из файла таблицы, преобразованию данных из строки в соответствующий тип, размещению данных в одномерном массиве и на экране. Этим в процедуре Init будет заниматься локальная процедура ReadTable. Для начала она будет только выводить на экран считанную из файла строку данных в поля таблицы, используя процедуру перемещения курсора по клеткам таблицы (MoveCursor, которую также добавим на этом этапе).

Листинг 5

{ Процедура перемещения курсора по клеткам таблицы }

procedure MoveCursor

({ П а р а м е т р ы п р о ц е д у р ы }

X, { Номер столбца в таблице }

Y, { Номер строки в таблице }

InitY { Номер начальной строки в таблице на экране }

:byte;

Xpos { Массив координат столбцов }

:ColumnsPositionsArray);

begin

GotoXY(Xpos[X]+1,Y+InitY); end;

{ Процедура подготовки программы к работе }

procedure Init(

var X, { Номер столбца в таблице }

Y, { Номер строки в таблице }

Nx, { Количество строк в таблице }

Ny, { Количество столбцов в таблице }

InitY { Номер начальной строки в таблице на экране }

:byte;

var Xpos { Массив координат столбцов }

:ColumnsPositionsArray;

var P { Массив записей в таблице }

:ProcessorArray);

...

procedure ReadTable;

var

Line, { Номер строки в таблице }

Column { Номер столбца в таблице }

:byte;

Field { Содержимое поля в виде строки }

:string;

F:Text; { Текстовый файл с таблицей }

S:string; { Строка текстового файла с таблицей }

begin

OpenTextFile(Table.txt,F,ReadFile);

for Line:=1 to InitY do ReadLn(F,S); { Пропустить шапку }

for Line:=1 to Ny do

begin

ReadLn(F,S);

for Column:=1 to Nx do

begin

{ Выделение поля из строки }

Field:=Copy(S,Xpos[Column]+1,Xpos[Column+1]-Xpos[Column]-3);

{ Распечатка содержимого поля на экране

(потом на этом месте должна быть процедура ввода поля) }

MoveCursor(Column,Line,InitY,Xpos); Write(Field);

end;

end;

end;

begin { Init }

ClrScr; { Очистить экран }

ReadTableForm; {Чтение формы таблицы из файла }

ReadTable; { Чтение таблицы из файла }

{Установка курсора в начало таблицы }

Y:=1; X:=1; MoveCursor(X,Y,InitY,Xpos);

end; { Init }

...

Как при вводе данных из файла, так и с клавиатуры, вводимые данные представлены в виде строки, поэтому есть необходимость преобразования данных из строки к типу, соответствующему тому или иному полю таблицы. Эти действия переданы процедуре «Ввод поля» (EnterField), взамен простой распечатки на экране монитора, как это было сделано на предыдущем этапе. Параметры, необходимые для работы процедуры, представлены в листинге 6.

На данную процедуру возложено выполнение многих функций:

а) получать строку данных из файла или вызывать ввод с клавиатуры (функция KeyBoardInput, которую на данном этапе не будем пока рассматривать подробно, а только представим формальное описание; кроме того, заметим, что логическая переменная KeyBoard будет определять, откуда процедура EnterField берет строку данных: или с клавиатуры, после вызова функции KeyBoardInput, или из файла в строке FileStr;

б) приводить строку к виду без начальных и конечных пробелов (процедура

DeleteSpaces);

в) сравнивать длину вводимой строки с шириной поля таблицы (функция LengthCompare);

г) преобразовывать данные из строкового типа в тип данных соответствующего поля ( процедуры StrToByte, StrToCorp, StrToWord, StrToReal, которые здесь использованы, но без описания и подробных объяснений, так как эти процедуры достаточно просты, хотя и обязательно должны содержать проверку правильности преобразования из строки в соответствующий тип);

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

Листинг 6

{ Процедура ввода поля таблицы }

procedure EnterField(

{ П а р а м е т р ы п р о ц е д у р ы }

KeyBoard:boolean; { Ввод с клавиатуры или из файла }

P:ProcessorArray; { Массив записей }

R, { Номер строки }

C, { Номер столбца }

Ny, { Количество строк }

InitY:byte; { Начало таблицы на экране }

Xpos: { Координаты столбцов на экране}

ColumnsPositionsArray;

FileStr:string; { Строка из файла }

{ Л о к а л ь н ы е п е р е м е н н ы е в п р о ц е д у р е }

var i,StrLen:byte; S:string; E:boolean;

{ Процедура вывода курсора в специальную строку.

Используется при вводе с клавиатуры и выводе сообщений об ошибке } procedure GoToSpecialLine(LineNum:byte { Номер строки });

begin

{ Переход в строку под таблицей }

GotoXY(1,InitY+Ny+1+LineNum);

end;

{Функция ввода с клавиатуры }

function KeyBoardInput:string;

begin { KeyBoardInput }

KeyBoardInput:=Функция ввода с клавиатуры.;

end; { KeyBoardInput }

{Процедура вывода сообщения об ошибке }

procedure Error(

S:string; { Строка сообщения }

var Sf:string); {Строка ввода поля данных в таблице }

begin

Sf:=; GoToSpecialLine(1); Write( ,S); Delay(2000);

GoToSpecialLine(1); ClrEol; MoveCursor(C,R,InitY,Xpos);

end;

{Функция сравнения длины вводимой строки с шириной поля таблицы }

function LengthCompare(

C:byte; {Номер столбца таблицы }

S:string; {Введенная строка }

var StrLen:byte {Ширина поля в таблице })

: boolean;

begin

StrLen:=(Xpos[C+1]-Xpos[C]-3); LengthCompare:=(StrLen=length(S)); end;

...

begin { основная часть процедуры EnterField }

{ Ввод строки или с клавиатуры, или из файла }

if KeyBoard then S:=KeyBoardInput else S:=FileStr;

DeleteSpaces; { Удаление пробелов в начале и в конце строки }

if S then { Если строка ввода не пустая }

begin

if LengthCompare(C,S,StrLen)

then { если длина строки не больше столбца }

begin

with P[R] do { Преобразования из строки в тип поля }

case C of { Выбор по номеру поля }

1: StrToByte(S,N); 2: StrToCorp(S,Corp);

3: StrToWord(S,Freq); 4: Notice := S;

5: StrToWord(S,Count); 6: StrToReal(S,Price);

7: StrToReal(S,Summ);

end;

if S then

begin { Если преобразование прошло без ошибок }

{ Вывод значения поля в виде строки на экран }

MoveCursor(C,R,InitY,Xpos);

while length(S)StrLen do S:= +S; { Добавление пробелов }

Write(S); { Вывод строки }

end;

end

else { Если длина строки больше столбца }

Error(Длина строки ввода больше ширины столбца.,S); end;

{ Вернуть курсор в соответствующую ячейку таблицы }

MoveCursor(C,R,InitY,Xpos);

end; { Основная часть процедуры EnterField } …

4.3.2. Основной цикл работы программы

Теперь процесс инициализации работы программы завершен, и пришла пора более подробного описания процедуры основного цикла работы программы (Run). Здесь основным является управление процессом работы и ввод данных с клавиатуры (функция KeyBoardInput).

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

- команды управления курсором;

- команды завершения ввода или завершения выбора;

- команды редактирования строки ввода данных с клавиатуры;

- команды выхода или отказа.

Команды представим перечисляемым типом:

type

Commands=(

cmLeft, cmRight, cmUp, cmDown, { управление курсором }

cmEnter, { завершение ввода/выбора }

cmBackSpace,cmDelete, { редактирование строки }

cmExit, { выход или отказ }

cmEmpty { пустая команда });

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

type

EventType=record { Тип события - это запись }

Key:char; { Какая клавиша нажата }

Command:Commands; {Какой команде соответствует нажатие этой клавиши } end;

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

Первое применение для процедуры GetEvent сделаем в процедуре Run, где будем принимать в цикле события до тех пор, пока не поступит команда выхода из программы cmExit, а также будем обрабатывать команды перемещения курсора по таблице, используя процедуру ExecutePositionCommand.

Листинг 7

{ Процедура получения события от клавиатуры }

procedure GetEvent(var Event:EventType);

var c:char;

begin

c:=ReadKey; { Прочитать код нажатой клавиши }

with Event do

begin

Command:=cmEmpty;

case ord(c) of { Определить команду по коду нажатой клавиши }

27:Command:=cmExit; 13:Command:=cmEnter; 8:Command:=cmBackSpace;

0:

begin

c:=ReadKey; { Выбор по клавишам, имеющим двойной код }

case ord(c) of

72:Command:=cmUp; { Вверх } 75:Command:=cmLeft; { Влево}

77:Command:=cmRight; {Вправо} 80:Command:=cmDown; {Вниз} 83:Command:=cmDelete; {Удалить}

end; {case}

end;

end; {case}

Key:=c; { Запомнить код нажатой клавиши }

end; {with}

end;

...

{ Основной цикл }

procedure Run ( { П а р а м е т р ы п р о ц е д у р ы }

X, {Номер столбца в таблице }

Y, {Номер строки в таблице }

Nx, {Количество строк в таблице }

Ny, {Количество столбцов в таблице }

InitY:byte; {Номер начальной строки в таблицы на экране }

Xpos:ColumnsPositionsArray; {Массив координат столбцов }

var P:ProcessorArray); { Массив записей в таблице }

{ Процедура выполнения команд перемещения курсора }

procedure ExecutePositionCommand(

{ П а р а м е т р ы п р о ц е д у р ы }

Com:Commands; {Команда для обработки }

var X,Y, {Текущие координаты }

MaxX,MaxY {Границы по координатам }

:byte);

begin

case Com of

cmLeft : if X1 then dec(X); cmRight: if XMaxX then inc(X);

cmUp : if Y1 then dec(Y); cmDown : if YMaxY then inc(Y);

end;

end;

var E:EventType; {Локальная переменная процедуры Run }

begin {Run }

repeat

Getevent(E); { Принять событие от клавиатуры }

with E do

case Command of

cmLeft..cmDown: {Обработка команд перемещения курсора }

begin

ExecutePositionCommand(Command,X,Y,Nx,Ny);

MoveCursor(X,Y,InitY,Xpos); end;

end; {case}

until E.Command=cmExit;

end; { Run }

...

begin {Основная часть программы }

{ Инициализация }

Init(Col,Row,Ncol,Nrow,InitRow,ColPos,Processors);

{ Основной цикл (теперь уже с параметрами) }

Run(Col,Row,Ncol,Nrow,InitRow,ColPos,Processors);

Done; {Завершение работы }

end.

В процедуре Run при получении команды cmEnter будем переходить на процедуру ввода поля данных EnterField, в которой теперь необходимо определить функцию ввода данных с клавиатуры - KeyBoardInput.

{ Основной цикл }

procedure Run

...

case Command of

...

cmEnter:

EnterField(FromKeyBoard,P,Y,X,Ny,InitY,Xpos,);

end; {case}

В функции KeyBoardInput надо также выполнить много действий, которые выделены в отдельные процедуры и функции (эти действия рассмотрим не сразу, а последовательно одно за другим):

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

Листинг 8

{ Ф у н к ц и я в в о д а с к л а в и а т у р ы }

function KeyBoardInput:string;

{ Локальные переменные для функции KeyBoardInput }

var Ev:EventType; Si:string; X,Y:byte; Cor:Corporations;

{ Процедура определения начальных установок }

procedure InitKeyBoardInput;

begin { InitKeyBoardInput }

Ev.Command:=cmEmpty; { Команды нет }

Cor:=P[R].Corp; { Начальное значение для имени корпорации }

{ Вывод дополнительных сообщений }

GoToSpecialLine(2);

Write(Enter - принять изменения, Esc - отказ от изменений.);

GoToSpecialLine(1);

if C=2 { Во втором столбце - выбор вариантов }

then

begin

Write(Выбор значения клавишами стрелок ( - - ): );

ClrEol; X:=WhereX; Y:=WhereY; Write(CorpName[Cor]);

end

else Write(Введите значение: );

end; { InitKeyBoardInput }

- ввод поля выбором вариантов с использованием клавиш стрелок простая, не требующая дополнительных пояснений функция InputByRows;

Листинг 9

{ Функция ввода поля выбором вариантов клавишами стрелок }

function InputByRows:string;

begin { InputByRows }

repeat

GetEvent(Ev);

if Ev.Command in [cmLeft,cmRight] then

begin

case Ev.Command of

cmLeft: if CorIntel then Cor:=Pred(Cor) else Cor:=Cyrix;

cmRight:if CorCyrix then Cor:=Succ(Cor) else Cor:=Intel;

end; {case}

GotoXY(X,Y); ClrEol; Write(CorpName[Cor]);

end;

until Ev.Command in [cmEnter,cmExit];

InputByRows:=CorpName[Cor];

end; { InputByRows }

- ввод данных в виде строки с клавиатуры - функция InputString, реализующая простейшие функции редактирования;

Листинг 10

{ Функция ввода строки с клавиатуры }

function InputString:string;

var S:string; X,Y,i,j:byte;

begin InputString

{Начальные значения вводимой строки и местоположения курсора}

S:=; X:=WhereX; Y:=WhereY; i:=1; repeat

GetEvent(Ev); { Получить событие от клавиатуры }

with Ev do

begin

case Command of { Выбор действий по командам }

cmEmpty: begin {Нет команды, тогда ввод символа }

Insert(Key,S,i); GotoXY(X,Y); write(S); inc(i); end;

cmBackSpace: begin { Удалить символ перед курсором }

Delete(S,i-1,1); GotoXY(X,Y); ClrEol; GotoXY(X,Y); write(S); if i1 then dec(i); end;

cmDelete: begin { Удалить символ после курсора }

Delete(S,i,1); GotoXY(X,Y); ClrEol; GotoXY(X,Y); write(S); end;

cmLeft: if i1 then dec(i); { Курсор влево }

cmRight: if ilength(S)+1 then inc(i); { Курсор вправо }

end; {case}

end; {with}

GotoXY(X+i-1,Y);

until (Ev.Command=cmExit)or(Ev.Command=cmEnter);

if Ev.Command=cmEnter { если команда cmEnter }

then InputString:=S { Тогда принять ввод строки }

else InputString:=; { Иначе отказ от введенных данных }

end; { InputString }

- процедура ClearSpecialLines - убирает с экрана всю дополнительную информацию.

Листинг 11

{ Процедура очистки специальных строк на экране монитора }

procedure ClearSpecialLines;

begin

GoToSpecialLine(1); ClrEol; GoToSpecialLine(2); ClrEol;

end;

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

Листинг 12

begin {KeyBoardInput }

InitKeyBoardInput; { Инициализация ввода с клавиатуры }

if C=2 { Если во втором столбце - выбор вариантов }

then Si:=InputByRows { Ввод поля выбором вариантов }

else Si:=InputString; {Ввод строкой с клавиатуры} ClearSpecialLines;

if Ev.Command=cmEnter

then KeyBoardInput:=Si { Принять ввод строки }

else KeyBoardInput:=; {Отказ от введенных данных }

end; { KeyBoardInput }

4.3.3. Завершение работы программы

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

Листинг 13

{ Завершение работы }

procedure Done(InitY,Ny:byte);

Const ScreenWidth=80; {Ширина экрана }

ScreenLength=25; {Длина экрана }

var i,j:byte; F:Text; S:string;

{ Массив, расположенный в экранной области памяти }

s1:array[0..ScreenWidth*2*ScreenLength] of char absolute $B800:0;

begin {Done }

OpenTextFile(Table.txt,F,WriteFile);

for i:=0 to InitY+Ny do { Для всех строк экранной памяти }

begin

{ Переписать из строки экранной памяти в строку S }

S[0]:=#160; Move(s1[ScreenWidth*2*i],s[1],ScreenWidth*2);

{ Удалить из строки S атрибуты (цвет и т.п.) символа на экране,

то есть каждый второй байт }

j:=1;

while (j+1)=length(S) do begin Delete(s,j+1,1); inc(j); end;

{ Вывести строку в файл }

WriteLn(F,S);

end;

Close(F);

end; { Done }

5. ОФОРМЛЕНИЕ ПОЯСНИТЕЛЬНОЙ ЗАПИСКИ

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

- титульный лист;

- задание на курсовое проектирование;

- аннотацию;

- * техническое задание;

- описание (спецификации) модулей программы;

- *описание программы;

- *текст программы;

- *программа и методика испытаний;

- (если это необходимо).

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

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

СПИСОК ЛИТЕРАТУРЫ

1. Джонс Ж., Харроу К. Решение задач в системе Турбо Паскаль : Пер. с англ. – М.: Финансы и статистика, 1991. – 720 с.

2. Джонстон Г. Учитесь программировать : Пер. с англ. – М.: Финансы и статистика, 1989. – 368 с.

3. Единая система программной документации (сборник стандартов). – М.: Издательство стандартов, 1988. – 143 с.

4. Лингер Р., Миллс Х., Уитт Б. Теория и практика структурного программирования : Пер. с англ. – М.: Мир, 1982. – 406 с.

5. Мик Б. и др. Практическое руководство по программированию : Пер. с англ. – М.: Радио и связь, 1986. -168 с.

6. Приборы, средства автоматизации и системы управления. ТС-3 «Автоматизированные средства управления». Обзорная информация «Методология и технология программирования». – М., 1989. Вып. 1.

7. Тассел Д. Ван. Стиль, разработка, эффективность, отладка и испытание программ : Пер. с англ. – 2-е изд., испр. – М.: Мир, 1985. – 332 с.

8. Шахов Э.К. Разработка и документирование программ. - Пенза: ПГТУ, 1994. - 58 с.

Учебное издание

Разработка и документирование программ

Методические указания по курсовому проектированию для студентов направления 071900

Составители: Докторов Александр Евгеньевич

Докторова Елена Анатольевна

Корректор Ю. М. Кретова

Подписано в печать 18.05.00

Формат 60х84/16. Бумага писчая. Усл. п. л. 2,09 Уч.-изд. л. 2,00 Тираж 50 экз. Заказ

Ульяновский государственный технический университет, 432027, Ульяновск, Сев. Венец, 32.

Типография УлГТУ, 432027, Ульяновск, Сев. Венец, 32.

* Не следует путать техническое задание и задание (бланк) на курсовую работу, получаемое студентом от руководителя. На основании последнего студент разрабатывает техническое задание в соответствии с требованиями ГОСТ 19.101-77 (см. табл.1) и ГОСТ 19.102-77

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

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

Скачать архив с текстом документа