Идея структурного программирования
Как отмечалось, любую программу можно составить только из структур трех типов: следования, ветвления и цикла (это базовые конструкции).
- Следованием называется конструкция, представляющая собой последовательное выполнение двух или более операторов (простых или составных).
- Ветвление задает выполнение либо одного, либо другого оператора в зависимости от выполнения какого-либо условия.
- Цикл задает многократное выполнение оператора.
Особенностью базовых конструкций является то, что любая из них имеет только один вход и один выход, поэтому конструкции могут вкладываться друг в друга произвольным образом, например, цикл может содержать следование из двух ветвлений, каждое из которых включает вложенные циклы.
Вложение базовых конструкций
Идеей использования базовых конструкций является получение программы простой структуры. Такую программу легко читать (а программы чаще приходится читать, чем писать), отлаживать и при необходимости вносить в нее изменения. Структурное программирование часто называли «программированием без goto», и в этом есть большая доля правды: частое использование операторов передачи управления в произвольные точки программы затрудняет прослеживание логики ее работы. С другой стороны, никакие принципы нельзя возводить в абсолют, и есть ситуации, в которых использование goto оправдано и приводит, напротив, к упрощению структуры программы.
В большинстве языков высокого уровня существует несколько реализаций базовых конструкций; в C++ есть три вида циклов и два вида ветвлений (на два и на произвольное количество направлений). Они введены для удобства программирования, и в каждом случае надо выбирать наиболее подходящие средства. Главное, о чем нужно помнить даже при написании самых простых программ, — что они должны состоять из четкой последовательности блоков строго определенной конфигурации. «Кто ясно мыслит, тот ясно излагает» — практика давно показала, что программы в стиле «поток сознания» нежизнеспособны, не говоря о том, что они просто некрасивы.
Рассмотрим операторы языка, реализующие базовые конструкции структурного программирования в C++.
Оператор «выражение»
Любое выражение, завершающееся точкой с запятой, рассматривается как оператор, выполнение которого заключается в вычислении выражения. Частным случаем выражения является пустой оператор (он используется, когда по синтаксису оператор требуется, а по смыслу — нет).
Примеры:
i++; // выполняется операция инкремента
а* = b + с; // выполняется умножение с присваиванием
fun(i, к); // выполняется вызов функции
Операторы ветвления
Условный оператор if
Условный оператор if используется для разветвления процесса вычислений на два направления. Формат оператора:
if ( выражение ) оператор_1; [else оператор_2;]
Сначала вычисляется выражение, которое может иметь арифметический тип или тип указателя. Если оно не равно нулю (имеет значение true), выполняется первый оператор, иначе — второй. После этого управление передается на оператор, следующий за условным.
Одна из ветвей может отсутствовать, логичнее опускать вторую ветвь вместе с ключевым словом else. Если в какой-либо ветви требуется выполнить несколько операторов, их необходимо заключить в блок, иначе компилятор не сможет понять, где заканчивается ветвление. Блок может содержать любые операторы, в том числе описания и другие условные операторы (но не может состоять из одних описаний). Необходимо учитывать, что переменная, описанная в блоке, вне блока не существует.
Структурная схема условного оператора
Примеры:
if (а if (ad || a==0)) b++; else {b *= a; a = 0;} //2
if (a if (a++) b++; //4
if (ba) max = b; else max = a; //5
В примере 1 отсутствует ветвь else. Подобная конструкция называется «пропуск оператора», поскольку присваивание либо выполняется, либо пропускается в зависимости от выполнения условия.
Если требуется проверить несколько условий, их объединяют знаками логических операций. Например, выражение в примере 2 будет истинно в том случае, если выполнится одновременно условие а
Оператор в примере 3 вычисляет наименьшее значение из трех переменных. Фигурные скобки в данном случае не обязательны, так как компилятор относит часть else к ближайшему if.
Пример 4 напоминает о том, что хотя в качестве выражений в операторе if чаще всего используются операции отношения, это не обязательно.
Конструкции, подобные оператору в примере 5, проще и нагляднее записывать в виде условной операции (в данном случае: max = (b а) ? b : а;).
Пример. Производится выстрел по мишени, изображенной на рисунке. Определить количество очков.
#include
int main(){
float x, у; int kol;
cout x у;
if ( x*x + y*y 1 ) kol = 2;
else if( x*x + y*y 4 ) kol = 1:
else коl = 0;
cout return 0;
}
Тип переменных выбирается исходя из их назначения. Координаты выстрела нельзя представить целыми величинами, так как это приведет к потере точности результата, а счетчик очков не имеет смысла описывать как вещественный. Даже такую простую программу можно еще упростить с помощью промежуточной переменной и записи условия в виде двух последовательных, а не вложенных, операторов if (обратите внимание, что в первом варианте значение переменной коl присваивается ровно один раз, а во втором — от одного до трех раз в зависимости от выполнения условий):
#1nc!ucle
int main(){
float x, у, temp; int коl;
cout X у;
temp = x * x + y * y;
коl = 0;
if (temp 4 ) коl = 1;
if (temp 1 ) kol = 2:
cout return 0;
}
Если какая-либо переменная используется только внутри условного оператора, рекомендуется объявить ее внутри скобок, например:
if (int i = fun(t)) a -= 1; else a += 1;
Объявление переменной в тот момент, когда она требуется, то есть когда ей необходимо присвоить значение, является признаком хорошего стиля и позволяет избежать случайного использования переменной до ее инициализации. Объявлять внутри оператора if можно только одну переменную. Область ее видимости начинается в точке объявления и включает обе ветви оператора.
Оператор switch
Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений. Структурная схема оператора приведена на рис. ниже. Формат оператора:
switch ( выражение ) {
case константное_выражение_1: [список_операторов_1]
case константное_выражение_2: [список_операторов_2]
…
case константное_выражение_n: [список_операторов_n]
[default: операторы ]
}
Выполнение оператора начинается с вычисления выражения (оно должно быть целочисленным), а затем управление передается первому оператору из списка, помеченного константным выражением, значение которого совпало с вычисленным.После этого, если выход из переключателя явно не указан, последовательно выполняются все остальные ветви.
Выход из переключателя обычно выполняется с помощью операторов break или return. Оператор break выполняет выход из самого внутреннего из объемлющих его операторов switch, for, while и do. Оператор return выполняет выход из функции, в теле которой он записан.
Все константные выражения должны иметь разные значения, но быть одного и того же целочисленного типа. Несколько меток могут следовать подряд. Если совпадения не произошло, выполняются операторы, расположенные после слова default (а при его отсутствии управление передается следующему за switch оператору).
Пример (программа реализует простейший калькулятор на 4 действия):
#include
int main() {
int a, b, res;
char op;
cout a;
cout op;
cout b;
bool f = true;
switch (op){
case ‘+’: res = a + b; break;
case ‘-‘: res = a — b; break;
case ‘*’: res = a * b; break;
case ‘/’: res = a / b; break;
default : \nНеизвестная операция; f = false;
}
if (f) cout return 0;
}
Операторы передачи управления
В C++ есть четыре оператора, изменяющих естественный порядок выполнения вычислений:
- оператор безусловного перехода goto;
- оператор выхода из цикла break;
- оператор перехода к следующей итерации цикла continue;
- оператор возврата из функции return.
Оператор goto
Оператор безусловного перехода goto имеет формат:
goto метка;
В теле той же функции должна присутствовать ровно одна конструкция вида:
метка: оператор;
Оператор goto передает управление на помеченный оператор. Метка — это обычный идентификатор, областью видимости которого является функция, в теле которой он задан.
Использование оператора безусловного перехода оправдано в двух случаях:
- принудительный выход вниз по тексту программы из нескольких вложенных циклов или переключателей;
- переход из нескольких мест функции в одно (например, если перед выходом из функции всегда необходимо выполнять какие-либо действия).
В остальных случаях для записи любого алгоритма существуют более подходящие средства, а использование goto приводит только к усложнению структуры программы и затруднению отладки (Даже в приведенных случаях допустимо применять goto только в случае, если в этих фрагментах кода не создаются локальные объекты. В противном случае возможно применение деструктора при пропущенгюм конструкторе, что приводит к серьезным ошибкам в программе). Применение goto нарушает принципы структурного и модульного программирования, по которым все блоки, из которых состоит программа, должны иметь только один вход и один выход.
В любом случае не следует передавать управление внутрь операторов if, switch и циклов. Нельзя переходить внутрь блоков, содержащих инициализацию переменных, на операторы, расположенные после нее, поскольку в этом случае инициализация не будет выполнена:
int к; …
goto metka; …
{int а = 3, b = 4;
к = а + b;
metka: int m = к + 1; …
}
После выполнения этого фрагмента программы значение переменной m не определено.
Оператор break
Оператор break используется внутри операторов цикла или switch для обеспечения перехода в точку программы, находящуюся непосредственно за оператором, внутри которого находится break.
Оператор continue
Оператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на начало следующей итерации.
Оператор return
Оператор возврата из функции return завершает выполнение функции и передает управление в точку ее вызова. Вид оператора:
return [ выражение ];
Выражение должно иметь скалярный тип. Если тип возвращаемого функцией значения описан как void, выражение должно отсутствовать.
Операторы цикла
Операторы цикла используются для организации многократно повторяющихся вычислений. Любой цикл состоит из тела цикла, то есть тех операторов, которые выполняются несколько раз, начальных установок, модификации параметра цикла и проверки условия продолжения выполнения цикла.
Один проход цикла называется итерацией. Проверка условия выполняется на каждой итерации либо до тела цикла (тогда говорят о цикле с предусловием), либо после тела цикла (цикл с постусловием). Разница между ними состоит в том, что тело цикла с постусловием всегда выполняется хотя бы один раз, после чего проверяется, надо ли его выполнять еще раз. Проверка необходимости выполнения цикла с предусловием делается до тела цикла, поэтому возможно, что он не выполнится ни разу.
Переменные, изменяющиеся в теле цикла и используемые при проверке условия продолжения, называются параметрами цикла. Целочисленные параметры цикла, изменяющиеся с постоянным шагом на каждой итерации, называются счетчиками цикла.
Начальные установки могут явно не присутствовать в программе, их смысл состоит в том, чтобы до входа в цикл задать значения переменным, которые в нем используются.
Цикл завершается, если условие его продолжения не выполняется. Возможно принудительное завершение как текущей итерации, так и цикла в целом. Для этого служат операторы break, continue, return и goto. Передавать управление извне внутрь цикла не рекомендуется.
Для удобства, а не по необходимости, в C++ есть три разных оператора цикла — while, do while и for.
