Советы и лайфхаки

Go to в паскале – Оператор перехода goto в Pascal или метки

Операторы goto, break, continue и прекращения программы

Оператор безусловного перехода goto

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

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

Необходимо знать, что всегда можно обойтись без оператора goto. Его использование затрудняет чтение и понимание программы.

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

label, после которого через запятую перечисляются метки.

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

goto метка;

label goback;
var num: real;
 
begin
    goback:
    write ('Введите число: ');
    readln (num);
 
    if num < 0 then
        goto goback;
 
    num := sqrt (num);
 
    write ('Квадратный корень: ', num:5:2);
 
readln
end.

Операторы break и continue

Бывает, что цель выполнения цикла достигается раньше, чем он будет прекращен по условию выхода. Так, например, в программе для определения простоты числа цикл будет выполняться n div 2-1 раз, хотя то, что число не является простым, может быть обнаружено на первых шагах цикла. Чтобы уменьшить количество шагов цикла, можно воспользоваться оператором goto, либо сформировать сложное условие выполнения (прекращения) цикла.

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

Break и continue являются процедурами, хотя обычно их называют операторами.

Операторы break и continue выполняются в любом из видов циклов (repeat, while, for) и действительны только для внутреннего цикла. Например, если нужно обеспечить принудительный выход из двойного цикла, оператор break должен быть расположен как во внутреннем, так и во внешнем цикле. Операторы break и continue по сути являются видоизмененными операторами goto с известной точкой, в которую осуществляется переход.

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

 

var
    num: real;
    i: integer;
 
begin
    for i := 1 to 5 do begin
        write ('Введите число: ');
        readln (num);
        if num = 0 then
            break;
        writeln (num)
    end;
 
readln
end.

В примере запрашиваются пять чисел и суммируются только положительные из них.

var
    num, sum: real;
    i: integer;
 
begin
    sum := 0;
 
    for i := 1 to 5 do begin
        write ('Введите число: ');
        readln (num);
        if num < 0 then
            continue;
        sum := sum + num
    end;
 
    write (sum:10:2);
 
readln
end.

Принудительное прекращение программы

Обычно программа завершает свою работу по достижении последнего оператора (т.е. при выходе на оператор end с точкой). Если возникает необходимость прекратить выполнение программы где-либо внутри нее, то можно воспользоваться процедурой halt, которая вызывается как отдельный оператор. Эту процедуру можно вызвать, задав в круглых скобках параметр в виде целого неотрицательного числа от 0 до 255. Это значение возвращается в операционную систему в виде кода ошибки (ERRORLEVEL) и может быть проанализирована DOS в случае запуска данной программы из командного файла. Отсутствие параметра в процедуре halt соответствует значению параметра 0 (нормальное завершение программы).

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

pas1.ru

паскаль, как работать с оператором goto, как ставить метки, чтобы при операции goto 1,

Если будет непонятно, тогда пиши!
Это тема метки и операторы перехода из моего учебника:

Метки и операторы перехода.
Можно теоретически показать, что рассмотренных операторов вполне достаточно
для написания программ любой сложности. В этом отношении наличие в языке опера-
торов перехода кажется излишним. Более того, современная технология структурного
программирования основана на принципе «программировать без GOTO»: считается,
что злоупотребление операторами перехода затрудняет понимание программы, делает
ее запутанной и сложной в отладке.
Тем не менее, в некоторых случаях использование операторов перехода может уп-
ростить программу.
Оператор перехода имеет вид:
GOTO <метка>.
Здесь GOTO - зарезервированное слово (перейти [на метку]) ;
<метка> - метка.
Метка в Турбо Паскале - это произвольный идентификатор, позволяющий имено-
вать некоторый оператор программы и таким образом ссылаться на него. В целях со-
вместимости со стандартным языком Паскаль в языке Турбо Паскаль допускается в

качестве меток использование также целых чисел без знака.
Метка располагается непосредственно перед помечаемым оператором и отделяется
от него двоеточием. Оператор можно помечать несколькими метками, которые в этом
случае отделяются друг от друга двоеточием. Перед тем как появиться в программе,
метка должна быть описана. Описание меток состоит из зарезервированного слова
LABEL (метка) , за которым следует список меток:
label
loop, 1Ы, 1Ь2;
begin
goto 1Ы;
loop:
1Ы : 1Ъ2 :
goto 1Ь2,-
Действие оператора GOTO состоит в передаче управления соответствующему ме-
ченному оператору.
При использовании меток необходимо руководствоваться следующими правилами:
• метка, на которую ссылается оператор GOTO, должна быть описана в разделе
описаний и она обязательно должна встретиться где-нибудь в теле программы;
• метки, описанные в процедуре (функции) , локализуются в ней, поэтому переда-
ча управления извне процедуры (функции) на метку внутри нее невозможна.

otvet.mail.ru

GOTO - это... Что такое GOTO?

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

Функциональность

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

метка: (то есть имя метки, за которым следует двоеточие), возможны и другие соглашения.

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

Распространение

GOTO имеется в таких языках, как Фортран, Алгол, КОБОЛ, Бейсик, Си, C++, C#, D, Паскаль, Perl, Ада, PHP, а также во многих других. GOTO присутствует также во всех языках ассемблера в форме JMP, JUMP или BRA (от англ. branch — ветвь) и используется там чрезвычайно активно. Свобода использования оператора GOTO в различных языках сильно различается. Если в ассемблерах или языках типа Фортрана он может применяться произвольно (допускается передача управления внутрь ветви условного оператора или внутрь тела цикла, а иногда и процедуры), то в более поздних языках высокого уровня его использование ограничено: как правило, с помощью GOTO запрещено передавать управление между различными процедурами и функциями, внутрь выделенного блока операторов, между ветвями условного оператора и оператора множественного выбора.

GOTO отсутствует в некоторых языках высокого уровня, например в Forth (но может быть реализовано средствами самого языка). В Паскаль GOTO первоначально включён не был, но недостаточность имеющихся языковых средств вынудила Никлауса Вирта его добавить. В более поздних своих языках Вирт всё же отказался от GOTO: этого оператора нет ни в Модуле-2, ни в Обероне и Компонентном Паскале. В Java есть зарезервированное слово goto, но оно не несёт никаких функций — оператора безусловного перехода в языке нет. Однако переход осуществить можно. При этом в языке сохранились метки — они могут применяться для выхода из вложенных циклов операторами break и continue.

Критика

Оператор GOTO в языках высокого уровня является объектом критики, поскольку чрезмерное его применение приводит к созданию нечитаемого «спагетти-кода». Впервые эта точка зрения была отражена в статье Эдсгера Дейкстры «Доводы против оператора GOTO»

[1], который заметил, что качество программного кода обратно пропорционально количеству операторов GOTO в нём. Статья приобрела широкую известность как среди теоретиков, так и среди практиков программирования, в результате чего взгляды на использование оператора GOTO были существенно пересмотрены. В своей следующей работе Дейкстра обосновал тот факт, что для кода без GOTO намного легче проверить формальную корректность.

Код с GOTO трудно форматировать, так как он может нарушать иерархичность выполнения (то есть парадигму структурного программирования), и потому отступы, призванные отображать структуру программы, не всегда могут быть выставлены правильно. GOTO также аннулирует многие возможности компилятора по оптимизации управляющих структур[2].

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

  • В языках, имеющих блочную структуру, допускающую описание в каждом блоке своих локальных переменных (например, в C или C++), передача управления внутрь блока «обходит» часть описаний этих переменных. Соответственно, может быть пропущено выделение памяти и вызов конструкторов для некоторых локальных переменных. По завершении блока будет происходить (в случае C++) вызов деструкторов для всех объявленных в блоке переменных, после чего — автоматическое удаление локальных переменных из памяти. В результате, как минимум, будут вызваны деструкторы для переменных, для которых не вызывались конструкторы, а в худшем случае произойдёт попытка освобождения не выделенной памяти, что вызовет ошибку.
  if (a > 0) {goto inner};
  ... // какие-то команды
  {
    X ax = X(a);
    ... // какие-то команды
  inner:
    // Сюда произойдёт переход по goto
    ...
    // По завершении всех команд блока компилятор вызовет 
    // деструктор ~X() для переменной ax.
  }
В вышеприведённом примере в случае перехода по goto в конце блока, выделенного фигурными скобками, будет вызван деструктор для ax, хотя конструктор для этой переменной не вызывался.
  • Передача управления внутрь тела цикла приводит к пропуску кода инициализации цикла или первоначальной проверки условия. Последствия непредсказуемы.
  • Передача управления между ветвями условного оператора приводит к тому, что выполняется часть команд, соответствующих выполнению условия, и часть команд, соответствующих его ложности.
  • Передача управления внутрь процедуры или функции может приводить к непредсказуемым последствиям. Поскольку правильная команда вызова процедуры не выполнялась, на вершине стека возврата находится адрес возврата из той процедуры, откуда вызвался GOTO, за которым, возможно, находится содержимое локальных переменных процедуры, если они размещаются в стеке. В результате, если только такая ситуация не обрабатывается компилятором специально, по завершении процедуры или функции, внутрь которой произведён переход, произойдёт разрушение стека и переход по непредсказуемому адресу.

Доводы против оператора GOTO оказались столь серьёзны, что в структурном программировании его стали рассматривать как крайне нежелательный. Это нашло своё отражение при проектировании новых языков программирования. Например, GOTO был намеренно полностью запрещён в Java и Ruby. Вместе с тем, в ряде современных языков он оставлен из соображений эффективности кодирования в тех редких случаях, когда применение GOTO оправданно. Так, GOTO сохранился в Аде — одном из наиболее продуманных с точки зрения архитектуры языке за всю историю[3]. Однако в тех современных языках высокого уровня, где этот оператор существует, на его использование, как правило, накладываются жёсткие ограничения, препятствующие использованию наиболее опасных методов его применения. В частности, как правило, категорически запрещается передавать управление извне процедуры или функции внутрь неё, извне цикла — внутрь его тела, из одной ветви условного оператора или оператора-переключателя — в другую его ветвь. ANSI-стандарт языка C++ запрещает обход инициализации переменной с помощью GOTO (то есть фрагмент кода, приведённый выше, современным транслятором, например, gcc 4.5, будет отвергнут как синтаксически некорректный). Встречаются и более жёсткие ограничения, например, запрет на передачу управления по GOTO внутрь любого выделенного блока в программе извне этого блока.

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

Оправданное применение

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

Выход из нескольких вложенных циклов сразу

Обычно считается, что в языках, где операторы досрочного завершения цикла (такие, как break и continue в Си) могут относиться только к тому из вложенных циклов, в котором они расположены, использование goto допустимо, чтобы выйти из нескольких вложенных циклов сразу. Здесь GOTO значительно упрощает программу, избавляя от необходимости создания вспомогательных переменных-флагов и условных операторов.

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

Пример:

int matrix[n][m];
int value;
...
for(int i=0; i<n; i++)
  for (int j=0; j<m; j++)
    if (matrix[i][j] == value)
    {
      printf("value %d found in cell (%d,%d)\n",value,i,j);
      //act if found
      goto end_loop;
    }
printf("value %d not found\n",value);
//act if not found
end_loop: ;

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

Без изменения структуры кода проблема решается, если команда break (или её аналог) позволяет выйти из нескольких вложенных блоков сразу, как в Java или Ada. Аналогичный код на Java никакого goto не требует:

int[][] matrix;
int value;
...
outer: {
  for(int i=0; i<n; i++)
    for (int j=0; j<m; j++)
      if (matrix[i][j] == value)
      {
        System.out.println("value " + value + " found in cell (" + i + "," + j + ")");
        break outer;
      }
  System.out.println("value " + value + " not found");
}

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

Обработка ошибок

Этот случай применим к языкам, не содержащим конструкции try ... finally — например, к C без применения SEH, существующего только в Windows. В этом случае goto используется для перехода на код «очистки» — находящийся в конце функции и уничтожающий созданные ею объекты перед выходом из неё. Этот метод широко используется при написании драйверов.

Пример такой обработки ошибок (все имена и константы, кроме NULL, вымышлены и приведены лишь для примера):

int fn( int* presult )
{
  int sts = 0;
  TYPE entity, another_entity = NULL;
  TYPE2 entity2 = NULL;
 
  if ( !( entity = create_entity() ) )
    { sts = ERROR_CODE1; goto exit0; }
 
  if ( !do_something( entity ) )
    { sts = ERROR_CODE2; goto exit1; }
 
  if ( condition ) {
    if ( !( entity2 = create_another_entity() ) )
      { sts = ERROR_CODE3; goto exit1; }
 
    if ( ( *presult = do_another_thing( entity2 ) == NEGATIVE )
      { sts = ERROR_CODE4; goto exit2; }
  } 
  else {
    if ( ( *presult = do_something_special( entity ) == NEGATIVE )
      { sts = ERROR_CODE5; goto exit2; }
  }
  exit2: if ( entity2 ) destroy_another_entity( entity2 );
  exit1: destroy_entity( entity );
  exit0: return sts;
}

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

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

Автогенерация кода

Ещё одним допустимым применением безусловного перехода является код, который генерируется автоматически, например, генерируемые с помощью программных инструментальных средств лексические и синтаксические анализаторы. Например, код, генерируемый утилитами yacc, lex, bison изобилует командами goto, но в этом нет ничего плохого, так как этот код в принципе не предназначен для восприятия и редактирования человеком, а его корректность целиком определяется корректностью создающего его инструмента. Иначе говоря, здесь имеет место та же самая ситуация, что в случае с компилятором языка высокого уровня, создающим машинный код (с неизбежными командами безусловного перехода) просто потому, что таков целевой язык.

См. также

  • Теорема Бома — Якопини

Примечания

Ссылки

dic.academic.ru

Циклы в Паскале

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

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

Цикл for

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

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

Цикл for существует в двух формах:

for счетчик:=значение to конечное_значение do 
     тело_цикла;
for счетчик:=значение downto конечное_значение do 
     тело_цикла;

Счетчик – это переменная любого из перечисляемых типов (целого, булевого, символьного, диапазонного, перечисления). Начальные и конечные значения могут быть представлены не только значениями, но и выражениями, возвращающими совместимые с типом счетчика типы данных. Если между начальным и конечным выражением указано служебное слово to, то на каждом шаге цикла значение параметра будет увеличиваться на единицу. Если же указано downto, то значение параметра будет уменьшаться на единицу.

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

var
    i, n: integer;
 
begin
    write ('Количество знаков: ');
    readln (n);
 
    for i := 1 to n do
        write ('(*) ');
 
readln
end.

Цикл while

Цикл while является циклом с предусловием. В заголовке цикла находится логическое выражение. Если оно возвращает true, то тело цикла выполняется, если false – то нет.

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

var
    i, n: integer;
 
begin
    write ('Количество знаков: ');
    readln (n);
 
    i := 1;
    while i <= n do begin
        write ('(*) ');
        i := i + 1
    end;
 
readln
end.

Цикл repeat

Цикл while может не выполниться ни разу, если логическое выражение в заголовке сразу вернуло false. Однако такая ситуация не всегда может быть приемлемой. Бывает, что тело цикла должно выполниться хотя бы один раз, не зависимо оттого, что вернет логическое выражение. В таком случае используется цикл repeat – цикл с постусловием.

В цикле repeat логическое выражение стоит после тела цикла. Причем, в отличие от цикла while, здесь всё наоборот: в случае true происходит выход из цикла, в случае false – его повторение.

var
    i, n: integer;
 
begin
    write ('Количество знаков: ');
    readln (n);
 
    i := 1;
    repeat
        write ('(*) ');
        i := i + 1
    until i > n;
 
readln
end.

В примере, даже если n будет равно 0, одна звездочка все равно будет напечатана.

pas1.ru

Циклы в Паскале

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

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

цикл с предусловием;

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

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

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10

program for_primer;
uses crt;
var i, x: integer;
begin
write(‘X=’);
readln(x);
for i:=1 to x do
write(#3, #6);
readkey;
end.

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

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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, так как операторов в теле цикла несколько.

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

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

Repeat

<тело цикла>

Until <условие>

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

1
2
3
4
5
6
7
8
9
10
11
12

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 – осуществляет переход к новой итерации.


Похожие записи:

kvodo.ru

Pascal

Модули в Паскале по отношению к основной части программы напоминают подпрограммы (процедуры и функции). Но…

Типизированные файлы Файл, определенный стандартным или пользовательским типом данных, называется типизированным. Общая форма объявления типизированных…

В язык Паскаль выделяются данные файлового типа, которые служат для работы с информацией, расположенной на…

Алгоритм, в котором предусмотрен вызов подпрограммой себя самой, называется рекурсивным. Использовать эту особенность в Pascal…

Процедуры и функции в языке Pascal являются подпрограммами. Подпрограмма – это именованная часть программы, представляющая…

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

Под множеством в Паскале понимается совокупность взаимосвязанных элементов одного типа. Его элементы должны быть порядкового…

Строка в Pascal – это последовательность символов заключенных в апострофы. Переменную строкового типа данных определяет…

Тем, кто знакомым с математическими матрицами, будет не трудно освоить и двумерные массивы в Pascal.…

Одномерный массив – это именованная последовательность, состоящая из пронумерованных элементов одного типа. Элементы могут быть…

kvodo.ru

Оболочка Turbo Pascal - Pascal

Для того, чтобы войти в главное меню оболочки ТУРБО-ПАСКАЛЯ 6.0, необходимо нажать клавишу F10. Поиск нужного меню осуществляется при помощи курсорных клавиш. Переход от команды к команде в диалоговом окне какой-либо команды оболочки осуществляется нажатием клавиши TAB. Выход из главного меню оболочки или диалогового окна осуществляется нажатием клавиши Esc.

Команды оболочки ТУРБО-ПАСКАЛЯ 6.0

Меню: Ё

About - номер версии и название фирмы.

Refresh Display - восстановить экран.

Clear Desktop - подготовка к новой работе (очистить, закрыть все окна).

Меню: File

Open - открыть старый файл в окне Edit.

New - открыть новое окно.

Save - сохранить файл.

Save As - сохранить файл с именем.

Save All - сохранить все файлы.

Change Dir - изменить текущий каталог.

Print - печать текста программы.

Get Info - получить информацию о состоянии памяти.

DOS Shell - временно выйти в DOS (для возвращения набрать EXIT).

Exit - выйти из среды.

Меню: Edit

Restore Line - восстановить строку.

Cut - вырезать фрагмент.

Copy - копировать фрагмент.

Paste - вставить фрагмент.

Copy Example - копировать фрагмент из HELP.

Show Clipboard - просмотреть окно с текстом выбранным командой.

Clear - очистить редакционное окно.

Меню: Search

Find - найти заданный текст.

Replace - заменитьтекст.

Search Again - повторить поиск.

Goto line number - перейти к строке с заданным номером.

Find Procedure - найти процедуру.

Find Error - найти ошибку.

Меню: Run

Run - выполнить программу.

Program reset - сбросить программу.

Go to Cursor - выполнить до строки с курсором.

Trace into - выполнить программу построчно (т.е. с заходом в процедуры).

Step over - выполнить программу пошагово (т.е. без захода в процедуры).

Parameters - установить параметры.

Меню: Compile

Compile - компиляция программы.

Make - сборка.

Build - полная сборка.

Destination - в какую память компилировать.

Primary File - основной файл.

Меню: Debug

Evaluate/Modify - вычисление/модификация.

Watches - просмотр.

Add Watch - добавить выражение для просмотра.

Delete Watch - удалить выражение просмотра.

Edit Watch - редактировать выражение просмотра.

Remove All Watches - удалить все выражения просмотра.

Toggle Breakpoint - переключить точку прерывания.

Breakpoints - точки прерывания.

Меню: Options

Compiler - компилятор.

Memory Sizes - размеры памяти.

Linker - редактор связей.

Debugger - отладчик.

Directories - каталоги.

Environment(среда).

Preferences - установки предпочтений.

Editor - редактор.

Mouse - мышка.

Startup - начальные установки.

Colours - цвета.

Save Options - сохранить установки.

Retrieve options - восстановить установки.

Меню: Window

Size/Move - изменение размера окна и положения на экране.

Zoom - масштабирование.

Tile - расположение окон одно под другим.

Cascade - расположение окон каскадом.

Next - активировать следующее окно.

Previous - активировать предыдущее окно.

Close - закрыть активное окно.

Watch - открыть окно просмотра параметров при отладке.

Register - показать окно с регистрами.

Ouput - открыть окно вывода.

Call Stack - открыть окно со стеком.

User Screen - открыть окно с экраном пользователя.

List - список открытых окон.

Меню: Help

Contents - показать содержание для выбора темы.

Index - показать список ключевых слов для выбора темы.

Topic Search - поиск заданной темы.

Previous Topic - показать предыдущий раздел.

Help on Help - как работать с подсказкой.

itteach.ru

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

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