Лекция 2. Базовые конструкции структурного программирования
Структура программы
Программа на языке С++ состоит из функций, описаний и директив препроцессора. О директивах мы говорили выше. Функция - это законченный фрагмент кода, к которому можно обратиться по имени (вызвать функцию). Функция может получать аргументы и возвращать в вызывающий код вычисленное в ней значение. Например, вызов функции, вычисляющей синус угла, может выглядеть примерно так же, как в математике: y = sin(x);.
Одна (и только одна) функция программы должна иметь имя main. Выполнение программы начинается с первого оператора этой функции. Ее вызывает на выполнение исполняющая система.
Описания представляют собой определения и объявления элементов программы: переменных, функций, классов, типов и т. д. Любой элемент программы должен быть определен только один раз. Это правило в стандарте называется правилом одного определения ( one definition rule, или odr ) . Объявление может встречаться в программе столько раз, сколько необходимо.
Итак, программа, состоящая из одного модуля, имеет следующую структуру:
директивы препроцессора
описания
int main()
{
операторы главной функции
}
В общем случае программа состоит из нескольких модулей, каждый из которых может содержать все рассмотренные элементы.
Простейшие средства ввода/вывода
Любая программа каким-либо образом взаимодействует с внешним миром. В простейшем случае это работа с консолью: ввод с клавиатуры и вывод на экран. В языке С++ нет встроенных средств ввода/вывода - он осуществляется с помощью средств, содержащихся в стандартных библиотеках. Рассмотрим два примера.
// используются классы стандартной библиотеки
#include <iostream> // 1
using namespace std; // 2
int main() // 3
{ const double course = 35.8; // 4
double sum; // 5
cout << "Введите сумму в рублях:\n"; // 6
cin >> sum; // 7
double euro = sum / course; // 8
cout << "В рублях: " << sum
<< " В евро: " << euro
<< "\n"; // 9
return 0; // 10
}
Листинг 2.1. Программа перевода рублей в европейскую валюту (html, txt)
Это первый пример законченной программы, поэтому рассмотрим его подробно. В первой строке записана директива препроцессора. Директива вида
#include <имя_файла>
вставляет содержимое указанного файла (он называется заголовочным ) в ту точку исходного файла, где она расположена. В данном случае директива задает включение файла <iostream>, в котором содержатся описания используемых в программе элементов стандартной библиотеки ввода/вывода.
Строка 2 является описанием, по которому программе становятся доступными все имена, определенные в стандартном заголовочном файле <iostream>. Дело в том, что внутри этого файла все описания спрятаны в так называемую поименованную область (пространство имен) с именем std. Это касается всех стандартных заголовочных файлов и сделано для того, чтобы стандартные имена не конфликтовали с теми, которые ввел программист.
Конечно, открытие всех стандартных имен из заголовочного файла не может предотвратить подобный конфликт, но есть средства, позволяющие сделать доступными не все, а только нужные имена.
Формат основных функций ввода-вывода, унаследованных из С:
int scanf ( строка_формата, список адресов вводимых величин ) // ввод
int printf( строка_формата, список выводимых величин ) // вывод
Функции выполняют форматированный ввод и вывод произвольного количества величин в соответствии со строкой формата. Она содержит символы, которые копируются на экран при выводе или запрашиваются с клавиатуры при вводе, и спецификации преобразования, начинающиеся со знака %, которые при вводе и выводе заменяются конкретными величинами. Каждой величине должна соответствовать своя спецификация.
Спецификация %d означает целое десятичное число, %f используется для величин типа float, %lf - для величин типа double. Оператор в строке 9 выводит на экран указанную в нем строку, заменив спецификации преобразования %lf на значения переменных sum и euro.
Для каждой программы необходимо выбрать один из способов вывода (либо с помощью классов, либо с помощью функций), поскольку смешивать оба варианта не рекомендуется. Функции ввода/вывода в стиле С имеет смысл использовать в тех программах, где требуется тщательное форматирование результатов, а классы - в остальных случаях.
Выражения
В любой программе требуется производить вычисления. Для вычисления значений используются выражения, которые состоят из операндов, знаков операций и скобок. В приведенных выше примерах программ выражения использовались для вычисления суммы в рублях. Другие примеры выражений:
( a + 0.12 ) / 6
x && y || ! z
( t * sin( x ) - 1.05e4 ) / ( ( 2 * k + 2 ) * (2 * k + 3 ) )
a = b = c
b++
cout << a
i++, j++
Операнды задают данные для вычислений. Операции задают действия, которые необходимо выполнить. Каждый операнд является, в свою очередь, выражением или одним из его частных случаев, например, константой или переменной. Операции выполняются в соответствии с приоритетами. Для изменения порядка выполнения операций используются круглые скобки. Уровень их вложенности не ограничен.
Язык С++ предоставляет в наше распоряжение внушительный набор операций: арифметические, логические, поразрядные, операции отношения, выделения памяти, преобразования типа, выбора и т. д.
Уровней приоритетов в языке С++ огорчительно много, поэтому в случае сомнений надо не лениться обращаться к справочной информации. Основные правила, тем не менее, просты и соответствуют принятым в математике: например, вычитание имеет более низкий приоритет, чем умножение, поэтому для того, чтобы оно было выполнено раньше, соответствующая часть выражения заключается в скобки.
Если в одном выражении записано несколько операций одинакового приоритета, то унарные операции, условная операция и операции присваивания выполняются справа налево, остальные - слева направо. Например, a = b = c означает a = (b = c), а a + b + c означает ( a + b) + c.
Порядок вычисления операндов в выражении не определен: например, нельзя считать, что в выражении (sin(x + 2) + cos(y + 1)) обращение к синусу будет выполнено раньше, чем к косинусу. Только четыре операции гарантируют порядок вычислений слева направо: ,, ?:, && и ||.
Операции присваивания ( =, +=, -=, *= и т. д.). Формат операции простого присваивания ( = ):
операнд_1 = операнд_2
Левым операндом должно быть L -значение, а правым - любое выражение. Сначала вычисляется выражение, стоящее в правой части операции, а потом его результат записывается в область памяти, ссылка на которую стоит в левой части (мнемоническое правило: "присваивание - это передача данных "налево""). В простейшем и наиболее распространенном случае левый операнд представляет собой переменную, куда и записывается вычисленное значение. То, что ранее хранилось в этой переменной, естественно, теряется.
Если тип значения, полученного в результате вычисления, не совпадает с типом левого операнда, то выполняется преобразование типа по умолчанию (об этом - в конце этой лекции).
Выражение с операцией присваивания может участвовать в качестве операнда в других выражениях. Например, оно может быть аргументом операции сложения.
Результат выражения с присваиванием является L -значением, поэтому выражение с присваиванием может быть аргументом другой операции присваивания. Таким образом, допустимы многократные присваивания вида a = b = c: сначала вычисляется выражение b = c, а затем его результат становится правым операндом для операции присваивания переменной a.
Выражения с операциями присваивания могут использоваться и как самостоятельные операторы. Для этого нужно после выражения поставить точку с запятой. Пример операции присваивания:
#include <iostream>
using namespace std;
int main()
{ int a = 3, b = 5, с = 7; // инициализация
a = b; b = a; с = с + 1; // присваивание
cout << "a = " << a
<< "\t b = " << b
<< "\t c = " << c;
с = a + ( b = 5 );
cout << "\t c = " << c;
}
Результат работы программы:
a = 5 b = 5 c = 8 с = 10
В составных операциях присваивания ( +=, *=, /= и т. п.) при вычислении выражения, стоящего в правой части, используется и L -значение из левой части. Например, при сложении с присваиванием к значению левого операнда прибавляется значение правого, и результат записывается в левый операнд. Таким образом, выражение a += b является более компактной записью выражения a = a + b.
Операции увеличения и уменьшения на 1 ( ++ и -- ). Эти операции, называемые также инкрементом и декрементом, имеют две формы записи - префиксную, когда операция записывается перед операндом, и постфиксную. В префиксной форме сначала изменяется операнд, и новое значение является результатом операции. В постфиксной форме значением выражения является исходное значение операнда, после чего он изменяется:
#include <cstdio>
using namespace std;
int main()
{ int x = 3, y = 3;
printf( "Значение префиксного выражения: %d \n", ++x );
printf( "Значение постфиксного выражения: %d \n", y++ );
printf( "Значение х после приращения: %d \n", x );
printf( "Значение у после приращения: %d \n", у );
}
Результат работы программы:
Значение префиксного выражения: 4
Значение постфиксного выражения: 3
Значение х после приращения: 4
Значение у после приращения: 4
Как и выражения с присваиванием, выражения с инкрементом и декрементом можно сделать самостоятельным оператором, задав после выражения точку с запятой.
Операции отрицания ( -,!). Арифметическое отрицание (унарный минус -) изменяет знак операнда целого или вещественного типа на противоположный. Логическое отрицание ( !) дает в результате значение false, если операнд есть true, и значение true, если операнд равен false. Операнд может быть арифметического типа. В этом случае выполняется неявное преобразование в тип bool.
Деление ( / ) и остаток от деления ( % ). Операция деления применима к операндам арифметического типа. Если оба операнда целочисленные, результатом операции является целая часть частного (дробная часть отсекается). Например, результатом 5/2 будет 2. Если же хотя бы один операнд вещественный, то и результат будет вещественным числом. В этом случае тип результата определяется правилами преобразования типов, которые рассмотрены в следующем разделе. Операция остатка от деления применяется только к целочисленным операндам. Знак результата зависит от реализации.
#include <cstdio>
using namespace std;
int main()
{int x = 11, y = 4;
float z = 4;
printf( "Результаты деления: %d %f \n", x / y, x / z );
printf( "Остаток: %d \n", x % y );
}
Результат работы программы:
Результаты деления: 2 2.750000
Остаток: 3
Операции отношения (<, <=, >, >=, ==, !=) сравнивают первый операнд со вторым. Операнды могут быть арифметического типа или указателями. Результатом операции является значение true или false. Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции сравнения.
Логические операции (&& и ||). Операнды логических операций И (&&) и ИЛИ (||) должны иметь тип, допускающий преобразование к типу bool, при этом операнды в одной операции могут быть различных типов. Результатом операции является true или false. Результат операции логическое И имеет значение true только если оба операнда имеют значение true. Результат операции логическое ИЛИ имеет значение true, если хотя бы один из операндов имеет значение true. Логические операции выполняются слева направо. Если значения первого операнда достаточно, чтобы определить результат операции, второй операнд не вычисляется.
Условная операция ( ?:).Эта единственная в С++ тернарная операция (имеет три операнда), ее формат:
операнд_1 ? операнд_2 : операнд_3
Операнды вычисляются слева направо. Результат вычисления первого операнда должен быть типа, который можно преобразовать к типу bool. Если результат равен true, то результатом выполнения всей условной операции будет значение второго операнда, иначе - третьего операнда. Их типы могут быть различными.
Пример: пусть требуется, чтобы некоторая целая величина увеличивалась на 1, если ее значение не превышает n, а иначе принимала значение 1. Это можно записать с помощью одной строки кода:
i = ( i < n ) ? i + 1 : 1;
Операция последовательного вычисления "запятая" (,). Формат операции:
выражение_1, выражение_2
Операция выполняется слева направо: сначала вычисляется выражение слева от знака операции (его результат отбрасывается), а затем вычисляется выражение справа от знака и его результат принимается за результат операции. Вычисление левого выражения обязательно завершается до того, как начнется вычисление правого выражения. Это позволяет присваивать значения переменным в левом выражении, а затем использовать их в правом. Например, результатом операции j = 2, j = 1 будет 1, результатом операции j = 2, j++ будет 2, а результатом операции j = 2, ++j будет 3.
Стандарт разрешает любое выражение заменить последовательностью выражений, разделенных операцией "запятая". Результатом вычисления последовательности выражений будет значение самого правого выражения.
Базовые конструкции структурного программирования
В теории программирования доказано, что программу для решения задачи любой сложности можно составить только из трех структур, называемых следованием, ветвлением и циклом. Их называют базовыми конструкциями структурного программирования.
Следованием называется конструкция, представляющая собой последовательное выполнение двух или более операторов (простых или составных).
Ветвление задает выполнение либо одного, либо другого оператора в зависимости от выполнения какого-либо условия.
Цикл задает многократное выполнение оператора.
Особенностью базовых конструкций является то, что любая из них имеет только один вход и один выход (см. рис. 3.1), поэтому конструкции могут вкладываться друг в друга произвольным образом.
Рис. 3.1. Базовые конструкции структурного программирования
Целью использования базовых конструкций является получение программы простой структуры. Такую программу легко читать, отлаживать и при необходимости вносить в нее изменения.
Оператор "выражение"
Любое выражение, завершающееся точкой с запятой, рассматривается как оператор, выполнение которого заключается в вычислении выражения. Частным случаем выражения является пустой оператор ; (он используется, когда по синтаксису оператор требуется, а по смыслу - нет). Примеры:
i++; //выполняется операция инкремента
a* = b + c; //выполняется умножение с присваиванием
Операторы ветвления. Условный оператор if
Условный оператор if используется для разветвления процесса вычислений на два направления. Структурная схема оператора приведена на рис. 3.1. Формат оператора:
if ( выражение ) оператор_1; [else оператор_2;]
Сначала вычисляется выражение, которое может иметь арифметический тип или тип указателя. Если оно не равно нулю, выполняется первый оператор, иначе - второй. После этого управление передается на оператор, следующий за условным. Одна из ветвей может отсутствовать.
Если в какой-либо ветви требуется выполнить несколько операторов, их необходимо заключить в блок. Блок может содержать любые операторы, в том числе описания и другие условные операторы.
Примеры:
if (a<0) b = 1; // 1
if (a<b && (a>d || a==0)) b++;
else {b* = a; a = 0;} // 2
if (a<b) {if (a<c) m = a; else m = c;}
else {if (b<c) m = b; else m = c;} // 3
В примере 1 отсутствует ветвь else. Подобная конструкция называется "пропуск оператора", поскольку присваивание либо выполняется, либо пропускается в зависимости от выполнения условия.
Если требуется проверить несколько условий, их объединяют знаками логических операций. Например, выражение в примере 2 будет истинно в том случае, если выполнится одновременно условие a<b и одно из условий в скобках. Если опустить внутренние скобки, будет выполнено сначала логическое И, а потом - ИЛИ.
Оператор в примере 3 вычисляет наименьшее значение из трех переменных. Фигурные скобки в данном случае не обязательны.
Рис. 3.2. Мишень
Пример. Производится выстрел по мишени, изображенной на рис. 3.2. Определить количество очков.
#include <iostream>
using namespace std;
int main()
{float x, y; int kol;
cout << "Введите координаты выстрела\n";
cin >> x >> y;
if ( x*x + y*y < 1 ) kol = 2;
else if ( x*x + y*y < 4 ) kol = 1;
else kol = 0;
cout << "\n Очков: " << kol;
}
Оператор switch
Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений. Формат оператора:
switch ( выражение ){
case константное_выражение_1: операторы_1;
case константное_выражение_2: операторы 2;
...
case константное_выражение_n: операторы n;
[default: операторы ;]}
Выполнение оператора начинается с вычисления выражения (оно должно быть целочисленным), а затем управление передается операторам, помеченным константным выражением, значение которого совпало с вычисленным, после чего последовательно выполняются все остальные ветви, если выход из переключателя явно не указан.
Все константные выражения должны иметь разные значения, но быть одного и того же целочисленного типа. Несколько меток могут следовать подряд. Если совпадения не произошло, выполняются операторы, расположенные после слова default (а при его отсутствии управление передается следующему за switch оператору).
Пример (программа реализует простейший калькулятор на 4 действия):
#include <iostream>
using namespace std;
int main()
{
int a, b, res; char op;
cout << "\nВведите 1й операнд : ";
cin >> a;
cout << "\nВведите знак операции : ";
cin >> op;
cout << "\nВведите 2й операнд : ";
cin >> 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 : cout <<"\nНеизвестная операция";
f = false;
}
if (f) cout << "\nРезультат : " << res;}
Выход из переключателя обычно выполняется с помощью операторов break или return.
Операторы цикла
Операторы цикла используются для организации многократно повторяющихся вычислений.
Любой цикл состоит из тела цикла, то есть тех операторов, которые выполняются несколько раз, начальных установок, блока модификации параметра цикла и проверки условия выхода из цикла (рис. 3.3), которая может размещаться либо до тела цикла (тогда говорят о цикле с предусловием ), либо после тела цикла (цикл с постусловием ).
Один проход цикла называется итерацией. Переменные, принудительно изменяющиеся в цикле и использующиеся при проверке условия выхода из него, называются параметрами цикла. Целочисленные параметры цикла, изменяющиеся на целое число на каждой итерации, называются счетчиками цикла.
Нельзя передавать управление извне внутрь цикла. Выход из цикла возможен как при выполнении условия выхода, так и по операторам break, return или безусловного перехода.
Цикл с предусловием (while)
Цикл с предусловием реализует структурную схему, приведенную на рис. 3.3 (а), и имеет вид:
while ( выражение ) оператор;
Выражение определяет условие повторения тела цикла, представленного простым или составным оператором. Если выражение не равно 0 (истинно), выполняется оператор цикла, после чего опять вычисляется выражение. Если при первой проверке выражение равно 0, цикл не выполнится ни разу. Тип выражения должен быть арифметическим или приводимым к нему.
Рис. 3.3. Два вида циклов
Пример (программа печатает таблицу значений функции y=x2+1 во введенном диапазоне):
#include <cstdio>
using namespace std;
int main()
{
float Xn, Xk, Dx;
printf("Введите диапазон и шаг изменения аргумента: ");
scanf("%f%f%f", &Xn, &Xk, &Dx);
printf("| X | Y |\n"); //шапка таблицы
int X = Xn; //начальные установки цикла
while (X<=Xk)
{ //проверка условия выхода
printf("| %5.2f | %5.2f |\n", X, X*X + 1); //тело
X += Dx; //модификация
}
}
Цикл с постусловием (do while)
Цикл с постусловием реализует структурную схему, приведенную на рис. 3.3 (б), и имеет вид:
do оператор while выражение;
Сначала выполняется простой или составной оператор, составляющий тело цикла, а затем вычисляется выражение. Если оно не равно 0 (истинно), тело цикла выполняется еще раз, и так далее, пока выражение не станет равным нулю или в теле цикла не будет выполнен какой-либо оператор передачи управления. Тип выражения должен быть арифметическим или приводимым к нему.
Пример (программа осуществляет проверку ввода):
#include <iostream>
using namespace std;
int main(){
char answer;
do{
cout << "\nКупи слоника! ";
cin >> answer;
}while (answer != 'y');}
Цикл с параметром (for)
Цикл с параметром имеет следующий формат:
for ( инициализация; выражение; модификации) оператор;
Пример:
for ( int i = 1; i < 6; ++i )
printf( " %d ", i );
printf( "вышел зайчик погулять" );
Инициализация используется для объявления и присвоения начальных значений величинам, используемым в цикле. В этой части можно записать несколько операторов, разделенных запятой.
Выражение определяет условие выполнения цикла: если оно не равно 0 (истинно), цикл выполняется.
Модификации выполняются после каждой итерации цикла и служат обычно для изменения параметров цикла. В части модификаций можно записать несколько операторов через запятую.
Простой или составной оператор представляет собой тело цикла. Любая из частей оператора for может быть опущена (но точки с запятой надо оставить на своих местах!). В любой части можно использовать операцию "запятая" (последовательное вычисление), например:
for (int i = 1, s = 0; i<=100; i++)
s += i; // сумма чисел от 1 до 100
Пример (программа печатает таблицу значений функции y=x2+1 во введенном диапазоне):
#include <cstdio>
using namespace std;
int main()
{
float Xn, Xk, Dx;
printf("Введите диапазон и шаг изменения аргумента: ");
scanf("%f%f%f", &Xn, &Xk, &Dx);
printf("| X | Y |\n");
for (int X = Xn; X<=Xk; X += Dx)
printf("| %5.2f | %5.2f |\n", X, X*X + 1);
}
Операторы передачи управления
В С++ есть пять операторов, изменяющих естественный порядок выполнения вычислений:
оператор выхода из цикла и переключателя break ;
оператор перехода к следующей итерации цикла continue ;
оператор возврата из функции return ;
оператор безусловного перехода goto ;
оператор генерации исключения throw.
Оператор выхода break используется для немедленного завершения оператора цикла или switch. Выполнение передается следующему после завершенного оператору.
Оператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на модификацию параметров цикла (в случае цикла for ) и начало следующей итерации.
Оператор возврата из функции return завершает выполнение функции и передает управление в точку ее вызова. Мы рассмотрим его вместе с функциями на следующей лекции.
Оператор безусловного перехода goto имеет формат:
goto метка;
В теле той же функции должна присутствовать ровно одна конструкция вида:
метка: оператор;
Оператор goto передает управление на помеченный оператор. Метка - это обычный идентификатор, областью видимости которого является функция, в теле которой он встречается.
Использование оператора безусловного перехода оправдано в двух случаях:
принудительный выход вниз по тексту программы из нескольких вложенных циклов или переключателей;
переход из нескольких мест функции в одно (например, если перед выходом из функции необходимо всегда выполнять какие-либо действия).
В остальных случаях для записи любого алгоритма существуют более подходящие средства.
Исключительную ситуацию (или просто исключение) генерирует либо программист с помощью оператора throw, либо сама среда выполнения. Это происходит, когда во время выполнения программы возникают какие-либо ошибки, например, деление на ноль или переполнение. Механизм обработки исключений, реализованный в С++, позволяет реагировать на подобные ошибки и таким образом избегать аварийного завершения программы.