Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
Министерство образования и науки РФ
Федеральное бюджетное государственное
образовательное учреждение
высшего профессионального образования
«Тульский государственный университет»
Политехнический институт
Кафедра "Автоматизированные станочные системы"
Троицкий Д.И.
доцент, к.т.н.
МЕТОДИЧЕСКИЕ УКАЗАНИЯ
ПО ВЫПОЛНЕНИЮ ЛАБОРАТОРНОЙ РАБОТЫ №6
по дисциплине
ИНФОРМАТИКА
Направление подготовки:
230100 Информатика и вычислительная техника
Профиль подготовки:
Системы автоматизированного проектирования
Форма обучения – очная, очно-заочная, заочная
Тула 2011 г.
Рассмотрено на заседании кафедры "Автоматизированные станочные системы"
протокол №1 от "31" августа 2011 г.
Зав. кафедрой________________А.Н. Иноземцев
Содержание
|
[1] Задачи с циклами [2] Цикл с предусловием [2.1] Вечный цикл [3] Цикл с постусловием [4] Цикл с переменной [5] Дополнительные операторы управления циклами [6] Вложенные циклы [7] Статические массивы [8] Многомерные статические массивы [9] Ввод-вывод массивов [9.1] Ввод с клавиатуры [9.2] Считывание массива из файла [10] Поиск максимума и минимума |
После поворота событий от плохого к худшему цикл повторится.
Из законов Мэрфи
Цикл в программировании позволяет выполнить одну и ту же последовательность операторов несколько раз. Циклы используются в трех случаях:
Кроме того, в ряде случаев циклы позволяют избежать повторения одних и тех же операторов. Если в программе есть повторяющиеся фрагменты – она написана неправильно.
Две интересные передачи всегда идут в одно и то же время.
Из законов Мэрфи.
Наиболее общим в Delphi является цикл с предусловием, реализуемый оператором WHILE…DO. Вот его общий вид:
WHILE условие DO
оператор;
В качестве условия может выступать любое логическое выражение или переменная типа BOOLEAN. Работает такой цикл следующим образом. Сначала проверятся условие (отсюда и название – цикл с предусловием). Если условие истинно, то выполняется оператор (он называется "тело цикла"), а затем программа "пятится назад", снова оказывается на операторе WHILE..DO, снова проверяет условие… и так далее до тех пор, пока условие не станет ложным. Как только это случится, цикл прекращается, и начинает выполняться оператор, следующий за телом цикла.
Цикл с предусловием имеет интересную особенность: если в начале его работы условие оказалось ложным, то цикл вообще не будет выполняться ни разу.
Рассмотрим пример использования цикла WHILE. Пусть мы суммируем ряд натуральных чисел 1+2+3+… и хотим узнать, на каком числе этого ряда сумма превысит 100. Программа будет выглядеть следующим образом:
VAR s:WORD; { сумма }
i: WORD; { текущее число ряда }
BEGIN
s:=0; { сумму обязательно обнуляем!!! }
i:=1; { начинаем суммировать с единицы }
WHILE s<100 DO
BEGIN
s:=s+i;
i:=i+1
END;
Label1.Caption:='Сумма превысит 100 при i='+IntToStr(i)
end;
Кстати, сумма превысит 100 при i=15, так как . Обратите внимание на операторные скобки BEGIN..END. Они позволяют поместить в тело цикла более одного оператора (разумеется, если в теле цикла только один оператор, BEGIN…END не нужны).
Рис. . Обозначение цикла с предусловием на блок-схемах.
На блок-схемах все циклы изображаются в виде крышки гроба, самого гроба и лежащего в нем тела цикла. Обозначения же зависят от вида цикла. Для цикла с предусловием блок-схема выглядит, как показано на .
На процессорах Pentium IV вечный цикл выполняется в два раза быстрее!
Из программистского фольклора.
Одна из самых больших неприятностей в программировании – зацикливание. Если при каждом проходе цикла в условии ничего не меняется, то цикл никогда не прекратится и программа "зависнет". Чтобы ее прервать насильно, нужно нажать клавиши Ctrl+C или Ctrl+Break. Вот яркий пример вечного цикла:
s:=0;
WHILE s<100 DO
i:=i+1;
В теле цикла находится только один оператор i:=i+1. Его выполнение никак не влияет на значение переменной s, которое всегда будет равным нулю и, соответственно, меньшим 100. Поэтому такой цикл никогда не прекратится.
Правило: в условии цикла обязательно должна присутствовать переменная6 значение которой изменяется в теле цикла.
Трубку вы схватите как раз тогда, когда в ней зазвучат сигналы отбоя.
Из законов Мэрфи.
Другая разновидность цикла отличается тем, что условие проверяется не до, а после выполнения тела цикла. Поэтому цикл с постусловием обязательно выполняется как минимум один раз. Именно поэтому он не чаще всего не годится для решения вычислительных задач: возникает лишняя итерация (проход) цикла, и, складывая 1+2+3, можно получить ответ 10=1+2+3+4.
Цикл с постусловием записывается оператором REPEAT.. UNTIL. Его общий вид таков:
REPEAT
оператор1
…
оператор n
UNTIL условие;
Тело цикла составляют операторы, стоящие между REPEAT и UNTIL. Дополнительные BEGIN..END здесь не нужны – синтаксис оператора и так позволяет помещать в тело цикла несколько операторов.
Важная особенность цикла REPEAT состоит в том, что его условие является условием прекращения цикла. Цикл прерывается и программа идет дальше, как только условие становится истинным. Напомним, что в цикле WHILE все наоборот- там цикл прерывается, как только условие становится ложным.
Цикл с постусловием идеально подходит для организации контроля корректности вводимых пользователем данных. Например, мы ожидаем ввода числа от 1 до 3 (скажем, при выборе, куда вводить информацию: на экран или в файл). Как обезопасить себя на тот случай, если гнусный пользователь возьмет и введет 4 или 0? Очень просто:
VAR a:BYTE;
BEGIN
…
REPEAT
a:=StrToInt(LabeledEidit1.Text)
UNTIL (a>=1) AND (a<=3);
После ввода числа проверяется условие его нахождения в интервале [1;3]. Если введенное число не попадает в указанный интервал, условие будет ложным и цикл повторится до тех пор, пока условие не окажется истинным.
Обозначение цикла с постусловием на блок-схемах показано на .
Рис. . Обозначение цикла с постусловием на блок-схемах.
Во всякой формуле константы должны рассматриваться как переменные.
Из законов Мэрфи.
Весьма часто возникает необходимость просто выполнить участок программы заданное число раз. Конечно, можно организовать такой цикл при помощи оператора WHILE. Например, нам нужно перебрать все целые числа от 10 до 20 и просуммировать их. Сделать это можно следующим образом:
VAR i: BYTE; s: WORD;
BEGIN
i:=10;
s:=0;
WHILE i<=20 DO
BEGIN
s:=s+i;
i:=i+1
END;
Такая программа работоспособна, но громоздка и некрасива. Есть способ лучше – использовать цикл с переменной FOR..TO. Его общий вид таков:
FOR переменная:=начальное значение TO конечное значение DO
оператор;
Оператор FOR автоматически перебирает значения целой переменной от начального до конечного c шагом 1 и при каждом увеличении переменной на единицу выполняет оператор. Обратите внимание, что оператор FOR работает только с целыми числами и шаг приращения всегда равен единице.
Перепишем нашу программу, используя оператор FOR:
VAR i: BYTE; s: WORD;
BEGIN
s:=0;
FOR i:=10 TO 20 DO
s:=s+i;
Программа стала проще и понятнее. Кстати, не следует думать, что уменьшение длины исходного текста программы приводит и к уменьшению размера создаваемого при компиляции исполнимого файла.
А что делать, если нужно перебирать не целые, а дробные значения? Единственный выход – по-прежнему перебирать целые, а в теле цикла делить их на 10,100,1000… для получения дробного числа. Например, просуммируем числа от 0.1 до 1.2 с шагом 0.1:
VAR i:BYTE; s:REAL;
BEGIN
s:=0.0; { обязательно 0.0, а не 0 – это вещественное число }
FOR i:=1 TO 12 DO
s:=s+i/10;
Иногда нужно перебирать числа в обратную сторону – от большего к меньшему. Обычный цикл FOR в случае, когда начальное значение переменной цикла меньше конечного, вообще не будет выполняться ни разу. Однако в Delphi предусмотрен вариант цикла с переменной, в котором шаг равен минус единице. Все отличие состоит в том, что слово TO заменяется на DOWNTO:
FOR i:=20 DOWNTO 10 DO…
На блок-схемах цикл с переменной изображается так, как показано на .
Рис. . Обозначение цикла с переменной на блок-схемах.
Люди согласны сделать работу, когда необходимость в этом уже отпала.
Из законов Мэрфи.
В теле всех трех циклов можно применять два специальных оператора: BREAK и CONTINUE. Оператор BREAK вызывает досрочный выход из цикла. Например, вернемся к задаче суммирования ряда натуральных чисел 1+2+3+… Мы хотим узнать, на каком числе этого ряда его сумма превысит 100. Программа с BREAK выглядит так:
VAR s:WORD; { сумма }
i: WORD; { текущее число ряда }
BEGIN
s:=0; { сумму обязательно обнуляем!!! }
i:=1; { начинаем суммировать с единицы }
WHILE TRUE DO { вечный цикл?! Не совсем…}
BEGIN
s:=s+i;
i:=i+1;
IF s>100 THEN
BREAK
END;
Label1.Caption:='Сумма превысит 100 при i='+IntToStr(i)
end;
Наличие оператора BREAK позволило смело совершить программистское преступление – написать вечный цикл WHILE TRUE DO. Прерывание цикла при s>100 обеспечивает оператор BREAK.
Оператор CONTINUE, наоборот, переходит в начало цикла и начинает следующую итерацию. Это позволяет пропустить часть итераций. Например, мы хотим вывести на экран все целые числа от 1 до 100, которые не делятся на 3. Делается это так:
VAR i:BYTE
BEGIN
FOR i:=1 TO 100 DO
BEGIN
IF (i MOD 3=0) THEN
CONTINUE;
Memo1.Lines.Add(IntToStr(i))
END;
Обратите внимание на способ проверки делимости. Операция MOD вычисляет остаток от деления нацело. Скажем, 10 MOD 3=1. Если одно число нацело делится на другие, то остаток будет равен нулю. В этом случае условие в операторе IF оказывается истинным и выполняется оператор CONTINUE. Он пропускает остаток тела цикла и снова возвращается к оператору FOR. Если же значение переменной i не делится на три, тело цикла выполняется дальше.
Операторы BREAK и CONTINUE являются вспомогательными – любой алгоритм можно запрограммировать и без них, но во многих случаях они оказываются удобными.
Внутри каждой большой задачи сидит маленькая, пытающаяся пробиться наружу.
Из законов Мэрфи
Внутри одного цикла может находиться другой, внутри его – еще один и т.д. Такая "матрешка" нужна для решения многих задач. Рассмотрим пример вложенных циклов. Пусть задана прямоугольная решетка на плоскости размером 1020. Нужно вывести на экран координаты всех узлов такой решетки. Делается это так:
VAR i, j: WORD;
BEGIN
FOR i:=1 TO 10 DO
FOR j:=1 TO 20 DO
Memo1.Lines.Add('X='+IntToStr(i)+' , Y='+IntToStr(j))
В данном случае BEGIN…END не нужны: внутри внешнего цикла находится только один оператор FOR j:=1 TO 20. Кстати, вложенными могут быть циклы всех трех типов.
На блок-схеме приведенная программа будет выглядеть следующим образом (рис. 4):
Рис. . Обозначение вложенного цикла на блок-схемах.
Как только вы испробуете все возможные способы решения и не найдете подходящего,
тут же найдется решение, простое и очевидное для всех других людей.
Из законов Мэрфи
Массив – это набор переменных одинакового типа. Обращение к конкретному элементу массива происходит по его номеру. Это позволяет обрабатывать массивы в циклах.
Для создания массива сначала необходимо определить пользовательский тип данных. Если такие типы, как REAL, INTEGER, BOOLEAN есть в Delphi всегда (они называются встроенными), то встроенных статических массивов в Delphi нет – их надо создавать самому. Новые типы данных создаются оператором TYPE, который должен находиться в разделе описаний перед оператором VAR. Оператор TYPE не выделяет память под переменные, он нужен, чтобы потом в операторе VAR компьютер знал, сколько памяти выделить.
Обычные массивы в Delphi являются статическими. Это значит, что число элементов в массиве должно быть задано как константа и известно до начала работы программы. Если нужно, например, ввести число n с клавиатуры и затем создать массив из n элементов, то необходимо применять более сложную структуру – динамический массив (см. п. ).
Общий вид оператора TYPE при создании типа данных "массив" такой:
TYPE имя_типа = ARRAY [размерность] OF тип_данных_элементов;
Здесь имя_типа – придуманное программистом имя нового типа данных (обычно его начинают с буквы "Т", чтобы не путать с именами переменных), тип_данных_элементов – один из встроенных типов данных, к которому будут принадлежать все элементы массива.
Размерность массива указывает, сколько элементов содержится в массиве и как они будут расположены. В простейшем случае массив будет линейным (одномерным). Для линейного массива размерность указывается в виде imin..imax (обратите внимание – две точки, а не три!). Здесь imin – индекс первого элемента массива, imax – индекс последнего. Число элементов в таком массиве равно imax-imin+1.
Например, создадим массив из 10 чисел типа REAL:
TYPE TA=ARRAY [1..10] OF REAL;
А теперь выделим под него память:
VAR a:TA;
Индексы элементов массива могут быть и нулевыми, и даже отрицательными. Единственное ограничение – суммарный размер массива в памяти не должен превышать 64Кб.
При работе с массивом в программе можно обращаться к его отдельным элементам, указывая их индекс в квадратных скобках после имени массива, например: a[1], a[i], a[j+2-1]. Нельзя присвоить значение всему массиву сразу. В приведенном примере запись a:=10 является глупостью. Значения в массив надо заносить в цикле, по одному. Например, заполним массив случайными числами:
CONST Nmax=10; { число элементов в массиве }
TYPE TA=ARRAY[1..Nmax] OF REAL;
VAR a:TA; i:BYTE;
BEGIN
FOR i:=1 TO Nmax DO
a[i]:=RANDOM
. . .
Обратите внимание, что число элементов массива вынесено в отдельную константу Nmax. Если его потребуется изменить, достаточно будет сделать это в одном месте, а не бегать по всей программе.
Если четыре причины возможных неприятностей
заранее устранены, то всегда найдется пятая.
Из законов Мэрфи.
Каждый элемент массива, в свою очередь, может являться массивом. Это позволяет создавать двумерные таблицы (матрицы), трехмерные (представьте себе прямоугольный параллелепипед), а также массивы с большим числом измерений. Зачем может понадобиться четырехмерный массив, который и представить-то сложно? Вот пример: в комнате в точках с координатами x,y,z меряется температура t. Тогда данные о температуре легче всего представить в виде четырехмерного массива [x,y,z,t].
Чаще всего встречаются двумерные массивы. Для их описания в операторе TYPE указывают не одну, а две размерности:
TYPE TA=ARRAY[1..10, 1..5] OF REAL;
В таком массиве всего 105=50 элементов, а для обращения к любому из них нужно указывать два индекса: a[i, j].
К сожалению, во многих книгах по программированию усиленно муссируется вопрос про "строки" и "столбцы" двумерного массива. На самом деле никаких строк и столбцов в памяти компьютера не возникает, массив любой размерности хранится линейно. Соответственно и вопрос "а что указывать первым – число строк или столбцов?" – лишен смысла. Вы можете для удобства считать, что первым индексом является номер строки, а вторым – номер столбца, или наоборот – это ни на что не повлияет.
Для обработки двумерных массивов нужны вложенные циклы. Один цикл находится внутри другого и при каждой итерации внешнего цикла внутренний цикл пробегает все заданные значения. Рассмотрим пример заполнения двумерного массива случайными числами и нахождения среднего арифметического его элементов:
CONST MaxX=10, MaxY=20;
TYPE TA=ARRAY[1..MaxX, 1..MaxY] OF REAL;
VAR a:TA; i, j: BYTE; s:REAL;
BEGIN
s:=0;
FOR i:=1 TO MaxX DO
FOR j:=1 TO MaxY DO
BEGIN
a[i,j]:=random;
s:=s+a[i,j]
END;
s:=s/(MaxX*MaxY);
Label1.Caption:=
'Максимальный элемент равен '+FloatToStrF(max,ffFixed,10,4);
Лифт ломается чаще, чем лестница.
Из законов Мэрфи
Чаще всего массив нужно не заполнять случайными значениями, а вводить с клавиатуры или считывать из файла. Для ввода значений пользователем удобнее всего использовать компонент TStringGrid , находящийся на закладке Additional. Он представляет собой таблицу с произвольно задаваемым числом столбцов и строк, в каждую ячейку которой можно вводить и выводить данные ().
Рис. – Компонент TStringGrid.
Основными свойствами компонента TStringGrid являются:
ColCount – общее число столбцов, включая фиксированные;
RowCount – общее число строк, включая фиксированные;
DefaultColWidth – ширина каждого столбца в пикселах:
DefaultRowHeight – высота каждой строки в пикселах;
FixedCols, FixedRows – число фиксированных столбцов и строк соответственно. Фиксированные столбцы и строки выделены цветом (она задается в свойстве FixedColor) и остаются на месте при прокрутке содержимого таблицы, поэтому в них очень удобно задавать заголовки столбцов и строк;
ScrollBars – управляет отображением полос прокрутки. Возможные значения: ssNone (нет), ssHorizontal (только горизонтальная полоска), ssVertical(только вертикальная полоска), ssBoth (обе полоски);
GridLineWidth – задает толщину линий сетки в пикселах.
Свойство Options представляет собой множество значений, управляющих работой TStringGrid. Среди этих значений:
goFixedVertLine – отображать вертикальные линии для фиксированных ячеек таблицы;
goFixedHorzLine– отображать горизонтальные линии для фиксированных ячеек таблицы;
goVertLine - отображать вертикальные линии для обычных ячеек таблицы;
goHorzLine- отображать горизонтальные линии для обычных ячеек таблицы;
goRangeSelect – возможность выделения диапазона ячеек, если отключен ввод данных в ячейки с клавиатуры;
goDrawFocusSelected – выделение редактируемой ячейки цветом;
goRowSizing – возможность изменения высоты строк пользователем;
goColSizing – возможность изменения ширины столбцов пользователем;
goRowMoving – возможность изменения порядка следования обычных строк при перетягивании их мышкой;
goColMoving - возможность изменения порядка следования обычных столбцов при перетягивании их мышкой;
goEditing – возможность ввода значений в ячейки таблицы пользователем с клавиатуры;
goTabs – клавиша Tab обеспечивает переход от ячейки к ячейке;
goRowSelect – выделение не отдельной ячейки, а целой строки;
goAlwaysShowEditor – постоянно включен режим редактирования содержимого ячеек и отображается текстовый курсор;
goThumbTracking – содержимое таблицы перерисовывается "на ходу", в процессе перетаскивания линеек прокрутки.
Для доступа из программы к содержимому каждой ячейки применяется массив Cells[столбец, строка]. Нумерация строк и столбцов ведется с нуля! Данные в ячейках хранятся как текст (тип данных String), поэтому при работе с числами необходимо выполнять преобразование.
Организуем ввод с клавиатуры двумерного массива вещественных чисел 45 элементов и найдем его максимальный элемент. Положим на форму компонент TStringGrid и установим его свойства следующим образом:
ColCount=4;
RowCount=5;
DefaultColWidth=50;
DefaultRowHeight=50;
FixedCols=0;
FixedRows=0;
ScrollBars=ssNone;
Options=[goEditing, goDrawFocusSelected]
Кстати, число строк и колонок можно задавать и программным путем, тем самым меняя размер таблицы на ходу. Поместим на форму кнопку, компонент Label и в обработчике ее нажатия запишем следующий код:
VAR i,j:BYTE;
max:REAL;
begin
WITH StringGrid1 DO
BEGIN
max:=StrToFloat(Cells[1,1]);
FOR i:=1 TO ColCount-1 DO
FOR j:=1 TO RowCount-1 DO
IF StrToFloat(Cells[i,j])>max THEN
max:=StrToFloat(Cells[i,j]);
Label1.Caption:='Max='+FloatToStrF(max,ffFixed,10,4)
END
end;
Как видно, нет необходимости копировать введенные числа в статический массив – можно напрямую работать с массивом Cells.
В приведенном примере для простоты отсутствует защита от ввода неверных значений. В реальной программе, разумеется, надо ставить оператор TRY…EXCEPT.
Для вывода информации в виде массива нужно просто присваивать значения элементам массива Cells. Например, так можно заполнить заголовки (ячейки фиксированной строки). Строка
StringGrid1.Cells[0,0]:='Длина, мм';
занесет значение "Длина, мм" в левую верхнюю ячейку таблицы.
Чтобы сто раз не вводить одно и то же, удобно организовать считывание элементов массива из текстового файла. В каждой строчке такого файла записан один элемент массива (, а).
|
2.0 14.5 -15.3 |
2.0 3.0 4.0 3.0 -2.5 14.3 16.2 18.0 1.0 |
|
а) одномерный массив |
б) двумерный массив |
Рис. – Файлы для хранения массивов.
Считывание делается примерно следующим образом:
TYPE TA=ARRAY[1..10] OF REAL;
VAR a:TA; f:TEXTFILE; i:BYTE;
BEGIN
ASSIGNFILE(f,'1.txt');
RESET(f);
FOR i:=1 TO 10 DO
READLN(f,a[i]);
CLOSEFILE(f);
…
Преобразование типов (из файла считывается текстовая строка, а в массив оно заносится как вещественное число) выполняется автоматически процедурой READLN.
Если массив двумерный, то удобно в каждой строчке файла располагать несколько его элементов, разделяя их пробелами. Давайте считаем массив 33 элемента, показанный на , б:
TYPE TA=ARRAY[1..3,1..3] OF REAL;
VAR a:TA; i,j:BYTE; f:TEXTFILE;
BEGIN
ASSIGNFILE(f,'1.txt');
RESET(f);
// Цикл по строкам файла
FOR i:=1 TO 3 DO
BEGIN
// Цикл по числам внутри строки
FOR j:=1 TO 3 DO
READ(f,a[I,j]);
// Считывание символов конца строки
READLN(f)
END;
CLOSEFILE(f);
…
В приведенном фрагменте используется процедура READ, которая считывает не строку целиком, а ее часть до следующего пробела. После считывания всех чисел из строки нужно перейти на следующую строчку, для чего применяется процедура READLN(f). Данных она не считывает, а просто переходит к следующей строке файла.
Допустимые отклонения размеров деталей будут накапливаться
однонаправленно, чтобы причинить максимум трудностей при сборке.
Из законов Мэрфи
Очень часто встречается задача нахождения минимального или максимального элемента в массиве. Существует много неправильных способов ее решения. А вот как выглядит правильный:
CONST Nmax=10; { число элементов в массиве }
TYPE TA=ARRAY[1..Nmax] OF REAL;
VAR a:TA; i:BYTE; max: REAL;
BEGIN
// заполнение массива
FOR i:=1 TO Nmax DO
a[i]:=RANDOM;
max := a[1];
FOR i:=2 TO Nmax DO
IF a[i]>max THEN
max:=a[i];
Label1.Caption:=
'Максимальный элемент равен '+FloatToStrF(max,ffFixed,10,4);
Суть этого способа в том, что сначала мы принимаем первый элемент массива за максимальный, а потом сравниваем с ним все остальные элементы, начиная со второго. Если очередной элемент окажется больше, мы запоминаем его значение в переменной max.
полосы прокрутки
фиксированный ряд
фиксированный столбец