 |
Операторы организации циклов
|
|
|
|
Оператор объявления
Оператор присваивания
Составной оператор
Пустой оператор
Условные операторы
· Условный оператор if
· Оператор выбора switch
Операторы организации циклов
· Оператор цикла while
· Оператор цикла do – while
· Оператор цикла for
· Способы организации бесконечных циклов
Оператор break
Оператор continue
Общая структура программы на С++
Структура простой C++- программы, которая содержит ввод или вывод информации, имеет следующий вид:
#include <iostream>
using namespace std;
int main (){
оператор_1;
…
оператор_N
system("pause"); // для задержки экрана
return 0;
}
Переводом программы с языка программирования на машинный язык и анализом её синтаксиса занимается программа- компилятор. Иногда компилятор называют более общим термином – транслятор.
Директива препроцессора – это инструкция, записанная в исходном тексте С++ -программы и выполняемая препроцессором. Строка, содержащая директиву препроцессора, начинается с символа '#' и не имеет точки с запятой в конце. Директива include <iostream> подключает заголовочный файл iostream, который необходим для поддержки С++- системы ввода-вывода (т.е. обеспечивает ввод-вывод информации).
Препроцессор – это программа, которая обрабатывает исходный файл перед компиляцией, находит директивы и выполняет соответствующие действия (подключает необходимые файлы, заменяет символические аббревиатуры в программе и т. д.). Программа запускается автоматически при вызове компилятора.
using namespace std; обозначает, что используется пространство имён с именем std. Пространство имён – это некоторая объявляемая область видимости имён. Она необходима, чтобы избежать конфликтов идентификаторов. В пространстве имён std объявлена вся библиотека стандарта языка С++.
|
|
|
В программах на С++ предусмотрено использование комментариев – пояснительного текста, который не компилируется и, следовательно, не влияет на ход выполнения программы:
// Однострочный комментарий в С++
/* Многострочный комментарий в С++ */
Все С++- программы состоят из одной или нескольких функций. Функция – это логически завершённый фрагмент программы, который может быть вызван из других частей программы. Каждая функция имеет имя, и только одна из них называется main(). С функции main() начинается выполнение любой С++- программы, она всегда должна присутствовать в программе, и имя её менять нельзя. Если в программе только одна функция, то это функция main().
Вфигурныхскобках, ограничивающих функцию main(),записывается телофункции. Тело функции представляет собой последовательность операторов, задающих действия для выполнения функцией, и оно заключается в фигурные скобки, т.е. является блоком.
Оператор представляет собой законченную конструкцию языка для описания некоторого конкретного действия и завершается точкой с запятой, что указывает на конец оператора.
Для большинства ОС нулевое значение, возвращаемое функцией main(), свидетельствует о нормальном завершении программы. Оператор return используется для возврата значения из функции main() и при нормальном завершении функции должен возвращать значение 0.
// Пример 4.1. Первая С++ -программа. Вычисление площади
// треугольника с длинами сторон a, b, c по формуле Герона.
#include <iostream> // для ввода-вывода
#include <math.h> // для функции sqrt()
using namespace std;
int main() {
float a, b, c; // объявление переменных a, b, c
float p, s; // объявление переменных p, s
cout<<"Vvedi a, b, c: ";
cin>>a>>b>>c; // ввод c клавиатуры
p = (a + b + c) / 2; // вычисление полупериметра
s = sqrt(p * (p - a) * (p - b) * (p - c)); // вычисление площади
cout<<"s = "<<s<<endl; // вывод на экран результата
|
|
|
system("pause"); // задержка экрана
return 0; // выход из main(), можно опустить
}
В теле функции main() приведённой программы объявлены переменные a, b, c, p, s, в результате чего под переменные будет выделена оперативная память в соответствии с их типом (по 4 байта).
Подключение заголовочного файла iostream обеспечивает ввод-вывод информации путём предоставления доступа к потокам ввода - вывода. Операция >> (извлечения из потока) обеспечивает считывание данных с клавиатуры через стандартный поток ввода cin (левый операнд операции), их преобразование в соответствии с типом правого операнда и присвоение полученных значений правому операнду (переменным a, b, c). Операция << (вставки в поток) обеспечивает вывод на экран через стандартный поток вывода cout значение правого операнда (строки " s= "и значения переменной s).
Подключение заголовочного файла < math.h> обеспечивает возможность использования в программе библиотечных математических функций и констант (в программе используется функция извлечения квадратного корня – sqrt()).
Оператор объявления
Все имена (идентификаторы) перед их использованием в программе на языке C++ должны быть объявлены (за исключением имени функции main()) с помощью оператора объявления. Оператор объявления состоит из названия типа и объявляемого имени (см. раздел объявление переменных). Оператор можно использовать для объявления переменных, именованных констант, функций и других данных:
int x; // объявление целой переменной x
double f, sum; // объявление f, sum типа double
Оператор присваивания
Только в том случае, когда в конце выражения с операцией (=) ставится точка с запятой, выражение становится оператором присваивания, например
x = y + z;
Оператор присваивания в С++ отличается от аналогичных операторов в других языках программирования тем, что может входить в более крупные выражения. В качестве результата оператор возвращает значение, присвоенное левому операнду. Например, следующее выражение вполне корректно:
value1 = 5 * (value2 = 8);
В данном случае сначала переменной value2 будет присвоено значение 5, после чего это значение будет умножено на 8 и результат 40 будет записан в переменную value1.
Оператор присваивания также часто применяется для присваивания нескольким переменным одинакового значения, например:
|
|
|
x = y = z = 0;
Составной оператор
Составной оператор (блок) представляет собой последовательность операторов, заключенных в фигурные скобки { }, например:
{
f = a + b; c = f * a; m = f * c;
}
Операторы, входящие в составной оператор, разделяются точкой с запятой.
Составной оператор может включать в себя любые операторы, в том числе и другие составные операторы:
{
f = a + b;
{ x = f * a; m = f * c; } c = f * x * m;
}
Пустой оператор
Пустой оператор в программе представляется отдельной точкой с запятой, которая в данном случае завершает пустое действие.
Условные операторы
В программировании очень редко встречаются задачи, которые можно решить, выполняя строго заданную линейную последовательность действий. Значительно чаще приходится выполнять те или иные действия, в зависимости от каких-либо условий. Для описания подобных случаев используются условные операторы, которые позволяют проверять условие и, в зависимости от его значения, выполнять различные части программы.
Условный оператор if
В С++ оператором проверки условия является оператор if который, позволяет выбрать один из двух возможных вариантов выполнения действий в зависимости от выполнения определенного условия. Общая форма записи оператора if имеет вид:
if (условие) оператор_1; [else оператор_2 ;]
Здесь в качестве условия понимается любое выражение, результат вычисления которого приводимо к целочисленному значению.
При выполнении оператора if сначала вычисляется условие. Если результат – истина (любое отличное от нуля значение), то выполняется оператор _1. Если результат анализа условия – ложь (значение равно 0), то выполняется оператор_ 2. В случае отсутствия конструкции else, оператор_ 1 пропускается, и управление передаётся на оператор, следующий после if. Операторы, стояшие после if и else могут быть составными. Рассмотрим примеры оператора if:
· if (x < y) min = x; // нахождение минимума
else min = y; // из двух чисел x и y
· cin>>val; // проверка правильности ввода
|
|
|
if (val < 1 || val > 10) // переменной val, которая может
cout<<"Error vvoda"; // содержать числа от 1 до 10
· if (x) y = 1 / x; // вычисление y по формуле y = 1 / x,
else сout<<"Error: x = 0 \n"; // если значение x не равно 0
· if(val < 0) val = -val; // абсолютная величина числа
В языке С++ имеется короткий способ записи оператора if…else с помощью условной операции (?), например:
min = (x < y)? x: y; // нахождение min (x, y)
// Пример4.2. Ввестис клавиатуры два целых числа a и b.
// Если значения a и b положительны, найти их произведение,
// в остальных случаях вычислить их сумму.
#include <iostream>
using namespace std;
int main() {
int a, b, rez;
cout << "Enter the number a, b: "; cin>>a>>b;
cout<<" a = "<<a<<" b = "<<b<<endl;
if(a > 0 && b > 0){rez = a * b; cout<<a<<" * "<<b <<" = ";}
else{rez = a + b; cout<<a<<" + "<<b<<" = ";}
cout<<rez<<endl;
}
Вложенные операторы if
В качестве внутренних операторов условного оператора if могут использоваться любые операторы, в том числе и условные. В таком случае говорят о вложенных условных операторах. Например:
if (условие 1)
if (условие 2) оператор_1;
else оператор_2;
else оператор_3;
При анализе подобных конструкций избежать возможных затруднений позволяет простое правило – else относится к ближайшему свободному if.
Рекомендуется вложенный оператор if брать в фигурные скобки, так как это значительно облегчает чтение программы и уменьшает вероятность путаницы с определением соответствующих else. В этом случае запись вложенного if принимает вид:
if (условие){
if (условие) оператор_1;
else оператор_2;
}
else оператор_3;
Конструкция if…else…if
Встречаются задачи, в которых выбор следует сделать между более чем двумя возможными вариантами, каждому из которых соответствует свое условие. Тогда применяется конструкция if…else…if (так называемая конструкция- лестница). Её можно представить в виде:
if (условие 1) оператор_1;
else if (условие 2) оператор_2;
else if (условие 3) оператор_3; …
else if (условие N)оператор_N;
else // необязательная часть
оператор _ по_умолчанию;
Здесь под элементами условие 1… условие N понимаются условные выражения, которые вычисляются сверху вниз. Как только в какой-нибудь ветви при вычислении условного выражения обнаружится истинный результат, будут выполнены операторы, связанные с этой ветвью, а вся остальная часть конструкции опустится. Если окажется, что ни одно из условий не является истинным, будет выполнен последний элемент else (выполняет роль условия, которое действует по умолчанию).
Последний элемент, за которым следует оператор _ по_умолчанию ( не является обязательным). В подобных конструкциях элемент else связывается с ближайшим предыдущим if в том же блоке, не имеющим элемента else.
|
|
|
Формально уровней вложенности операторов if может быть много, но реально при количестве таких вложенных конструкций, больше чем 4-5, программа становится трудночитаемой и её трудно отлаживать.
// Пример4.3. Ввести целое число x. Проверить, попадает ли введённое
// значение в заданный диапазон от 1 до 4. Вывести значение x на экран.
// Использовать конструкцию if…else…if.
#include <iostream>
using namespace std;
int main() {
int x;
cout << "Vvedi chislo x = "; cin >> x;
if (x == 1) cout<<"x = 1 \n";
else if (x == 2) cout<<"x = 2 \n";
else if (x == 3) cout<<"x = 3 \n";
else if (x == 4) cout<<"x = 4 \n";
else cout<<"x vne diapazona. \n";
cout<<endl;
}
// Пример4.4. Найти максимальное значение из введённых чисел x, y, z.
#include <iostream>
using namespace std;
int main() {
int x, y, z, max;
cout<<"Enter the number x, y, z: = "; cin>>x>>y>>z;
cout<< "Variant 1" <<endl;
if(x > y) max = x; // полная форма оператора if
else max = y;
if(z > max) max = z; // краткая форма оператора if
cout<<"max = "<<max<<endl;
cout<< "Variant 2" <<endl;
max = x;
if(y > max) max = y;
if(z > max) max = z;
cout<<"max = "<<max<<endl;
cout<<" Variant 3 " <<endl;
max = x > y? x: y; // условная операция
max = z > max? z: max;
cout<<"max = "<<max<<endl;
cout<< "Variant 4" <<endl;
if(x > y && x > z) max = x;
else if(y > z) max = y;
else max = z;
cout<<"max = "<<max<<endl;
}
// Пример4.5. Расположить значения четырех переменных a, b, c, d
// в порядке возрастания их величин.
#include<iostream>
using namespace std;
int main() {
int a, b, c, d, r;
cout<<"Enter a, b, c, d "; cin>>a>>b>>c>>d;
cout<<" a = "<<a<< "b = "<<b<<" c = "<<c<<" d = "<<d<<endl;
if(a>b) { r = a; a = b; b = r;}
if(a>c) { r = a; a = c; c = r;}
if(a>d) { r = a; a = d; d = r;}
if(b>c) { r = b; b = c; c = r;}
if(b>d) { r = b; b = d; d = r;}
if(c>d) { r = c; c = d; d = r;}
cout<<" a = "<<a<<" b = "<<b<<" c = "<<c<<" d = "<<d<<endl;
system("pause");
}
// Пример 4.6. Написать программу-калькулятор, которая может
// выполнять только четыре действия: +, -, *, /.
#include<iostream>
using namespace std;
int main() {
double a, b, rez;
cout<<"Enter a and b: ";
cin>>a>>b;
char oper;
cout<<"Input the operation: ";
cin>>oper;
if(oper == '+'){rez = a + b;
cout<<'\n'<<a<<" + "<<b<<" = "<<rez<<endl;
}
if(oper == '-'){ rez = a - b;
cout<<'\n' <<a << " - " <<b<<" = "<<rez<<endl;
}
if(oper == '*'){rez = a * b;
cout<<'\n'<<a<<" * "<<b<<" = "<<rez<<endl;
}
if(oper == '/')
if(b!= 0){rez = a / b;
cout<<"\n\t"<<a<<" / "<<b<<" = "<<rez<<endl;
}
else cout<<"Division by zero!\n";
if(oper!= '+' && oper!= '-' && oper!= '*' && oper!= '/')
cout<<"Incorrect operation!\n";
system("pause");
}
Оператор выбора switch
Условный оператор if…else позволяют легко осуществить выбор между двумя вариантами. В программировании же часто встречается задача выбора одного решения задачи из многих возможных. Это можно сделать с помощью вложенных конструкций if...else…if. Однако более удобный способ – использование оператора switch, формат записи которого имеет следующую форму:
switch (выражение){
case константа1: оператор_1; break;
case константа2: оператор_2; break;
…
case константаN: оператор_N; break;
[default: операторы; break;]
}
Оператор switch работает следующим образом. Вычисляется выражение, тип которого должен быть целочисленным. Затем значения констант, указанных в метках case, сравниваются со значением вычисленного выражения. Если совпадение обнаружено, выполняются операторы, следующие за соответствующей меткой case. Если в списке констант не будет константы равной значению выражения, выполняются операторы, записанные после метки default.
Обычно действие каждой ветви заканчивается оператором break. Выполнение этого оператора приводит к выходу из оператора switch. Если break отсутствует, то управление передаётся следующему оператору, помеченному case или default. Подобным образом выполняются все последующие операторы внутри switch, пока не встретится оператор break.
В качестве значений в метках case могут использоваться только целые числовые константы, а также константные (не содержащие переменных) выражения, причем значения, используемые в метках case в пределах одного оператора switch, не должны повторяться. Например:
switch (m){
case 1: x = a + b; break;
case 2: x = a - b; break;
case 3: x = a * b; break;
default: cout<<"Incorrect operation!\n";
}
В качестве значений в метках case также могут использоваться символьные константы, которые в С++ являются целочисленными:
char сh; cin>>сh;
switch(сh){
case '+': x = a + b; break;
case '-': x = a - b; break;
default: cout<<"Incorrect operation!\n";
}
В одной метке case нельзя указать диапазон значений. Это означает, что если, например, для трёх последовательных целых числовых значений необходимо выполнить одни и те же действия, в операторе switch придется записать три отдельные метки case, две из которых будут “пустыми”:
switch (m){
case 1:
case 3:
case 5:
cout<<"!!!";…
}
В отличие от оператора if оператор switch может выполнять операции проверки только строгого равенства, в то время как оператор if в условиях может использовать логические операции и операции сравнения. Например, с помощью switch не удастся проверить, принадлежит ли значение определенному интервалу.
// Пример4.7. Проанализировать значение переменной mark, которая
// является значением выставленной оценки, используя оператор switch.
#include <iostream>
using namespace std;
int main() {
int mark;
cout<<"Enter the mark = "; cin>> mark;
switch (mark){
case 5: cout<<"оcenka 5\n"; break;
case 4: cout<<"оcenka 4\n"; break;
case 3: cout<<"оcenka 3\n"; break;
case 2: cout<<"оcenka 2\n"; break;
default: cout<<"Error mark\n";
}
system("pause");
}
// Пример 4.8. Составить программу-калькулятор, которая может
// выполнять только четыре действия: +, -, *, /.
// Использовать оператор swith.
#include <iostream>
using namespace std;
int main() {
double a, b, rez;
char oper;
cout<<"Enter a and b:";
cin>>a>>b;
bool flag = true;
cout<<"Enter operation: ";
cin>>oper;
switch (oper){
case '+': rez = a + b; break;
case '-': rez = a - b; break;
case '*': rez = a * b; break;
case '/': if(b == 0) flag = false; // или if (!b) flag = false;
else rez = a / b; break;
default: flag = false;
}
if (flag == true)cout<<'\n'<<a<<' '<<oper<<' '<<b<<'='<<rez<<endl;
else cout<<"Division by zero or incorrect operation.\n";
system("pause");
}
Операторы организации циклов
При выполнении программы нередко возникает необходимость неоднократного повторения однотипных вычислений над различными данными (например, программа расчёта заработной платы для сотрудников). Для этих целей используются так называемые циклы.
Фрагмент программы, который многократно повторяет выполнение одного или нескольких операторов, называется циклом, а последовательность операторов, входящая в данный фрагмент – телом цикла.
Повтор цикла (или итерация) – один из важнейших приёмов вычислений в программировании, состоящий в том, что определенная последовательность операторов (тело цикла) повторяется до достижения некоторого условия или заданное число раз.
Язык С++ имеет три оператора для организации цикла – while, do … while и for.
Оператор цикла while
Оператор while. используется в случае, когда, во-первых, не известно точное число повторов цикла и, во-вторых, при этом нет необходимости, чтобы цикл непременно был выполнен хотя бы один раз. Общая форма записи оператора имеет следующий вид:
while (условие)
тело цикла;
Оператор while организует повторное выполнение одного оператора или нескольких операторов, образующих тело цикла, до тех пор, пока условие истинно. В качестве условия обычно используется условное выражение. Если в теле цикла нужно выполнить несколько операторов, то они заключаются в фигурные скобки ({}), т.е. используется составной оператор.
Оператор while называют оператором цикла с предусловием, так как истинность условия проверяется перед входом в цикл. Следовательно, возможна ситуация, когда тело цикла не выполнится ни разу (если условие сразу ложно).
При построении цикла while необходимо включить в тело цикла операторы, изменяющие проверяемое условие так, чтобы в конце концов его значение стало ложным. В противном случае выполнение цикла никогда не завершится.
// Пример4.9. Цикл типа while. Вычислить значение f = n!.
#include <iostream>
using namespace std;
int main() {
long int f = 1; int n, i = 1;
cout<<"Vvedi n > 0: "; cin>>n;
while(i <= n){
f = f * i; i++;
}
cout<<"f = "<<f<<'\n';
}
// Пример 4.10. Определить количество цифр в заданном целом числе.
#include <iostream>
using namespace std;
int main() {
long num;
cout<<" Enter num: "; cin>>num;
cout<<" num = "<<num<<endl;
int k = 0;
while(num){
k++; num = num / 10;
}
cout<<"k = "<<k<<endl;
}
Оператор цикла do – while
Если необходимо обеспечить выполнение цикла хотя бы один раз, то удобно использовать оператор цикла do – while, который называют оператором цикла с постусловием. Общая форма записи оператора имеет следующий вид:
do
тело цикла;
while (условие);
Цикл типа do – while очень похож на цикл типа while с той лишь разницей, что проверка истинности условия в операторе do – while происходит после выполнения тела цикла. Поэтому такой цикл выполнится по крайней мере один раз. Повторение тела цикла происходит до тех пор, пока условие не примет значение ложь.
// Пример4.11. Цикл типа do – while. Вычислить значение f = n!.
#include <iostream>
using namespace std;
int main() {
long int f = 1; int n, i = 1;
cout<<"Vvedi n > 0: "; cin>>n;
do{
f = f * i; i++;
}while(i <= n);
cout<<"f = "<<f<<'\n';
system("pause");
}
Оператор цикла for
Оператор цикла for обычно используется в случаях, когда известно, сколько раз должен быть выполнен цикл, и называется циклом с параметром. Цикл for имеет следующую форму записи:
for (Выражение1; Выражение2; Выражение3)
тело цикла;
В операторе for используются три выражения, разделяемые символами точка с запятой. В тело цикла может входить простой оператор, составной оператор.
Выражение1 называется инициализирующим выражением, предназначено для установки управляющей переменной цикла, равной начальному значению. Эта переменная является счётчиком цикла (параметром цикла) и предназначена для управления работой цикла. Здесь также можно присваивать начальные значения и другим переменным, используемым в цикле. Инициализация выполняется только один раз перед началом выполнения цикла for.
Выражение2 называется условием выполнения цикла, представляет собой выражение, в котором анализируется значение управляющей переменной цикла. Результат этого анализа определяет, будет ли продолжено выполнение цикла for или нет. Если значение Выражения2 отлично от нуля (истинно), то выполняется тело цикла. Если же значение Выражение2 равно нулю (ложно), то цикл завершится и выполнение программы продолжится с оператора, следующего за циклом for.
Выражение3 – это выражение, которое определяет, как изменяются значения переменных, используемых в цикле, и значение управляющей переменной цикла после каждой итерации цикла.
Любое выражение оператора цикла for может отсутствовать (но символы точка с запятой должны присутствовать). При этом для корректной работы такого цикла необходимо включить в его тело операторы, которые приведут к завершению цикла.
Если в заголовке цикла отсутствует Выражение2, оно считается истинным.
При использовании цикла for следует избегать изменения управляющей переменной цикла в теле цикла.
// Пример4.12. Цикл типа for. Вычислить значение f = n!.
#include <iostream>
using namespace std;
int main() {
long int f = 1;
int n, i;
cout<<"Vvedi n > 0: "; cin>>n;
for(i = 1; i <= n; i++)
f = f * i;
cout<<"f = "<<f<<'\n';
system("pause");
}
В цикле for имеется возможность объявить в выражении1 заголовка цикла одну или несколько переменных, но это объявление будет действительно только в пределах цикла:
for (int i = 1, j=2; i <= 5; i++, j++) // заголовок цикла
тело цикла
Выход из цикла можно организовать, присваивая управляющей переменной цикла значение, которое делает значение Выражение2 в заголовке цикла ложным. Например:
for(int i = 1; i < m; i++)
if(i*i == VALUE) i = m;
// Пример 4.13. Вычислить сумму вида 2+4+6+ +n, где n вводится.
#include <iostream>
using namespace std;
int main() {
int n, sum = 0;
cout<<"Enter n:"; cin>>n;
if(n % 2)n = n - 1;
for(int i = 2; i <= n; i+=2)
sum = sum + i;
cout<<" 2 + 4 +... + " <<n<<" = "<<sum<<endl;
}
Способы организации бесконечных циклов
Цикл, в котором не предусмотрен выход из него, будет повторяться бесконечное число раз. Такой цикл называется бесконечным.
Для организации бесконечного цикла с помощью оператора while условие оператора должно быть всегда верно, вне зависимости от значений переменных внутри цикла. И так как ложью в С++ считается нуль, а простейшее арифметическое выражение может состоять из константы, то например, бесконечный цикл можно организовать так:
while (1){
тело цикла
}
В программе можно задать именованную константу, определить её значение в виде любого, отличного от нуля числа. В этом случае бесконечный цикл можно организовать следующий образом:
const bool flag = true;
while (flag){
тело цикла
}
Бесконечный цикл можно организовать и с помощью оператора цикла for.
Если в операторе for отсутствует условие окончания цикла, то цикл становится бесконечным и может быть прерван только из своего тела с помощью оператора break, о котором речь пойдет позже.
Вложенные циклы
Вложенным называется цикл, находящийся внутри другого цикла. Внутренний цикл выполняется полностью во время каждого повтора (итерации) внешнего цикла.
В программе можно использовать любые комбинации вложенных циклов всех типов: while, for, do–while, если этого требует логика построения программы. Приведём примеры вложенных циклов.
// Пример1. Вывод на экран пяти строк с цифрами от 0 до 9.
// Вложенный цикл организован оператором for.
…
int i, j;
for(i = 0; i < 5; i++) {
for(j = 0; j < 10; j++)
cout<<j<<' ';
cout<<endl;
}
…
// Пример 2. Ввод десяти значений месяца с проверкой правильности
// ввода. Вложенный цикл организован операторами for и do-while.
…
int i, den;
for(i = 1; i <= 10; i++){
do
cin>>den;
while(den < 1 || den > 31);
cout<<den;
}…
В данном примере внешний цикл выполняется 10 раз, а внутренний будет выполняться до тех пор, пока не будет введено правильное значение.
// Пример 4.14. Вычислить для каждого числа, вводимого с клавиатуры,
// его факториала. Построить диалог при вводе чисел.
#include <iostream>
using namespace std;
int main() {
short n;
char flag = 'y';
while (flag == 'y'){
cout << "Enter the number\n"; cin >> n;
if (n <= 0){cout<<" Data error! "<<endl; system("pause");}
long k = 1;
for(short i = 1; i <= n; i++)
k = k * i;
cout<<"Factorial chisla "<<n<<" = "<<k<<endl;
cout<<" Continue? (y/n)\n"; cin>>flag;
}
system("pause");
}
Оператор break
Оператор break имеет два назначения. Первое – окончание работы оператора switch, второе – принудительное окончание цикла, минуя стандартную проверку условия.
Оператор break может использоваться в операторах цикла всех трёх типов. Необходимость в использовании оператора break возникает обычно, когда условие продолжения цикла необходимо проверить в середине тела цикла (а не в начале или конце):
заголовок_цикла{
…
if(условие) break;
…
}
Оператор break, стоящий в теле цикла, немедленно прекращает выполнение цикла, и передаёт управление оператору, следующему после данного цикла. Если оператор break находится внутри вложенных циклов, то его действие распространяется только на тот цикл, непосредственно в котором он находится.
Часто с помощью оператора break организовывают выход из бесконечного цикла. В общем случае это может выглядеть следующим образом:
while (true){
…
if (условие) break;
…
}
// Пример4.15. Длякаждогочисла, вводимого с клавиатуры, получить
// сумму его цифр. Конец вычислений – ввод числа, равного нулю.
#include <iostream>
using namespace std;
int main() {
long num;
for(;;){
cout<<"Enter number: "; cin>>num;
if(!num) break;
int sum = 0;
while(num){
int c=num % 10;
sum = sum + c; num = num / 10;
}
cout<<" summa= "<<sum<<endl;
}
}
Оператор continue
Оператор continue используется для завершения текущей итерации цикла и перехода к следующей итерации этого же цикла. Оператор continue вызывает пропуск той части цикла, которая находится после записи этого оператора. Общий вид использования оператора continue:
заголовок_цикла{
…
if(условие) continue;
…
}
Чтобы легче было понять работу данного оператора, рассмотрим два простых примера, дающих один и тот же результат, но в одном используется оператор continue, а в другом нет.
// Пример1. Вывод на экран чисел кратных десяти, но меньших ста.
// Оператор continue не используется.
for(int a = 0; a < 100; a++)
if(a % 10!=0);
else cout<<a<<' ';
cout<<endl; …
// Пример2. Вывод на экран чисел кратных десяти, но меньших ста.
// Оператор continue используется.
...
for(int a = 0; a < 100; a++){
if(a % 10!=0) continue;
cout<<a<<' ';
}
cout<<endl;…
Следует обратить внимание на особенность оператора continue в циклах for, while или do–while. В цикле с использованием оператора for после выполнения оператора continue, управление передаётся на вычисление третьего выражения в скобках, в приведённом примере на a++; затем на проверку условия a <100. При использовании while или do–while часть цикла, располагающаяся после continue не выполняется, а управление сразу передаётся на проверку условия, что может привести к зацикливанию, например:
…
int a = 0;
while (a < 100){
if(a % 10) continue; // зацикливание при a = 1;
cout<<a<<’ ‘;
a++;
}…
Конечно, зацикливание можно избежать следующим образом:
…
int a = -1;
while (a++, a < 100){
if(a % 10) continue;
cout<<a<<’ ‘;
}
// Пример4.16. Длякаждогочисла, вводимого с клавиатуры, получить
// сумму его младших цифр, до первой цифры нуль. Конец ввода чисел
// определяется вводом числа, равного нулю.
#include <iostream>
using namespace std;
int main() {
long num;
for(;;){
cout<<"Enter number: "; cin>>num;
cout<<"num = "<<num;
if(!num) break;
int sum = 0;
while(num){
int c = num % 10;
if(!c){
num = 0; continue;
}
sum = sum + c; num = num / 10;
}
cout<<" sum = "<<sum<<endl;
}
|
|
|
