Как составить блок схему с циклом for

Предыдущий раздел:

Следующий раздел:

3.1. Цикл for

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

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

Рис. 1. Блок-схемы циклов.

В языке Паскаль существует несколько вариантов организации циклов. Рассмотрим один из них – так называемый цикл с параметром или цикл for. Чтобы записать его нам потребуется переменная целого типа, например:

  var
    i: integer;

Схема его записи выглядит следующим образом:

  for i := <начальное значение> to <конечное значение> do
  begin
    <операторы>
  end;

Здесь i – так называемая переменная-счетчик (разумеется, ее не обязательно называть именно i, это может быть любая переменная целого типа). Начальное и конечное значение это любые выражения, имеющее значение целого типа. Когда оператор цикла начинает работу переменная счетчик принимает начальное значение, затем выполняются <операторы>, после этого счетчик увеличивается на единицу, и снова выполняются операторы. Процесс повторяется, пока счетчик не окажется больше конечного значения. Например, если начальное значение 2, а конечное 3, то <операторы> будут выполнены 2 раза. Область между словами begin и end, где располагаются повторяющие в цикле операторы, называется телом цикла.

На рис. 2 показана блок-схема работы этого цикла.

Рис. 2. Схема работы цикла с параметром (for).

Пример 1: Напечатать слово Hello на экране 100 раз.

Один раз слово Hello можно напечатать с помощью процедуры

  writeln('Hello');

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

  for n := 1 to 100 do
  begin
    writeln('Hello');
  end;

Переменной счетчику n будет присвоено начальное значение 1. Затем Hello будет напечатано 1-й раз. Счетчик увеличится на 1 и Hello напечатается 2-й раз и т.д.

Перечислим в одном месте все правила, касающиеся работы цикла с параметром:

1) Переменная-счетчик должна быть обязательно целого типа (например, integer).

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

Нельзя, например, записать цикл

  for x := 0 to 2*Pi do …

Но можно, например:

  for k := 2*round(n*1000) to trunc(2*pi)+1 do …

3) Если конечное значение меньше начального цикл не выполнится ни разу.

4) После окончания работы переменная-счетчик «портится». Глядя на блок-схему можно предположить, что после окончания работы цикла она на единицу больше конечного значения. На практике это не так и она может иметь любое значение. Отсюда правило: если переменная используется, как счетчик шагов в цикле не следует обращаться к ней после того, как цикл завершил свою работу.

5) Если в теле цикла содержится всего один оператор, то слова begin и end, ограничивающие тело цикла можно опустить. Такая ситуация у нас была в примере 1. Там можно было написать:

  for n := 1 to 100 do
    writeln('Hello');

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

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

8) Еще одно стилистическое правило: все операторы тела цикла должны быть дополнительно сдвинуты на 2-3 пробела вправо (см. запись программы в примере 1 и последующих примеров ниже по тексту).
Итак, одни и те же действия мы можем выполнять сколько угодно раз, но что полезного это дает? Печатать 100 раз Hello не очень важное приложение. Чтобы сделать что-то полезное, надо чтобы действия на каждом шаге цикла чем-то различались. Первый способ добиться этого состоит в использовании переменной счетчика, которая на каждом шаге принимает различные значения.

Пример 2: Напечатать все целые числа в диапазоне от 5 до 25.

  for i := 5 to 25 do
    writeln(i);

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

Пример 3: Табуляция функций.

Под табуляцией функций подразумевается составление таблицы значений функции для некоторого диапазона значений аргумента. Пусть требуется N значений функции f(x) в диапазоне от Xmin до Xmax. Рассматривая переменную-счетчик как номер аргумента функции, составим выражение, позволяющее по номеру получить значение аргумента:

x := Xmin + (Xmax — Xmin)*(i-1)/(N-1).

Убедитесь, что действительно первое значение аргумента (при i = 1) составляет x = Xmin, а N-е (i = N) – x = Xmax. Вычисляя на каждом шаге значение аргумента, можем тут же вычислить функцию и составить требуемую таблицу.

  for i := 1 to N do
  begin
    x := Xmin+(Xmax-Xmin)*(i-1)/(N-1);
    y := f(x);
    writeln(x, '  ', y);
  end;

Вместо f(x) в приведенной программе следует подставить любое выражение, составленное по правилам языка Паскаль.

Следующий раздел:

Предыдущий раздел:

Добавить комментарий

В этом руководстве мы узнаем о цикле for в C++ и его работе с помощью примеров. В компьютерном программировании циклы используются для повторения блока кода.

Например, предположим, что мы хотим показать сообщение 100 раз. Тогда вместо того, чтобы писать оператор печати 100 раз, мы можем использовать цикл.

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

В С++ существует 3 типа циклов:

• цикл for;
• цикл while;
• цикл do…while.

В этом руководстве основное внимание уделяется циклу for в C++.

for loop

Синтаксис цикла for:

for (initialization; condition; update) {
    // body of-loop 
}

Где:

• initialization – инициализирует переменные и выполняется только один раз;
• condition – если true, то тело цикла for выполняется, если false, цикл for завершается;
• update – обновляет значение инициализированных переменных и снова проверяет условие.

Блок-схема цикла for

Пример 1: печать чисел от 1 до 5

#include <iostream>

using namespace std;

int main() {
        for (int i = 1; i <= 5; ++i) {
        cout << i << " ";
    }
    return 0;
}

Вывод:

1 2 3 4 5

Вот как работает эта программа:

Пример 2: отображение текста 5 раз

// C++ Program to display a text 5 times

#include <iostream>

using namespace std;

int main() {
    for (int i = 1; i <= 5; ++i) {
        cout <<  "Hello World! " << endl;
    }
    return 0;
}

Вывод:

Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

Вот как работает эта программа в С++:

Пример 3: нахождение суммы первых n чисел

// C++ program to find the sum of first n natural numbers
// positive integers such as 1,2,3,...n are known as natural numbers

#include <iostream>

using namespace std;

int main() {
    int num, sum;
    sum = 0;

    cout << "Enter a positive integer: ";
    cin >> num;

    for (int count = 1; count <= num; ++count) {
        sum += count;
    }

    cout << "Sum = " << sum << endl;

    return 0;
}

Вывод:

Enter a positive integer: 10
Sum = 55

В приведенном выше примере у нас есть две переменные – num и Sum. Переменной Sum присваивается 0, а переменной num присваивается значение, указанное пользователем.

Обратите внимание, что мы использовали цикл for.

for(int count = 1; count <= num; ++count)

Где:

• int count = 1: инициализирует переменную count;
• count <= num: запускает цикл до тех пор, пока count меньше или равно num;
• ++ count: увеличивайте переменную count на 1 на каждой итерации.

Когда count становится 11, условие ложно и Sum будет равна 0 + 1 + 2 + … + 10.

Представление цикла for

В C++ 11 был представлен новый цикл for на основе диапазона для работы с коллекциями, такими как массивы и векторы. Его синтаксис:

for (variable : collection) {
    // body of loop
}

Здесь для каждого значения в collection выполняется цикл for, и значение присваивается variable.

Пример 4: на основе диапазона

#include <iostream>

using namespace std;

int main() {
  
    int num_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  
    for (int n : num_array) {
        cout << n << " ";
    }
  
    return 0;
}

Вывод:

1 2 3 4 5 6 7 8 9 10

В приведенной выше программе мы объявили и инициализировали массив int с именем num_array. В нем 10 элементов.

Здесь мы использовали цикл for на основе диапазона для доступа ко всем элементам в массиве C++.

Бесконечный цикл for

Если условие в цикле for всегда truth, оно выполняется бесконечно (пока память не заполнится). Например:

// infinite for loop
for(int i = 1; i > 0; i++) {
    // block of code
}

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

3.5.3 Оператор цикла for..do

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

for параметр_цикла:=начальное_значение to конечное_значение do
	оператор;
for параметр_цикла:=конечное_значение downto начальное_значение do
	оператор;

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

Шаг изменения цикла for всегда постоянен и равен интервалу между двумя ближайшими значениями типа параметра цикла (при целочисленном значении параметра цикла шаг равен 1).

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

for параметр_цикла:=начальное_значение to конечное_значение do
	begin
		оператор_1;
		оператор_2;
		...
		оператор_N;
	end;

Опишем алгоритм работы цикла for..do (рис. 3.26).

• Параметру_цикла присваивается начальное_значение.
• Если значение параметра_цикла превосходит конечное_значение, то цикл завершает свою работу. В противном случае выполняется п. 3.
• Выполняется оператор.
• Значение параметра_цикла изменяется на соответствующий шаг и осуществляется переход к п. 2, и т. д.

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

В дальнейшем, чтобы избежать создания слишком громоздких алгоритмов, в блок-схемах цикл for будем изображать так, как показано на рис. 3.27
^{10Если шаг изменения параметра цикла равен единице, его в блок-схемах можно не указавать.} .

Фрагмент подпрограммы, приведённый далее, демонстрирует применение цикла for:

var i : integer; c : char;
	begin
		{Вывод на экран чисел от 1 до 10.}
		for i :=1 to 10 do
			writeln ( i );
		{Вывод на экран чисел от 10 до -10.}
		for i :=10 downto -10 do
			writeln ( i );
		{Вывод на экран символов от a до r.}
		for c := ’ a ’ to ’ r ’ do
			writeln ( c );
	end.

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

( 3.6)

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

var i, n : integer; x, y : real;
	begin
	n:=round ( ( pi - 0)/0.1)+1; {Количество повторений цикла.}
	x : = 0; {Начальное значение аргумента.}
	{Цикл с известным числом повторений,}
	{i - параметр цикла, изменяется от 1 до n с шагом 1.}
	for i :=1 to n do
	begin {Начало цикла.}
		y:=exp ( sin ( x ) ) * cos ( x ); {Вычисление значения функции }
		{для соответствующего значения аргумента.}
		writeln ( ’ x= ’, x, ’    y= ’, y );
		x:=x + 0.1; {Вычисление нового}
		{значения аргумента.}
	end; {Конец цикла.}
end.

Общие сведения

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

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

• Достоинства и недостатки применения циклов.
• Синтаксис, необходимый для использования циклических операторов. Общая информация о блок-схемах. Абстрактные модели.

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

Правила применения

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

Основной принцип программиста — максимальное упрощение кода или оптимизация. Простым примером являются конструкторы сайтов. При генерации web-страницы в ее теле появляется много ненужных элементов. Например, специалист при создании одной страницы уложится в 200 строк html-кода, а конструктор способен сгенерировать в 4 или 5 раз больше.

Упрощение кода

Циклы в некотором случае могут быть тоже лишними. Однако не всегда целесообразно их использовать, поскольку этот подход существенно влияет на скорость вычислений. Для примера следует разобрать случай, когда необходимо вывести всего лишь несколько строк на экран. Проще использовать специальный оператор write или writeln, который занимает незначительный объем оперативной памяти. Для организации кода приложений с учетом признаков «хорошего тона» необходимо воспользоваться следующей инструкцией:

• Цель приложения.
• Количество генерируемой информации (маленький или большой объем).
• Простота кода.
• Количество строк.

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

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

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

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

Достоинства и недостатки

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

• Простота применения.
• Уменьшение количества кода.
• Универсальность.
• Читабельность.
• Обработка и вывод больших массивов информации.

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

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

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

• Ресурсоемкость.
• Зацикливание (зависание).

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

Синтаксис циклов

Перед разбором синтаксиса основных циклов языка программирования Турбо Паскаль необходимо обратить внимание на их классификацию. Их можно условно разделить на три типа:

• с параметром;
• постусловием;
• предусловием.

Следует отметить, что для понимания классификации нужно разобраться со структурой, то есть элементами, из которых он состоит. К ним относятся заголовок (условие) и тело. Условие — основной элемент, имеющий вид логического выражения. Последнее принимает только два значения — ложь и истина. Первое на машинном языке кодируется 0, а второе — 1. Однако такой вид кодировки приемлем только для Турбо Паскаля. В современных языках программирования кодировка следующая: ложь — FALSE, а истина — TRUE. Телом называется группа операторов, переменных и операндов, необходимых для обработки результата.

В зависимости от условия, идет обработка данных. Циклы очень часто применяются вместе с оператором IF-ELSE. Последний переводится таким образом: если — иначе. В первый блок (если) вставляется условие. Если оно выполняется, то производятся одни действия, а если нет (иначе) — другие. Этот механизм очень удобен, поскольку придает программному продукту сложную структуру.

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

Параметрический тип

К циклу с параметром принадлежит for (блок-схема 1). В нем тело выполняется заданное число раз. Это зависит от некоторого параметра (итератора). Существует 2 класса записи команд, состоящих из следующего списка:

• for <iterator1> := <value_first> to <value_last> do <operator>.
• for <iterator2> := <value_last> to <value_first> do <operator>.

В первом случае после каждой операции, которая завершилась без ошибок, <iterator1> : = <value_first> будет увеличивать на 1. Выражение <iterator1> — переменная, принимающая значение <value_first>. Итерация цикла останавливается, когда <iterator1> эквивалентен <value_last>. Служебное слово «to» обозначает интервал изменения итератора.

Знак «:=» — оператор присваивания итератору величины <value_first>. Его не следует путать со знаком равенства «=», поскольку последний применяется в логических выражениях для сравнения величин. Зарезервированное слово «do» означает передачу значения итератора соответствующему выражению.

Второй класс записи имеет другую логику исполнения. Значение итератора <iterator2> уменьшается на 1 до начальной величины <value_first>. В этом случае расшифровка всех зарезервированных слов совпадает с первым классом.

Блок-схема 1. Цикл for.

Стоит обратить внимание, что когда необходимо написать несколько выражений в теле, следует использовать блок do begin-end. Тело располагается между begin и end. Кроме того, следует придерживаться определенной последовательности действий (алгоритма), чтобы правильно написать соответствующий код.

Использование предусловия

В Турбо Паскале циклом с предусловием является while (блок-схема 2). В нем условие стоит перед телом. Все операции в последнем выполняются до того момента, пока значение выражения в условии не будет эквивалентно FALSE (0). В результате этого работа while прекращается. Далее выполняются остальные блоки, находящиеся вне цикла. Формат while имеет такой вид: while <логическое выражение> do <operator1>. Транскрипция имеет такой вид: пока выполняется условие — делай.

Блок-схема 2. Цикл с предусловием while.

Необходимо отметить, что при использовании нескольких операторов, их следует применять внутри блока begin-end. Кроме того, значение итератора в условии увеличивается на 1. Шаг является постоянным. Однако его можно изменять для примера таким образом: i = i + 2. Инициализацию переменной нужно проводить перед циклом.

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

Логическое выражение в конце

Можно поставить логическое выражение после тела. В этом случае получится конструкция repeat-until или цикл с постусловием (блок-схема 3). Его формат имеет такой вид (состоит из нескольких строк):

repeat {не используется конструкция begin-end}

write(i) {Вывод итератора}

i = i + 1 {увеличение на 1}

until i = 10 {прекращение работы цикла при i = 10}.

Блок-схема 3. Цикл с постусловием repeat-until.

Специалисты не рекомендуют использовать repeat-until, поскольку в некоторых случаях возможны «зависания» программы. Параметр «i» называют счетчиком. Его значение может быть равно только целому числу. В противном случае итерационный элемент вызовет ошибку и выполнение программы невозможно будет остановить. Это очень часто происходит при подсчете суммы положительных чисел, представленных некоторым промежутком, или геометрической прогрессии.

Кроме того, в repeat-until можно использовать метку Goto, позволяющую переходить в определенную область тела. Аварийный выход осуществляется при помощи зарезервированного слова break. Последний следует указывать всегда после условия, поскольку это уменьшит вероятность «зависания» приложения. Если указан зарезервированный оператор continue, то произойдет переход к новой итерации. Его можно применять для задержки (паузы или прерывания) вычислений до ввода определенного значения или нажатия клавиши.

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