birmaga.ru
добавить свой файл

1
Тема: Операторы цикла.


Цели:


    1. Ознакомить с операторами для составления цикла.

2. Формировать навыки операционного и логического мышления, навыки общения с компьютером.

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

Тип урока: комбинированный

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

Программно – дидактическое обеспечение: ПК, программы Microsoft PowerPoint, Quick Basic, мультимедиапроектор, обучающая презентация, карточки с индивидуальными заданиями.

План урока:

  1. Организация начала урока (1 мин).

  2. Проверка и актуализация знаний (2 мин).

  3. Постановка целей и задач (1 мин).

  4. Теоретическая часть (13 мин).

  5. Практическая часть (17 мин)

  6. Информация о домашнем задании (1 мин).

  7. Подведение итогов урока (5 мин).

Ход урока:

  1. Организация начала урока.

    1. Приветствие. Проверка готовности учащихся к уроку.

  2. Проверка и актуализация знаний

  • Когда появился язык Паскаль и кто его автор?

  • 2. Как записывается заголовок программы на Паскале?

  • 3. Как записывается раздел описания переменных?

  • 4. С какими типами числовых величин работает Паскаль?

  • 5. Как записываются операторы ввода и вывода в Паскале?

  • 6. Что такое оператор присваивания?

  • 7. Как записываются арифметические выражения?

  • 8. По каким правилам определяется порядок выполнения операций в арифметическом выражении?

  1. Постановка целей и задач

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


  1. Теоретическая часть

Начнем мы с циклических операторов. Язык Паскаль располагает как минимум тремя такими операторами:

1) While

2) Repeat .. Until

3) For

Оператор While имеет следующую структуру:
While логическое выражение do оператор;
Работает этот оператор очень просто. Вычисляется значение логического выражения. Если получается истина (True), то выполняется оператор, а затем снова вычисляется значение логического выражения. Если снова получается истина, то опять выполняется оператор, и т.д. Так продолжается до тех пор, пока при вычислении логического выражения не получится ложь (False). После этого оператор While заканчивает свою работу и передает действие следующему оператору.

В частности, если в самом начале работы While при вычислении логического выражения получается ложь, то оператор не выполнится ни разу. Как обычно, в качестве оператора может выступать некоторый составной оператор. Может показаться странным, что оператор While вообще когда-нибудь заканчивает свою работу. В самом деле, почему одно и то же логическое выражение сначала было истинным, а потом, после нескольких выполнений оператора, стало ложным? Ответ таков: логическое выражение зависит от нескольких переменных, значение которых меняется во время выполнения оператора, что влечет за собой изменения значения логического выражения. В принципе, это вовсе не означает, что каждый оператор While когда-нибудь заканчивает работу. То есть, не исключена ситуация, когда логическое выражение всегда будет истинным, и оператор While будет работать вечно. Такая ситуация называется зацикливанием. Таким образом, при использовании оператора While и вообще других циклических операторов нужно быть аккуратным и стараться избегать зацикливаний. Это значит, что при программировании любого цикла нужно стараться всегда объяснить самому себе, почему этот цикл не будет вечным, а когда-нибудь закончит свою работу. Самым простым примером вечного цикла может быть следующий:

While True do


Проиллюстрируем работу оператора While на примере.

Пример. По числу X (1≤X≤2000000000) определить количество знаков в этом числе.

Решение этой задачи может иметь следующий вид:
program DigitCount;

var

X, Y: LongInt;
begin

ReadLn(X);

Y:= 0;

While X <> 0 do begin

X:= X div 10;

Y:= Y+1;

end;

WriteLn(Y);

end.
Цикл While в данной программе не является вечным. Это следует, к примеру, из того, что после каждого выполнения этого цикла число X уменьшается в 10 раз, что не может продолжаться вечно. Более того, программа работает правильно. Это следует из того, что число X div 10 имеет ровно на один знак меньше, чем число X (если считать, что число 0 состоит из нуля знаков).
Напомним еще раз, что оператор в теле цикла While может, в принципе, не выполниться ни разу. Иногда возникает необходимость в написании цикла, тело которого выполняется хотя бы один раз. Язык Паскаль располагает конструкцией Repeat..Until для организации подобных циклов. Оператор Repeat..Until имеет следующую структуру:
Repeat

оператор1;

оператор2



операторN

Until логическое выражение;
Работает этот оператор достаточно похоже на While. Существенных отличий два:

1) Группа операторов в теле цикла выполняется хотя бы один раз (в самом начале цикла).

2) Цикл заканчивает свою работу, когда при вычислении логического выражения получается истина (True).

Опишем работу цикла Repeat..Until более точно. Сначала выполняются все операторы в теле цикла. Далее вычисляется логическое выражение. Если оно ложно, то снова выполняются все операторы из цикла. Затем опять вычисляется логическое выражение и т.д. Цикл заканчивает свою работу, как только при вычислении логического выражения получается истина (True).

Циклы While и Repeat..Until достаточно похожи друг на друга и использование того или другого является, наверное, делом вкуса. Хотя, в принципе, встречаются ситуации, когда один из этих циклов использовать гораздо удобнее, чем другой. Однако, как правило, оба этих цикла используются тогда, когда неизвестно, сколько раз понадобится выполнять тело цикла (точнее, затруднительно вычислить, сколько раз нужно выполнять тело цикла). В случаях, когда число повторений тела цикла известно (или может быть вычислено), очень часто оказывается более удобным использовать цикл For. Этот цикл имеет несколько более сложную структуру.
For переменная:= начальное значение to конечное значение do

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

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

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

Объясним теперь работу цикла For. Сначала вычисляется начальное значение (обозначим результат вычислений A), а затем – конечное значение (обозначим его B). Если оказывается, что A > B, то тело цикла не выполняется ни разу, и управление передается следующему после For оператору. Иначе выполняются следующие действия: в переменную помещается значение A, выполняется оператор, в переменную помещается следующее после A значение, выполняется оператор, …, в переменную помещается предыдущее перед B значение, выполняется оператор, в переменную помещается значение B, выполняется оператор. Таким образом, оператор выполняется B-A+1 раз, при этом каждый раз с разными значениями переменной.

Заметьте, что начальное и конечное значение вычисляются ровно один раз в начале цикла. Например, рассмотрим следующий фрагмент программы:
n:= 1;

For i:= 1 to n do

n:= n+1;
Цикл For здесь вовсе не является вечным, как может показаться на первый взгляд. На самом деле он выполняется только для i = 1.

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

While переменная ≤ конечное значение do begin

оператор;

Inc(переменная)

end;
Здесь используется незнакомая вам операция Inc(перечислимый тип), которая возвращает следующее значение для аргумента и имеет такой же тип, как и аргумент. Аналогичная операция Dec(перечислимый тип) возвращает предыдущее значение для аргумента и имеет такой же тип, как и аргумент.

После описания цикла For в таком все вопросы снимаются. Можно рассмотреть, к примеру, следующий фрагмент программы:

For i:= 1 to 10 do begin

WriteLn(i);

i:= i+1;

end;
Нетрудно видеть, что данная программа выведет на экран числа 1, 3, 5, 7, 9.
Иногда бывает полезным перебирать переменную не в порядке увеличения ее значений, а в порядке уменьшения. Для этого можно использовать следующую структуру:
For переменная:= начальное значение downto конечное значение do

оператор;
Чтобы долго не описывать, как работает оператор For в данной записи, перепишем ее в эквивалентном виде:
переменная:= начальное значение;

While переменная ≥ конечное значение do begin

оператор;

Dec(переменная)

end;
В заключение рассмотрим пример использования цикла For.

Пример. Для заданного N (1≤N≤1000) вычислить сумму квадратов всех чисел от 1 до N.

Решение может выглядеть следующим образом:
Program SumSqr;

var

N, S, i: LongInt;

begin

ReadLn(N);

S:= 0;

For i:= 1 to S do

S:= S+Sqr(i);

WriteLn(S);

end.
Иногда бывает полезным либо «насильно» завершить работу некоторого цикла, либо «насильно» перейти к следующей его итерации, не заканчивая текущую. Для этого служат операторы языка Паскаль break и continue. Операторы эти могут быть написаны только в теле циклов While, Repeat..Until и For. Если в теле некоторого цикла есть оператор Break и до него доходит выполнение, то этот цикл сразу автоматически заканчивает свою работу и управление передается следующему после цикла оператору. Если в теле некоторого цикла есть оператор Continue и до него доходит выполнение, то текущая итерация этого цикла автоматически заканчивается и сразу начинается следующая итерация цикла (под итерацией мы понимаем одноразовое выполнение тела цикла). Как мы увидим дальше, данные операторы иногда бывают очень удобными.

Отметим также еще два полезных оператора – Exit и Halt. Дальше мы скорректируем работу этих операторов, но пока Вы можете считать, что они делают одно и то же – просто заканчивают работу программы, что тоже очень часто бывает полезным. Эти операторы могут быть написаны в произвольном месте программы.