Как составить программу с циклом for

Здравствуйте, дорогие читатели! Вот мы с вами и подошли к изучению циклов. Циклы в Паскаль. Что это такое? Как этим пользоваться? Для чего они нужны? Именно на эти вопросы я сегодня и отвечу.
Если вы читали этот урок, то знаете, что существует три вида алгоритмов: линейный, разветвляющийся и циклический. Мы с вами уже знаем, как реализовывать линейные и разветвляющиеся алгоритмы на Паскале. Приступим к изучению последнего типа алгоритмов.
В языке Pascal, как и в большинстве языков программирования, существует три типа циклических конструкций.

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

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

Задача 1. Вывести все числа от 1 до числа, введенного с клавиатуры.

Как вы, наверное, уже поняли из названия, while — это цикл, в котором условие стоит перед телом. Причем тело цикла выполняется тогда и только тогда, когда условие true; как только условие становится false, выполнение цикла прекращается.

While имеет формат:

while < условие> do <оператор 1>;  {Пока … делай ….}

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

Решение задачи.

program example_while; 

var
  i, N: integer; { объявляем переменные }

begin
  i := 1; { Присваиваем i значение 1 }
  readln(N); { Считываем последнее число }
  while i <= N do {Как только i станет больше N, цикл прекратится (можно было бы написать просто <, но пришлось бы добавлять 1 к N) }
  begin {Открываем операторные скобки}
    write(i, ' '); {Выводим i}
    Inc(i);  {увеличиваем i на один.}
  end; { закрываем скобки }
end.

Repeat, или цикл с постусловием

Repeat  — полная противоположность while. Repeat — это цикл, в котором условие стоит после тела. Причем оно выполняется тогда и только тогда, когда результат условия false; как только логическое выражение становится true, выполнение цикла прекращается.

Repeat имеет формат:

repeat { повторяй … }
<оператор 1>;
< оператор 2>;
…
until {до…} <условие>

Begin и end не требуются.

Решение задачи.

program example_repeat;

var
  i, N: integer;{ объявляем переменные }

begin
  i := 1; { Присваиваем i значение 1 }
  readln(N); { Считываем последнее число }
  repeat {после repeat не требуется begin и end }
    write(i, ' '); {Выводим i}
    Inc(i);  {увеличиваем i на один.}
  until i = N + 1; {Например, i = 11, а N = 10. Цикл прекратится, так условие стало true.}
end.

For, или цикл с параметром

For — это  цикл, в котором тело выполняется заданное количество раз.

Существует две формы записи этого цикла:

Первая форма

for <счетчик1> := <значение1> to <конечное_значение> do <оператор1>;

После каждой итерации значение <счетчик1> будет увеличиваться на 1.

<значение1> — это начальное значение счетчика. Это может быть переменная или число.
<конечное_значение> : как только значение <счетчик1> станет больше <конечное_значение>, выполнение цикла прекратится.

Если требуется написать несколько операторов в теле цикла, используем begin и end.

И <счетчик1>, и <конечное_значение>, и <значение1> —  переменные целого типа.

Чаще всего в качестве счетчика используется переменная i.

Вторая форма

for <счетчик2> := <значение2> downto <конечное_значение> do <оператор1>;

После каждой итерации значение <счетчик2> будет уменьшатся на 1.

<значение2> — это начальное значение счетчика.
<конечное_значение> : как только значение <счетчик2> станет меньше <конечное_значение>, выполнение цикла прекратится.

Два важных примечания:

1. Цикл повторяется, пока значение значение счетчика лежит в отрезке [значение ; конечное_значение].
2. Изменять значение счетчика внутри тела нельзя!  Вот что выводит компилятор:

Решение задачи:

 
program example_for;

var
  i, N: integer;

begin
  read(N); {предположим, что мы ввели 10}
  for i := 1 to N do write(i, ' '); {количество итераций - 10 - 1 + 1 = 10}
end.

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

Давайте решим пару задач.

For1. Даны целые числа K и N  (N > 0). Вывести N раз число K.

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

program for1;

var
  K, N, i: integer;

begin
  read(K, N);
  for i := 1 to N do write(K, ' '); {Пишем К через пробел }
end.

For2. Даны два целых числа A и B (A < B). Вывести в порядке возрастания все целые числа, расположенные между A и B (включая сами числа A и B), а также количество N этих чисел.

Так как A < B, то цикл должен будет выводить все числа от А до B. Чтобы сосчитать количество чисел, используем формулу: <конечное_значение> — <начальное_значение> + 1.

program for2;

var
  A, B, i, count: integer;

begin
  read(A, B);
  for i := A to B do write(i, ' '); {выписываем числа от меньшего к большему}
  count := B - A + 1; {считаем количество чисел}
  writeln;
  write( 'Количество чисел - ', count);
end.

For9. Даны два целых числа A и B (A < B). Найти сумму квадратов всех целых чисел от A до B включительно.

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

program for9;

var
  A, B, i, S: integer;

begin
  read(A, B);
  S := 0; {PascalABC делает это автоматически, но если у вас другой компилятор советуем обнулять переменные вручную}
  for i := A to B do S := S + Sqr(i);  {складываем все квадраты}
  writeln;
  write( 'Сумма квадратов - ', S);
end.

For13°. Дано целое число N (> 0). Найти значение выражения 1.1 – 1.2 + 1.3 – … (N слагаемых, знаки чередуются). Условный оператор не использовать.

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

program for13;

var
  N, A, i: integer;
  S: real;

begin
  Write('N = ');
  readln(N); 
  S := 1.1; 
  A := 1; {Сначала положительное}
  for i := 2 to N do {первую итерацию цикла мы уже произвели, поэтому начинаем отсчет с 2}
  begin 
   A := -A; {Теперь отрицательное}
   S := S + A * (1 + i / 10);  {Складываем}
  end;
  Writeln(S:5:1); {Отдадим под дробную часть одно знакоместо}
end.

While1°. Даны положительные числа A и B (A > B). На отрезке длины A размещено максимально возможное количество отрезков длины B (без наложений). Не используя операции умножения и деления, найти длину незанятой части отрезка A.

Каждый раз вычитаем B из А, пока А — В  >= 0.

program while1;

var
  A, B: integer;

begin
  readln(A, B);
  while (A - B) >=  0 do A := A - B; {Пока разница положительная, вычитаем. Необходимо предусмотреть вариант с кратностью А и B, поэтому >=}
  write(A);
end.

While4°. Дано целое число N (> 0). Если оно является степенью числа 3, то вывести True, если не является — вывести False.

Действуем следующим образом: пока N делится нацело на три, делим N нацело. Затем, если N = 1 — число является степенью тройки; если N <> 1, тогда число — не степень тройки. Для того чтобы решить эту задачу, требуется знать, что такое div и   mod,  и как работают логические выражения.

program while4;

var
  N: integer;

begin
  readln(N);
  while N mod 3 = 0 do N := N div 3; {Пока остаток от деления на три равен нулю, делим N нацело } 
  writeln(N = 1); {логическое выражение}
end.

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

Когда в алгоритме некоторое действие нужно выполнить несколько раз, используются циклы. В программирование цикл — это многократное повторение определенных инструкций. Циклы состоят из заголовка и тела. Заголовок содержит в себе условия, которые определяют работу цикла, а тело – повторяющиеся действия. В этом уроке рассмотрим:

• цикл со счетчиком (с параметром);
• цикл с предусловием;
• цикл с постусловием.
• вложенные циклы/a>.

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

1 For — цикл с параметром

Цикл с параметром, известный также как цикл со счетчиком, используется при известном количестве повторений. Он имеет две формы записи. В любом случае он выполняет следующий после него оператор (как правило, это составной оператор заключенный в «операторные скобки» Begin..End), каждый раз изменяя переменную цикла с шагом 1

For <счетчик>:=< начальное значение> To <конечное значение> Do <тело цикла>;

For <счетчик>:=<начальное значение> Downto <конечное значение> Do <тело цикла>;

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

Условия выполнения цикла проверяются перед выполнением блока операторов. Если переменная цикла больше максимального значения (при to) или меньше минимального (downto), то цикл FOR не выполняется.

Формы записи, представленные выше, отличаются словами To и Downto. Если Вы используете цикл с To, то значение счетчика с каждым шагом будет увеличиваться на единицу, а если с Downto, то уменьшаться. Из этого следует, что в первом варианте начальное значение не должно превышать конечное, во втором — верно противоположное. В программе ниже, указанное пользователем количество раз, будут выводиться символы.

program for_primer;
uses crt;
var i, x: integer;
begin
  write('X=');
  readln(x);
  for i:=1 to x do
    write('a');
readkey;
end.

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

Другой пример — вычисление суммы чисел от A до B:

Program Summa;
Var a, b, S: Integer;
Begin
  ClrScr;
  Write('a = ');
  Readln(a);
  Write('b = ');
  Readln(b);
  S:=0;
  For I:=a To b Do
    S:=S + I;
  Writeln ('Cумма = ', S);
  ReadLn
End. 

2 While – цикл с предусловием

Оператор While – начинает описание цикла с предусловием. Такой вид цикла нужен, в тех алгоритмах, где число повторений неизвестно заранее. В общем виде он выглядит так:

While <выражение> Do <тело цикла>;

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

Пример программы написанный с использованием цикла While:

program while_primer;
uses crt;
var i, x, limit: integer;
begin
  write('Предел=');
  readln(limit);
  write(' Числа Фибоначчи: ');
  i:=1; x:=1;
  while i<=limit do
  begin
    write(i,' ');
    i:=i+x;
    x:=i-x;
  end;
  readkey;
end.

В данном коде использовался составной оператор Begin-End, так как операторов в теле цикла несколько.

3 Repeat – цикл с постусловием

Главной особенностью цикла с постусловием (часто встречается название: цикл-ДО) является выполнение его тела минимум один раз. Это связано с тем, что условие записывается в конце и соответственно вначале выполнится тело, а затем провериться условие. Формально он выглядит так:

Repeat
  <тело цикла>
Until <условие>

В противоположность двум рассмотренным прежде циклам, этот прекращает свое выполнение тогда, когда условие становиться истинным, т. е. чтобы итерации продолжались условие должно быть ложно. Рассмотрим работу цикла с постусловием на примере:

program repeat_primer;
uses crt;
var i, otvet: integer;
begin
  i:=1;
  repeat
    i:=i+1;
    write(i,'+',i,'*2=');
    read(otvet);
  until otvet<>i+i*2;
  readkey;
end.

Программа продолжает работать до тех пор, пока пользователь не допустит ошибку в ответе. Думаю, Вы заметили, что в примере (непосредственно в цикле) составной оператор Begin-End, несмотря на количество операторов не поставлен. Просто его роль выполняют слова repeat и until.

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

• Goto – переходит в отмеченную область;
• Break – производит безусловный выход из цикла;
• Continue – осуществляет переход к новой итерации.

4 Вложенные циклы

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

Рассмотрим вложенные циклы на примере цикла с параметром:

For <счетчик 1>:=<начальное знач.> To <конечное знач.> Do <тело цикла 1>;
For <счетчик 2>:=<начальное знач.> To <конечное знач.> Do <тело цикла 2>;
…
For <счетчик n>:=<начальное знач.> To <конечное знач.> Do <тело цикла n>;

Вернувшись к терминологии, отметим, что в таких структурах одни циклы называются внешними, а другие внутренними. Так цикл 2 относительно цикла 1 является внутренним, а для цикла n он внешний.

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

Предположим у нас есть вложенные циклы for:

for i:=1 to m1 do
for j:=1 to m2 do
…
for k:=1 to mn do

Количество проходов по первому циклу = m1, второму = m2*m1, n-ому = mn*mn-1*mn-2*..*m2*m1. В качестве доказательства предлагаю разобраться в следующей программе.

program counter_performance;
uses crt;
var i, j, k, g, h: integer;
s_i, s_j, s_k, s_g, s_h: integer;
begin
  s_i:=0; s_j:=0; s_k:=0; s_g:=0; s_h:=0;
  for i:=1 to 5 do
  begin
    s_i:=s_i+1;
    for j:=1 to 3 do
    begin
      s_j:=s_j+1;
      for k:=1 to 19 do
      begin
        s_k:=s_k+1;
        for g:=1 to 10 do
        begin
          s_g:=s_g+1;
          for h:=1 to 6 do
            s_h:=s_h+1;
        end;
      end;
    end;
  end;
  write('i=',s_i,' j=',s_j,' k=',s_k,' g=',s_g,' h=',s_h);
  readkey;
end.

Имеются 5 циклов со счётчиками от i до h. В каждом из них при помощи переменных подсчитывается, сколько раз выполняется каждый цикл. Запустив программу на своем компьютере, Вы должны увидеть такой результат:

Результат работы вложенных циклов

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

program nested_loops;
uses crt;
var i, j: integer;
begin
  i:=1; j:=1;
  while i<20 do begin
    while j<i+1 do begin
      write('');
      j:=j+1;
    end;
    j:=1;
    i:=i+1;
    writeln;
  end;
  readkey;
end.

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

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

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

Цикл – это…

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

• тело;
• заголовок.

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

Как только последняя инструкция тела достигнута, поток повторения делает возврат к заголовку. Условие будет проверяться снова и снова. В зависимости от полученного результата программы ведут себя тем или иным образом:

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

Большинство ЯП предусматривают три цикла для создания разнообразных приложений:

• со счетчиком – for;
• repeat (или do while) – с постусловием;
• while – с предусловием.

Выше – пример того, как работают соответствующие блоки кода в Pascal. Упор будет сделан на for.

Цикл While

С двумя остальными циклами (петлями) стоит разобрать на примере Pascal. Это – самый простой способ полноценно освоить соответствующее направление.

Первый тип петли – с предусловием. Для него используется оператор while. Здесь:

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

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

Оператор Repeat

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

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

Здесь:

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

Выше – пример того, как будет выглядеть соответствующая петля на практике в Pascal. Это – элементарное приложение, которое посчитает сумму чисел.

For – это петля со счетчиком. Является достаточно распространенным на практике. Встречается в самых разных языках программирования. Далее будут приведены примеры из Pascal, C++ и C#. Каждый ЯП рассмотрен отдельно.

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

В Pascal

For в Pascal использовать не слишком трудно. Это – петля со счетчиком. Итерации цикла будут определяться разницей между первым и вторым значением + единица. Тело здесь не должно включать в себя выражения, которые могут внести в счетчик корректировки.

Pascal предусматривает две формы представления:

• For счетчик := начало to конец do тело;
• For счетчик := начало downto конец do тело.

Если поставить to между концом и началом в for i, каждый шаг петли увеличивается на +1, а downto уменьшает его на -1.

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

В for итерации цикла (их количество) известно до того, как программа будет выполнена. Можно сделать так, чтобы этот момент регулировал пользователь.

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

В C++

C++ — язык программирования, который должен освоить каждый разработчик. Особенно это касается тех, кто серьезно планирует заниматься созданием контента. Здесь тоже есть for.

Он позволяет повторять одни и те же операции несколько раз. Сколько – известно до окончательного запуска приложения. Ниже – синтаксис «петли».

Здесь необходимо запомнить следующее:

1. <объявление счетчика> — создается переменная (счетчик цикла for), после чего задается ее первоначальное значение. Соответствующая команда будет выполняться до того, как рассматриваемый блок кода запустится. Это – первоначальное значение счетчика.
2. <условие выполнения> — напоминает условие оператора if. Здесь прописывается логическое выражение, которое будет обрабатываться приложением. В зависимости от результата меняется алгоритм действий. Если «на выходе» получается логическая «истина» — петля выполняет прописанный внутри блока код.
3. <шаг цикла> — инструкция, выполняемая в конце итерации. Переводит счетчик for на новое значение.
4. <тело> — код, необходимый для выполнения при «истинности» на той или иной итерации. То, что будет выполняться в ходе обработки запроса.

А вот – пример программы, которая найдет произведение цифр от 1 до n (факториал).

Выше – результат обработки кода.

В C#

C# тоже стал использоваться достаточно часто, поэтому на него стоит обратить внимание. У него есть цикл for. Он напоминает по синтаксису C++:

Тоже необходим для многократного повторения тех или иных операций. Работает так:

1. В for объявляются три переменные: счетчик, итератор и условие.
2. Объявление счетчика осуществляется всего один раз. Делается это в самом начале. Он инициализируется после того, как будет объявлен.
3. Происходит проверка условия (это – булево выражение). Результат – true или false.
4. Если итог – «истина», выполняется тело. Далее – инициализируется итератор (изменяется значение соответствующей переменной), а условие проходит повторную проверку. Процедура не заканчивается, пока не произойдет возврат false.

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

Выше – пример кода в C#, демонстрирующий вычисление суммы первых n натуральных чисел.

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus!

│




Deutsch (de) │
English (en) │




français (fr) │










русский (ru) │

for is a keyword used in conjunction with other keywords to create loops.

loop with iterator variable

for used along with to/downto and do constructs a loop in which the value of a control variable is incremented or decremented by 1 passing every iteration.

behavior

for controlVariable := start to finalValue do
begin
	statement;
end;

In this example controlVariable is first initialized with the value of start (but cmp. § “legacy” below).
If and as long as controlVariable is not greater than finalValue, the begin … end frame with all its statements is executed.
By reaching end controlVariable is incremented by 1 and the comparison is made, whether another iteration, whether the statement-frame is executed again.

reverse direction

By exchanging to with downto, the variable – in the example controlVariable – is decremented by 1 and the condition becomes “as long as the control variable is not less than the final value.”

constraints

scope requirements

The control variable has to be local inside nested routines.
A routine is nested, if routine variables tagged with the modifier is nested can store its address.
Nevertheless, a global variable is always allowed as a control variable.

immutable requirement

While inside in a loop, it is imperative not to mess with the loop variable.
Plain assignments – e. g. controlVariable := 2 – are caught by the compiler reporting “Illegal assignment to for-loop variable «controlVariable»”.
However, indirect manipulations are not prevented:

program iteratorManipulation(input, output, stderr);

var
	i: longint;

procedure foo;
begin
	i := 1;
end;

begin
	for i := 0 to 2 do
	begin
		writeLn(i);
		foo;
	end;
end.

The global variable i is modified by calling foo.
The program runs an infinite loop.

type restrictions

The type of controlVariable has to be enumerable.
Assuming your system operates on ASCII you can do

var
	c: char;
begin
	for c := 'a' to 'z' do
	begin
		writeLn(c);
	end;
end.

or generally use any type that is enumerable.

other step widths

Other step widths than 1 or -1 are not possible by utilizing this syntax.
You have to use other loop constructs such as while … do and manually initialize, compare and change the controlVariable.

The matter, whether FreePascal could provide a syntax specifying other step widths, came up several times.
In general it was regarded as “syntactic sugar”, though, and in order to stay compatible Pascal’s core, or Delphi’s extensions, in order to avoid any impetuous decisions, the developers remained rather conservative and rejected any changes in that direction.

^{See also FPC issue 25549.}

limits

Note, as it is common in mathematics when writing sums [math]displaystyle{ sum_{n=0}^{k} }[/math] or products [math]displaystyle{ prod_{n=1}^{k} }[/math] the limits are inclusive.

for i := 5 to 5 do
begin
	writeLn(i);
end;

This excerpt will print one line with 5, though you might be fooled by such thoughts as “5 to 5 – the difference is zero. So the body must never be executed.”
This is in fact wrong.
Not the difference determines the number of iterations, but the cardinality of the set constructed by the expression [start..finalValue].
This can be an empty set, or in the case of [5..5] just the single-element set [math]displaystyle{ left{5right} }[/math].

legacy

Assuming no other manipulations were made, after the loop the value of controlVariable will be final, unless the the proper condition was not met from the start, then it is undefined (remains unchanged).

In case of empty loops (where the body is never executed), even the start value is not loaded.
Rationale:
The controlVariable exists for usage inside the loop’s body.
If the loop’s body is not entered, then the value might remain unused.
We generally avoid unused values, i. e. any unnecessary assignment without successive reads.

short syntax

For single statements writing a surrounding begin … end frame can be skipped resulting in:

for controlVariable := start to final do
	statement;

It is advised though, to make use of that only in justified cases, where the readability is improved and it is very unlikely the loop is expanded by any additional statement.
Too many programmers inadvertently fell for the pitfall before and added a properly indented line forgetting it requires a surrounding begin … end then, too.

Make it a habit and always accompany for-loops with begin … end, leaving the option to possibly eliminate those at a later stage, prior a complete code freeze (but not right in the middle of development).

loop with elements

With for … in loops the variable that is changed every iteration represents an element out of a collection.
This works on strings, arrays, sets, and any other custom collection that implements the required iterators. Looping over an empty collection simply does nothing.

type
	furniture = (chair, desk, bed, wardrobe);
	arrangement = set of furniture;
var
	thing: furniture;
begin
	writeLn('all available pieces of furniture:');
	for thing in arrangement do
	begin
		writeLn(thing);
	end;
end.

In contrast to other loops, an index variable is not provided.
In the above example ord(thing) will return an index, but it has to be additionally retrieved while it inherently exists yet still inaccessible.
Proposals were made, whether and how to extend the syntax allowing to specify an index variable that is adjusted with every iteration.

special commands

Inside loops (including for-loops) two special commands tamper with the regular loop-program-flow.
system.continue skips the rest of the statements in one iteration.
Effectively in a for-loop the next element/index is immediately assigned to the control variable, the regular check is performed, and processing of all the statements might start from the top again.
Additionally system.break instantly skips the whole loop altogether.
This is different to system.exit, which exits the whole frame, but loops do not create frames (but blocks do).

Their usage however is usually discredited, since they “disqualify” the loop’s iteration condition.
One has to know a loop’s body contains such commands, in order to actually determine how often a loop is executed.
Without such, you can tell how many times a loop is run just by inspecting the loop’s head or tail respectively.

see also

• Example: Why the loop variable should be of signed type
• {$rangechecks}

Keywords: begin — do — else — end — for — if — repeat — then — until — while