Лекция 8
Лекция 8
Операторный базис
С точки зрения операторного базиса во всех современных ЯП достигнут консенсус, конечно, есть некие синтаксические отличия, однако по семантике различные конструкции практически эквивалентны. Поэтому, как правило, человеку, который свободно владеет одним или двумя ЯП, перейти на новый операторный базис нового языка достаточно просто. Основные дискуссии по поводу операторов в ЯП свёлся к тому, что соответствующие управляющие структуры должны представлять собой некий «чёрный ящик» с одним входом и одним выходом.
 |
С этой точки зрения, развернулись дискуссии по поводу таких конструкций как цикл, из-за сложности управляющих вычислений. И тут достигнут такой консенсус: в ЯП сейчас есть три вида циклов - два цикла с условием: «до» и «пока»; и, так называемый, цикл с управлением пользователем. Ну и бесконечный цикл. Мы их рассмотрим позже.
А в общем случае все операторы в ЯП, за исключением некоторых слишком специфичных можно разделить на следующие группы:
логические (if)
1.Ветвления дискретные (case)
многовариантные логические (if…elsif…)
Рекомендуемые материалы
с условием («до»/«пока»)
2.Циклы со счётчиком
с управлением пользователем
Цикл с управлением пользователем - это цикл, выход из которого допустим из любой точки. С точки зрения общей структуры вход всё равно один, ну а выход всегда идёт в конец. Необходимость в управляющих структурах такого рода, конечно же, есть. При этом в простейшем языке, скажем в Паскале, можно моделировать подобного рода семантику с помощью операторов «goto», но современные ЯП содержать достаточное количество конструкций, которые в купе с операторами ветвления и циклов позволяют моделировать произвольные структурированные прототипы.
3.Переходы
4.Составной оператор
Есть ещё некие экзотические, специфичные для некоторых ЯП структуры, например, частный случай оператора цикла со счётчиком, а именно «foreach». Есть, скажем, связанный с параллелизмом в Аде специфический оператор «select». Но мы рассмотрим только общие операторы, которые имеют общее назначение и необходимы во всех парадигмах.
1)Простейшие логические ветвления появились впервые в языке Алгол 60, и в этом виде они были скопированы во многие другие ЯП, прежде всего в язык Паскаль, Си и, основанный на Си, С++, Java, C#. Его структура:
if условие then S1 [else S2] //[…]- «часть может отсутствовать»
И если синтаксис может быть совершенно разным, в языках, основанных на Си, синтаксис следующий:
if (B) S1 [else S2]
Семантика его совершенно общеупотребительна. Отличие Си от С++ в том, что в этих языках нет логического типа данных. Ну в С++ он уже появился, но тем не менее для совместимости со старыми стилем программирования это условие приводится, как вы помните, поскольку существуют неявные операторы приведения к целому типу практически любого типа данных, это условие сводится к целому типу данных, проверяется на ноль или не ноль. Во всех остальных языках под B понимается логическое (булевское) выражение, а такой тип данных есть во всех современных ЯП. И тут особых проблем нет. Ну, правда, первая же проблема возникла сразу после появления Алгола 60, а именно, случай когда у нас комбинируется укороченный оператор if без else и комбинированный оператор, иначе говоря, у нас есть два if и только один else:
if B1 then
if B2 then
S1
else
S2
Как вы понимаете такого рода конструкцию можно трактовать по-разному. То ли B1 является укороченным, то ли B2. Многие компиляторы ЯП, реализации компиляторов, в случае обнаружения подобного рода конструкций в этой части выдают предупреждение, советуя программисту, сказать, что именно в явном виду имеется в виду. Впервые, кстати, даже при описании Алгола 60 подобного рода проблема не была замечена. Её заметили только в 63 году, ну и тогда же в 63 году была достигнута некая договорённость, выпущено новое описание к Алголу 60, которое и применяют все языки, основанные на Алгольской схеме, а именно, то, что else принадлежит ближайшему if. В любом случае, профессиональный программист, по крайней мере, с помощью отступов, выравниваний, то есть некоторого визуального стиля программирования, должен, вообще говоря, указывать, о чём идёт речь. А ещё лучше - расставлять скобки.
Интересно, что ряд языков, особенно те, которые претендовали на надёжность, они несколько изменили синтаксическую схему условного оператора, а именно, ну это такие языки, как Модула 2 и её наследник Оберон, а также Ада. Эти языки, в отличие от языков, которые основаны на С++, то есть Java, C#, ну и, соответственно, Delphi, который основан на Паскале (они используют старую конструкцию), в этих же языках (Модула, Ада, Оберон) принята другая схема, а именно каждый оператор, отличный от оператора присваивания и оператора процедуры, то есть в котором есть вложенные конструкции, этот оператор должен заканчиваться своим ключевым словом. Впервые эта идея была предложена в языке Алгол 68 довольно оригинально, а именно: начинается оператор с if, давайте его заканчивать ключевым словом fi, если, соответственно, case, тогда – красивым словом esac, ну и так далее. Ну, вообще говоря, это решение довольно оригинальное, но создатели последующих ЯП пошли по другому принципу. В Модуле 2 каждый подобного рода оператор, который может включать в себя другие операторы, обязательно должен заканчиваться ключевым словом end. То же самое приняла Ада, только Ада многословный язык, если есть возможность написать больше, значит надо писать, а именно endif. В результате проблемы с вложенными if’ами просто не возникает:
if B1 then
if B2 then
S1
endif
else
S2
endif
или
if B1 then
if B2 then
S1
else
S2
endif
endif
То есть в любом случае программисту не дадут уйти, если он не напишет соответствующего endif’а. Кстати, как следствие, если в ЯП, основанных на Алгольском стиле условного оператора if, если нам внутри нужна некая последовательность операторов, то мы её заменяем на составной оператор, ну соответственно, begin end в Алголе или {…}. При этом и в Алголе 60 и в Си в качестве составного оператора можно использовать более общую его схему, а именно блок, то есть с вложенными объявлениями переменных и с локальными областями видимости. В случае же если мы принимаем решение заканчивать каждый оператор с вложенными операторами явным ключевым словом (как говорят языки с явными терминаторами), так вот языки с явными терминаторами не требуют ограничения, чтобы внутри стоял только один оператор, а именно у нас естественным ограничителями последовательности операторов выступают скобки then … else, либо скобки then … endif; else …endif. В любом случае, с точки зрения компилятора if синтаксически разрешается. Вспомним тот же цикл
repeat
...
until B;
в языке Паскаль, где внутри могла стоять произвольная последовательность операторов, и это было достаточно удобно.
Довольно часто у нас возникает необходимость в развилке не на два направления, а на несколько и вот тут, вообще говоря, в ЯП вместо одной конструкции ветвления появилось две, а именно дискретный оператор ветвления и оператор ветвления общего вида. Дискретный оператор ветвления появился впервые в языке Алгол 68. В принципе любую последовательность ветвлений можно запрограммировать с помощью последовательности условных операторов. Общая схема многовариантного ветвления:
 |
где Si – составной оператор. В общем случае, ветвление реализуется с помощью вложенных конструкций if. И на Си естественным образом программисты изображают это так:
 |
if (B1)
S1
else if (B2)
S2
…
else if (BN)
SN
else
SN+1
Хотя синтаксически это дерево вложенных операторов, мы выравниваем влево, из-за ограниченности экрана и психологической причины, то есть из-за того, что люди не любят вложенные структуры (об этом можно судить по примеру русского языка), а более естественны структуры из последовательных переходов (вопрос …, вопрос …, …). Но в языках с явными терминаторами, кроме появления N штук then’ов, что не существенно, в конце мы должны записать подряд столько endif’ов, сколько у нас было if’ов. Впервые подобная вещь была отмечена ещё в языке PL|I, где можно было ставить метку END (перед else if …) и в конце всего один end. Но она сразу была забракована, как страшно ненадёжная.
Коль скоро мы приняли решение о явном терминаторе, то нам нужна некая конструкция для моделирования вложенных if’ов, а именно в Аде и в Модуле 2 появилось ключевое слово elsif. То есть общий вид условного оператора принял несколько более хитрую форму, а именно:
if B1 then
S1
{elsif Bi then //{…} «произвольная последовательность,
Si // в том числе и пустая»
}
[else BN then
SN
]
endif
В языке Паскаль такой конструкции не было, так как её можно было промоделировать вложенными if’ами, но уже в языке Паскаль появился так называемый дискретный выбор, а именно, если каждое условие Bi имеет вид: e = const. Где e – выражение какого-то дискретного типа, а const – это константа такого же дискретного типа. В программировании такая необходимость появляется достаточно часто. И ещё одна причина: на ассемблере при просмотре N значений, то есть при выборе от 0 до N-1, мы реализуем не последовательный просмотр, когда нам приходится проверять все условия до искомого включительно, а такую конструкцию можно запрограммировать весьма эффективно с помощью встроенных ассемблерных операций перехода. В ранних ЯП для этих целей вводились специальные виды операторов перехода (Фортран: 4 вида операторов перехода и 2 вида условных операторов, которые тоже сводились явно или неявно к оператору перехода).
В Паскале:
 |
сase e of
e1: S1;
…
en: SN;
end;
С явным терминатором end. В Турбо Паскале добавилась только else часть, если e не попадает не в одно из этих значений:
.
.
.
else
SN+1
end;
И возможность использования нескольких констант вместо одной. Так как в Модуле 2 требуются явные терминаторы, то последовательности операторов заканчиваются «|»:
сase e of
e1: S1; … |
…
en: SN; … |
else
SN+1
end;
В Модуле 2 разрешён в левой части список констант и список диапазонов: 1,2,5..10; что перешло во все расширения Паскаля. В Аде case выглядит следующим образом:
case e of
when 1|2|5..10 => S1;
when 3|12 => S…,
when others =>
…
end case
Естественно, when others может отсутствовать, что равносильно пустому оператору для других значений e.
В Си с помощью оператора switch был внесён неявный оператор перехода, который вследствие популярности языка С++ был перенесён во многие другие ЯП, которые внешне понятием совместимость не были обременены, а именно синтаксис оператора switch практически без изменений перешёл в оператор С++ по наследствию, а в операторы Java и C#, только потому, что создатели Java ориентировались на аудиторию программистов на С++, а создатели C# на аудиторию Java и С++.
switch (e) {
case c:
…
default:
}
Где e – это выражение, приводимое к целому типу. Вычисляется значение e и если e = с, то делается оператор goto case c; если у нас не находится метки case c, то тогда делается goto default;. Если ничего не находится (в том числе и default’а), то это эквивалентно пустому оператору. Выбор сводится строго к операторам перехода. Формально и сase тоже сводится к операторам перехода, но там компилятор неявно вставляет goto end;, чтобы выйти на конец. В случае Си это не так. Следовательно, следующая конструкция допустима (и некоторые программисты её используют):
…
case 0:case 1:
S1;
case 2:
S2;
}
И, если e равно либо 0, либо 1 у нас последовательно выполняются S1и S2 и так далее. Писать каждый раз goto не очень хорошо, так как появляется большое количество меток нужно придумать (по одной на каждый switch), хотя создатели языка Си против меток и не возражали:
…
case 0:case 1:
S1;
goto end1;
case 2:
S2;
}
end1:
Специально был изобретён частный случай оператора перехода, а именно: оператор break; - выход из соответствующего переключателя. Семантика оператора break; позже была расширена на оператор цикла, для того, чтобы моделировать выход из цикла. И это вполне хорошая концепция с точки зрения структурного программирования, но вся проблема в том, что программисты иногда break; забывают ставить. Вообще говоря, вышеприведённая конструкция крайне редко полезна, и ей всегда можно придумать какой-то альтернативный вариант. Но программистов на Си и С++ так много, что Java был вынужден принять Сишную форму оператора switch, которая сводится исключительно к оператору goto (Даже в руководстве нет объяснений почему надо ставить break;, так как в Java слово из четырёх букв употреблять нельзя, и соответствующее слово даже специально зарезервировано, то есть нельзя объявить индификатор goto, а без этого неприличного слова полную семантику переключателя не объяснишь).
Примерно такая же ситуация стала и перед создателями языка C#, тем более, что отец языка C# одновременно и отец Турбо Паскаля, и в душе он смеялся над подобного рода конструкциями. Но тут нужна была переносимость некого стиля программирования, то есть если Сишный программист не видит в конце case break;, то у него возникает подсознательное ощущение, что его кидают. Поэтому создатели C#, оставив синтаксис очень похожим, ввели понятие «case-блока» - это последовательность операторов, которая начинается с последовательности меток, и он заканчивается либо меткой case (другой), либо меткой default, либо, соответственно, управляющей скобкой. И сказано, что коль скоро мы пишем любой case-блок, то он должен обязательно кончаться либо ключевым словом break;, либо goto case c;. С помощью этого можно было явно моделировать конструкции вроде, той, что была выше:
switch (e)
case 0:case 1:
S1;
goto case 2;
case 2:
S2;
…
Если мы забудем либо break, либо goto компилятор выдаёт сообщение об ошибке.
Других ветвлений в ЯП в общем-то нет, за исключением, опять же языков параллельного программирования, где есть так называемые параллельные ветвления, то есть многовариантный выбор, дело в том, что в случае последовательных ЯП здесь происходит последовательный опрос вариантов, и довольно часто некоторые компиляторы даже переключатель программируют как последовательный опрос вариантов, хотя, как ранее было сказано, здесь есть возможность вставлять оптимизацию. В Аде есть специальный оператор select, который с одной стороны можно рассматривать как многовариантный выбор, но нужно понять, что условия соответствующие как бы вычисляются параллельно, то есть по мере поступления. В данный момент мы не будем рассматривать параллельный стиль программирования.
2)Операторы цикла (наиболее используемые после операторов ветвления). В первом ЯП, как уже говорилось, было четыре оператора перехода и два оператора ветвления, которые сводились к операторам перехода. Там была всего одна форма цикла, причём достаточно уродская, которая в настоящее время из Фортрана исключена вообще. Сейчас, в современных ЯП, три вида ветвлений и четыре вида операторов цикла. Причём циклы как раз именно ветвятся, причём даже такой минимальный язык как Оберон, включает в себя весь полный набор операторов цикла. Первый классический вид цикла, который появился ещё в Паскале, и был унаследован из Алгола, хотя и сильно упрощён, это цикл «пока»: while B do S;, и цикл «до»: repeat S1;…SN until B. Аналогичного вида цикл есть и в Си, и всё различие в том, что в Паскале у нас условие выхода, а в Си, С++ и Jave это условие продолжения: do S while (B);. Но S- должен быть одним оператором, поэтому, программисты, как правило, сразу ставят составной оператор {S}.
Уже в языке Паскаль появился ещё один оператор, а именно оператор цикла со счётчиком, то есть та же самая конструкция, что с ветвлениями, не смотря на то, что дискретное ветвление- это частный случай многовариантного логического ветвления, тем не менее, во всех современных ЯП дискретное ветвление есть, просто потому, что оно очень часто встречается, а так же как возможность вставки для компилятора некоторой оптимизации. Так же и оператор цикла for: for i := e1 to e2 do S. В Модуле 2: for i := e1 to e2 step e3 do S. При этом во всех языках, основанных на Паскале, e1, e2 и e3 вычислялись сразу же, перед входом в цикл. То есть это цикл с фиксированным числом повторений. В первой версии языка Оберон подобного рода оператор был исключён, из-за его очевидной излишности (Вирт), так как тоже самое можно промоделировать с помощью цикла типа пока. В Оберон 2 его вернули, без объяснений. В языках основанных на Си семантика этого цикла различается достаточно сильно. В общем случае: for (e1;e2;e3) S;, где e3, e2 интерпретируются как логические выражения. Но отличия в том, что, во-первых, любое из этих выражений может отсутствовать, а, во-вторых, e1 вычисляется сразу, а e2 и e3 перевычисляются на каждом шагу. Поэтому в некоторых случаев реализация такого цикла for будет мене эффективна, чем соответствующая Паскалевская, Модуловская или Обероновская реализация. Хотя современные компиляторы могут распознать случаи, когда не надо перевычислять выражения на каждом шагу. В целом, семантика остаётся той же самой.
На прошлой лекции мы обсуждали, что иногда необходимо иметь возможность выхода из середины цикла, и, как следствие, в современных ЯП, появились либо специальные циклы, так называемые циклы с управлением пользователем, либо специальные операторы, а именно операторы выхода из цикла. Семантика оператора выхода из середины переключателя естественным образом распространилась на все остальные циклы во всех современных ЯП (Си, Модула 2, С++, Java и C#), то есть в любом цикле любого из этих языков можно выполнить оператор break;, который означает выход из тела цикла, так же добавили оператор continue;, который означает тоже самое, но мы идём заново на новую итерацию цикла, игнорируя, все операторы, которые стоят после continue;. В ряде алгоритмов не употребление break;, continue; или переходов существенно ломает структуру алгоритма. Отличие ЯП не в принятии или непринятии возможности выхода из произвольной точки тела цикла, а в том, какие синтаксические конструкции они для этого используют.
В языках, основанных на Си, используют комбинации операторов break; и continue; с любым оператором тела цикла. Но возникает проблема вложенных циклов:
loop
…
loop
…
endloop
endloop
Довольно часто возникает проблема, когда нам нужен выход из середины вложенного цикла, но при этом выход вообще. Выход из общего цикла (например, найти в матрице первую строку сверху, содержащую нулевой элемент). В языках, основанных на Си, появилось ещё такое расширение: после break; можно ставить ещё имя метки, причём это имя метки помечает либо оператор переключателя, либо оператор цикла. Этот break L; может появляться внутри оператора, который помечен этой меткой и он означает, естественно, выход из цикла, который помечен этой меткой. Метки используются лишь для ограниченных операторов перехода. Тоже самое распространяется и на оператор continue L;.
В языке Ада общая форма цикла:
loop
S1;…;SN
endloop;
То есть, внешне это выглядит как бесконечный цикл. Но всё время считалось, что бесконечный цикл- это ошибка. Это так только для языков, где нет параллельного программирования (когда мы программируем параллельно или квазипараллельно, то очень часто процедуры, которые работают по процессу, и имеют вид бесконечного цикла, они закончатся, когда их убьёт кто-то сверху), кроме этого, с помощью этой конструкции реализуется цикл с управлением пользователем, если добавить ещё одну конструкцию: exit [метка][when B];. Меткой помечают тот цикл, из которого нужно выходить: <<метка>>. А условие B, вообще говоря, излишне, так как exit when B; равносильно if B then exit; endif;. Тут опять же принцип языкового дизайна: «если какая-то конструкция иногда бывает полезна, то её нужно включить». На эту общую форму цикла в языке Ада ложатся все остальные циклы.
Цикл «до»:
while B do
loop
S1;…SN
endloop
Цикл «пока»:
…
while B
Цикл с фиксированным числом повторений:
for i in дискретный диапазон
loop
Если нам надо в обратном направлении, то мы соответственно применяем конструкцию … in reduce … .
В Модуле 2 мы либо программируем с помощью классических циклов («до», «пока» и со счётчиком), либо используем цикл LOOP, и внутри этого цикла допускается оператор EXIT:
LOOP
…
EXIT;
…
END
Ещё два замечания по поводу циклов. Первое – цикл со счётчиком. Язык С++ был расширен относительно Си, с точки зрения цикла со счётчиком, а именно таким образом, что в некоторых случаях внутри выражения e1 допускалось объявлять переменные. Например, цикл прохождения по массиву мог быть реализован таким образом:
for (int i = 1; i < N; i++)
A[i];
Что похоже на Паскалевский (Модула 2 или Оберон) цикл:
For i := 0 to N-1 do
A[i];
Но где локализована эта переменная i? Страуструп принял мнение, что даже если есть такое описание, то переменная i считается описанной во внешнем блоке, то есть к ней можно получить доступ после выхода из цикла. Это было одно из неудачных решений. Во всех последователях языка С++ областью видимости переменной является тело цикла. В Аде также, но тип переменной указывать не нужно, он выводится неявно из дискретного диапазона. Опять же вспомним, что если компилятор не может вывести тип, то мы всегда можем подсказать ему с помощью так называемого указания типа: T’e, это не приведение типа, а всего лишь подсказка компилятору, как трактовать это выражение. И последнее - конструкция foreach (для каждого).
В Перл или Visual Basic есть эта специальная конструкция, которая внешне напоминает конструкцию Ады:
for i L..R loop
То есть у нас вводится переменная, которая локализована и которая последовательно пробегает значения из дискретного диапазона. В Перл существует конструкция – «ассоциативный массив»:
@names = {“str1”,”str2”,”str3”};
Он хранит в себе значения строк и это структура прямого поиска (строки – ключи):
$names{“str2”};
foreach($names) {
println($names)
}
$names в foreach означает, что переменная names пробегает последовательно все значения. Подобного рода парадигма сводится к тому, что у нас есть коллекция, то есть структура данных, которая хранит в себе другие структуры данных. И довольно часто, независимо от устройства коллекции нам необходимо пробежать всю коллекцию от первого до последнего элемента (часто даже порядок не важен). При этом если программировать в обычном стиле, то вид соответствующего цикла очень сильно зависит от вида соответствующей коллекции. Коллекции – один из важнейших типов данных. В С++ все типы данных, которые нам могут понадобится, моделируем при помощи классов. Вот, например, библиотека стандартных шаблонов STL, выбирает, похожий на foreach подход к программированию коллекций, а именно там любой контейнерный класс должен содержать внутри себя некоторый класс, который называется iterator. По соглашению все контейнерные классы обладают классом iterator, а класс iterator должен содержать перекрытые операции: конструктор и инициализация, (итератор просто держит очередной элемент коллекции) перекрытую операцию ++ продвижение на следующий элемент в этой коллекции и -> оператор разыменования. Он ведёт себя как указатель в каком-то массиве. Похоже на стандартный подход, только обобщённый на произвольную структуру данных. Если у нас есть коллекция call c; мы объявляем итератор: call::iterator e. Инициализируем соответствующий итератор p и по соглашению у нас всегда есть функции begin(); - инициализация соответствующего итератора началом коллекции и end(); и, по STL’ному соглашению соответствующий цикл пробега по коллекции принимает вид:
for (p = c.begin(); p != c.end(); p++)
p->
В C# оператор foreach:
foreach(p in C)
Но доступ теперь не через указатель, а через «p.», которое ссылается на очередной элемент коллекции С. Этот оператор отражает концепцию современных ЯП, которая называется рефлексией. С её помощью мы управляем поведением компилятора и среды времени выполнения. Здесь рефлексия заключается в том, что эта операция перечисления in применима не к встроенным в язык типам данных, а именно к пользовательским классам, которые должны реализовывать так называемый «переходный интерфейс». Далее вернёмся к этому вопросу. С помощью рефлексии привязываем соответствующие объекты к операторам ЯП.
В Java это понятие работает на уровне стандартной библиотеки (а не встроено в язык). Есть некий стандартный интерфейс и если классы поддерживают его, то с ними будут работать все программы стандартной библиотеки, без её перекомпиляции. Этот подход ближе к STL. Но, если STL построена на понятие template (шаблон), то в Jave нет никакой статической параметризации нет и всё это построено на концепции динамического интерфейса. В C# пошли ещё дальше и встроили некие конструкции (foreach, …), которые позволяют некие языковые конструкции прямо связать с пользователем.
3)Переходы. Необходимость в операторе перехода постоянно падает. Общий вид оператора перехода, если он присутствует (из рассмотренных языков отсутствует в Модула 2, Оберон и Java) имеет вид goto метка;, причём на него накладывается куча ограничений. А именно все конструкции современных ЯП таковы, что для них существует только один вход, иначе говоря, мы никогда не сможем войти внутрь составного оператора, цикла или условного ветвления. Следовательно, переход может быть только наружу, далее этот переход, как правило, ограничен некой статической областью видимости, например, в языках, основанных на Си, и во многих других языках, переход ограничен только блоком тела процедуры (то есть goto – локальный переход). В Паскале, который поддерживает вложенные процедуры, переход допустим только в рамках одной процедуры. В некоторых ЯП (например, Си) есть так называемый нелокальный переход setjmp, но мы не будет рассматривать эту концепцию, как предельно устаревшую. Структурное программирование существенно сократило область использования оператора перехода (все эти формы оператора перехода не противоречат концепции один вход, один выход):
- выход из середины цикла (break;, exit)
- выход из функции (return [e];)
- обработка ошибочных, аварийных ситуаций (ошибки бывают в системе или во входных дынных, а мы хотим надёжную систему, которая адекватно реагирует на ошибку)
Во многих случаях в процедуре, где была обнаружена ошибка, исправить ошибку невозможно. Что делать: спросить программу, предупредить пользователя, то ли сделать что-то ещё, но сама процедура никакого решения не принимает. Поэтому она должна просигнализировать об ошибке. В старых ЯП (Си, Паскаль) единственная возможность сигнализации об ошибке – возврат из процедуры с какой-то сигнализацией об ошибке. Часто у процедуры возвращаемое значение типа int f(…), которое сигнализирует только об одном – нормально закончилась процедура или не нормально. Все системные вызовы библиотек языка Си (подавляющее большинство) описаны именно таким образом, так они всегда должны завершаться корректно. Значение >= 0 говорит о том, что всё нормально, а значение < 0 (обычно –1) говорит о том, что что-то не то. И надо возвращаться из процедуры. Но очень часто не хватает одного оператора return; так как необходимо обеспечить чистку ресурсов (закрыть файлы, …):
{…
goto end;
…
end: чистка ресурсов
}
В современных ЯП применяются специального вида конструкции, а именно исключительные ситуации и вместо перехода по метке происходит выброс (возбуждение) соответствующей исключительно ситуации: throw(исключительная ситуация). Потом обсудим. Наличие концепции исключений практически полностью ликвидирует необходимость использования операторов перехода. В С++:
{
C1 a; //объект класса С1
…
goto end;
C2 b;
end: …
}
Деструкторы классов занимаются чисткой ресурсов. В С++ деструкторы локальных объектов выполняются автоматически в конце каждого блока. И теперь мы точно не знаем деструкторы каких объектов запускать. Компилятор С++ выдаст паническое сообщение, что деструктор будет игнорироваться. Но программисты не любят, когда им что-то запрещают, поэтому C# на всякий случай поддерживает оператор перехода.
4)Составной оператор – это частный вид блока.
блок = {[объявления;]операторы}
begin … end
Если объявления отсутствуют, то такая конструкция и называется составным оператором. Но смешивать операторы и объявления не очень хорошо, поэтому, начиная с языка Паскаль, Вирт определяет под блоком несколько другую структуру:
блок = объявления и составной оператор.
Например, тело программы:
заголовок программы
 |
объявления
begin
end
И любая процедура состоит из заголовка, объявлений и составного оператора. Если у нас язык без терминаторов, то составной оператор просто необходим. Иначе необходимость в составном операторе просто исчезает. С этой точки зрения языки с терминаторами ортогональны (там, где может стоять один оператор, может стоять и группа операторов). В тоже время концепция блока остаётся во всех языках.
объявления
Бесплатная лекция: "Лекция 12" также доступна.
 |
begin
операторы
end
В таких языках как Модула 2 и Ада begin end в отдельную синтаксическую конструкцию не выделяется. В Аде ещё всегда перед началом блока (не того, который тело процедуры или функции, а вложенного блока) стоит слово declare.
Блоки отмечают объявления локальных переменных внутри кода, что, вообще говоря, не есть очень хорошо. Тут есть два стиля: стиль С++: «объявляй переменные там, где они тебе нужны», в результате операторы и объявления переменных смешиваются. И стиль языков Паскалевского типа, а именно то, что переменные нужно объявлять в начале какого-то блока и перемешивать объявления и операторы нельзя. Ада придерживается смешенного типа. Составной оператор теряет свою значимость.
