Использование управляющих конструкций в С++

Содержание:

Введение

Язык программирования C++ является одним из старейших и продвинутых языков программирования. Это компилируемый язык программирования общего назначения, который сочетает свойства как высокоуровневых, так и низкоуровневых языков программирования. С++ был создан в начале 1980-х годов и с тех пор не теряет актуальности и важности в мире программирования. Он широко используется для создания прикладных программ, разработки операционных систем, драйверов устройств, видеоигр и тд.

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

Цель данной курсовой работы – подробно изучить виды, особенности и использование основных управляющих конструкций в С++.

Для достижения поставленной цели были выделены следующие задачи:

• Проанализировать литературу по теме курсовой работы;
• Изучить понятие «управляющие конструкции»;
• Рассмотреть назначение и использование основных управляющих конструкций в C++;
• Проиллюстрировать использование основных управляющих конструкций в С++ на примере конкретных задач.

Курсовая работа состоит из введения, трех глав, заключения и списка литературы, включающего в себя 3 источника.

В первой главе описываются основные управляющие конструкции в С++.

Вторая глава посвящена конструкциям, позволяющим делать выбор и производить ветвления в программе.

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

Глава 1. Основные конструкции

Управляющие конструкции позволяют организовывать циклы и ветвления в программах.  В C++ имеется достаточно большое количество конструкций, которые будут рассмотрены в данной работе. К таким конструкциям относятся условия (будут рассмотрены во 2 главе), циклы (будут рассмотрены во 3 главе), исключения, функции и другие.

Фигурные скобки

Основная управляющая конструкция в C++ - это фигурные скобки. Фигурные скобки позволяют объединить несколько элементарных операторов в один составной оператор или блок. Во всех синтаксических конструкциях составной оператор можно использовать вместо простого. [1]

В C++ в начало блока можно помещать описания локальных переменных. Локальные переменные, описанные внутри блока, создаются при входе в блок и уничтожаются при выходе из него. [2] [3]

В C++ локальные переменные можно описывать не только в начале блока, но и в середине, однако вне зависимости от их положения, они автоматически уничтожаются при выходе из блока. [4] [5]

Приведем фрагмент программы, обменивающий значения двух вещественных переменных:

double a, b;  

...  

{  

  double tmp = a;  

  a = b;  

  b = tmp;  

}  

Чтобы обменять значения двух переменных a и b, мы сначала запоминаем значение x во вспомогательной переменной tmp. Затем в a записывается значение b, а в b - сохраненное в tmp предыдущее значение x. Поскольку переменная tmp нужна только внутри этого фрагмента, мы заключили его в блок и описали переменную tmp внутри этого блока. По выходу из блока память, занятая переменной tmp, будет освобождена.

Оператор запятая

Оператор запятая (,) позволяет объединить несколько выражений в одно выражение, таким образом в C++ вводится понятие выражение с запятой, имеющее общий вид записи:

<выражение>, <выражение>, <выражение>, . . . [6]

Оператор запятая имеет ассоциативность слева направо. Два выражения, разделенные запятой, вычисляются в направлении слева направо. Левый операнд вычисляется всегда в первую очередь, и перед вычислением правого операнда учитываются все побочные эффекты. [7] [8]

В некоторых контекстах, например, в списках аргументов функций, в качестве разделителей можно использовать запятые. Не следует путать использование запятой в качестве разделителя с ее использованием в качестве оператора; эти два варианта использования совершенно различны. [9] [10]

В тех случаях, когда в качестве разделителя обычно используется запятая (например, в фактических аргументах для функций или составных инициализаторов), оператор запятую и его операнды следует заключать в скобки. [11] Например:

function_1( x, y + 2, z );

function_2( (x--, y + 2), z );

В приведенном выше вызове функции func_one передаются три аргумента, разделенные запятыми: x, y + 2 и z. В вызове функции function_2 скобки заставляют компилятор интерпретировать первую запятую в качестве оператора последовательного вычисления. В этом вызове функции в функцию function_2 передаются два аргумента. Первым аргументом является результат операции последовательного вычисления (x--, y + 2), который имеет значение и тип выражения y + 2; второй аргумент — z.

Операторы передачи управления

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

К операторам передачи управления в C++ относятся:

• goto;
• функции (function_name());
• return.

Оператор перехода goto

Оператор перехода goto позволяет изменить естественный порядок выполнения программы и осуществить переход на другой участок программы, обозначенный меткой. [12] Переход может осуществляться только внутри функции, т.е. оператор goto не может ни выйти из функции, ни войти внутрь другой функции. Оператор goto выглядит следующим образом:

L: ...;  

...  

goto L;  

В качестве метки можно использовать любое имя, допустимое в C++ (т.е. последовательность букв, цифр и знаков подчеркивания " _ ", начинающуюся не с цифры). [13] Метка может стоять до или после оператора goto. Метка выделяется символом двоеточия " :". Лучше после него сразу ставить точку с запятой " ; ", помечая таким образом пустой оператор - это общепринятая программистская практика, согласно которой метки ставятся между операторами, а не на операторах. [14]

Использование оператора goto нежелательно, поскольку это запутывает программу. Вместо goto при необходимости можно использовать операторы выхода из цикла break и пропуска итерации цикла continue. Единственная ситуация, в которой использование goto оправдано, - это выход из нескольких вложенных друг в друга циклов:

while(...)  

{  

  ...  

  while(...)  

  {  

    ...  

    if(...)  

    {  

      goto LExit;  

    }  

    ...  

    }  

}  

LExit: ;  

Оператор func() вызов функции

Функция — это поименованный набор описаний и операторов, выполняющих определенную задачу. [15] Функция может принимать параметры и возвращать значение. Информация, передаваемая в функцию для обработки, называется параметром, а результат вычислений функции ее значением. Обращение к функции называют вызовом. [16]

Перед вызовом функция должна быть обязательно описана. Описание функции состоит из заголовка и тела функции:

тип имя_функции(параметры)  

{  

  тело функции  

}  

Заголовок функции содержит:

тип возвращаемого функцией значения, он может быть любым; если функция не возвращает значения, указывают тип void;

имя_функции, с которым она будет вызываться;

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

Тело функции представляет собой последовательность описаний и операторов, заключенных в фигурные скобки. [17]

В общем виде структура программы на C++ может иметь вид:

тип имя_1(параметры)  

{  

  //тело функции

}  

тип имя_2(параметры)  

{  

  //тело функции

}

…

int main(параметры)

{  

//тело функции может содержать

//вызов других функций

//тело основной функции

}  

Стоит отметить, что тексты функции могут следовать после главной функции main(). Однако заголовки необходимо перечислить до нее. [18]

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

имя_функции(параметры);

Оператор return

Для возвращения результата из функции применяется оператор return. Этот оператор имеет две формы:

return;

return выражение; [19]

Первая форма используется, если в качестве возвращаемого типа функции применяется тип void. [20]

Вторая форма оператора return применяется для возвращения результата из функции. Если функция имеет в качестве возвращаемого типа любой тип, отличный от void, то такая функция обязательно должна возвратить некоторое значение с помощью оператора return. Причем значение, которое возвращается оператором return, должно соответствовать возвращаемому типу функции, либо допускать неявное преобразование в этот тип. [21]

Исключения

Исключение - это некое действие, которое вступает в силу, при наступлении нестандартной ситуации. Говоря о об исключениях в С++, рассмотрим одну из таких нестандартных ситуаций — деление на 0. Если в программе вручную вводится большое количество числовых данных, и в результате определенных расчетов значение одной из переменных станет равным нулю, и это значение выступит в роли делителя, то это действие приведет к неизбежному закрытию программы и выходу из нее и потере всех данных. [22]

Приведенный ниже пример иллюстрирует исключения в С++. Пользователь должен ввести два числа, и программа проведет простые расчеты с этими числами. Ввод и расчеты будут проводиться определенное количество раз — с помощью цикла while.

Если в приведенном ниже коде в переменную a внести число 0, то программа прекращает свою работу, поскольку сталкивается с делением на 0 (см. Листинг 1).

1. #include <iostream>;  
2.   
3. using namespace std;  
4.   
5. int main()    
6. {    
7.   int a, b, i;     
8.   i=2  
9.   while(i--)    
10. {  
11.    cout<<"Введите значение num1: ";  
12.     cin>>a;  
13.     cout<<"Введите значение num2: ";  
14.     cin>>b;  
15.     cout<<"a+b="<<a+b<<endl;  
16.     cout<<"a/b="<<a/b<<endl;  
17.     cout<<"a-b="<<a-b<<endl;  
18. }  
19. system("pause");  
20. return 0;  
21. }    

Листинг 1

В программе цикл должен отработать два раза. В строке 12 циклу передается значение переменной i, и в этой же строке она уменьшается на единицу с помощью операции декремента (i--). Но если в переменную num2 будет введено значение 0, будет виден только результат сложения a + b, и программа завершит работу вне зависимости от того, есть код ниже или нет, отработал цикл или нет.

С помощью исключений возможно избежать подобных проблем. [23] Чтобы добавить исключение к этому примеру, необходимы следующие команды С++:

• throw;
• try;
• catch.

В исходном коде ниже (см. Листинг 2), исключение будет работать следующим образом: программа получает конкретное указание от программиста — если значение определённой переменной в определённом участке кода (в try-блоке) будет равно 0, то в этом случае пусть генерируется исключение throw. Это исключение автоматически передастся catch-блоку в виде параметра, и будет выполнен код этого блока.

Рассмотрим пример:

1. #include <iostream>;
2. using namespace std;  
3.    
4. int main()  
5. {  
6.   int a, b;  
7.   int var = 2;   
8.   while(var--)  
9.   {  
10.     cout<<"Введите первое число: ";  
11.     cin>>a;  
12.     cout<<"Введите второе число: ";  
13.     cin>>b;   
14.     cout<<a<<”+”<<b<<”="<<a+b<<endl;  
15.     cout<<a<<”/”<<b<<”=";   
16.     try  
17.     {    
18.       if (num2 == 0)  
19.       {  
20.         throw 123;  
21.       }  
22.       cout<<a/b<<endl;     
23.     }  
24.     catch(int i)  
25.     {  
26.       cout<<"Ошибка "<<i;  
27.       cout<<" - на 0 делить нельзя!"<<endl;  
28.     }  
29.     cout<<a<<”-“<<b<<”="<<a-b<<endl;  
30.     cout<<endl;  
31.   }  
32.   system("pause");  
33.   return 0;  
34. }  

Листинг 2

В строках 22 — 29 определен try-блок. В нем располагается код, который потенциально может вызвать ошибку в работе программы, а именно ошибку в случае деления на 0. Задаем условие if — если num2 равно 0, то генерировать целое число 123, к примеру. В этом случае try-блок сразу прекращает выполнение дальнейших команд, а число 123 попадает в catch. В нашем примере выводится сообщение об ошибке. При этом программа продолжает работать и выполнять команды, размещенные ниже. Если же число num2 не будет равно нулю, то в try-блоке выполнится команда cout << num1 / num2 << endl;, а catch не сработает.

Запускаем программу и в первом шаге цикла вводим значение переменной num2 равное 0, а во втором — любое другое число (см. Рисунок 1)

Рисунок 1

Программа завершила работу.

Как видно, деление на 0 не произошло, и программа не прекратила свою работу. Вместо этого мы увидели сообщение об ошибке в строке, где должна была произойти операция деления на 0.

Чтобы было лучше понятно, как именно значение, которое генерирует throw передается в catch, заменим участок кода строк 22 — 33 на следующий код:

try  

{    

  if (num2 == 0)  

  {  

    throw "Ошибка - на 0 делить нельзя!!!!";  

    //генерировать символьную строку  

  }  

  cout << num1 / num2 << endl;     

}  

catch(char *str)//сюда передастся строка  

{  

  cout << str << endl;  

}  

При попытке деления на 0 throw генерирует не число, а символьную строку. И блоку catch в скобках мы показываем, что он будет принимать указатель на строку и ниже — выводить эту строку на экран.

Исключение так же может генерироваться в определенной программистом функции. Например, у нас определена функция деления двух целых чисел и в ней мы сразу проверим деление на 0.

int division(int n1, int n2)  

{  

    if(n2==0)  

    {  

        throw 99;  

    }  

    return n1/n2;  

}  

Вызывается эта функция в try-блоке.

try  

{    

  cout<<division(5, 0);  

  cout<<endl;  

}  

catch(int i)  

{  

  cout<<"Ошибка №"<<i<<" Деление на ноль."<<endl;  

}  

Деление на ноль не состоится и catch поймает число 99.

Что важно знать об исключениях:

• try-блок — так называемый блок повторных попыток. В нем надо располагать код, который может привести к ошибке и аварийному закрытию программы; [24]
• throw генерирует исключение. То, что остановит работу try-блока и приведет к выполнению кода catch-блока. Тип исключения должен соответствовать типу принимаемого аргумента catch-блока; [25]
• catch-блок — улавливающий блок, поймает то, что определил throw, и выполнит свой код. Этот блок должен располагаться непосредственно под try-блоком. Никакой код не должен их разделять. [26]
• если в try-блоке исключение не генерировалось, catch-блок не сработает. Программа его обойдет.

Глава 2. Ветвления

Встречаются ситуации, когда программе нужно выбрать, какую операцию ей выполнить, в зависимости от определенного условия. [27]

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

Для реализации данных конструкций используются следующие операторы:

• if
• else
• else if
• switch

Отдельно стоит упомянуть так называемый тернарный оператор. Используется он обычно в тех случаях, если условие и код, который надо выполнить, в результате проверки условия, очень простые. К примеру, спросить у пользователя хочет он продолжить работать в программе или же хочет выйти из неё. Он имеет следующий синтаксис:

условие ? команда 1 : команда 2

Оператор if

Операторы выбора позволяют принять программе решение, основываясь на истинности или ложности условия. [28] Если условие истинно (т. е. равно true), оператор в теле if выполняется, после чего выполняется следующий по порядку оператор. [29] Если условие ложно (т. е. равно false), оператор в теле if не выполняется (игнорируется или пропускается) и сразу же выполняется следующий по порядку оператор. Проверяемое условие может быть любым логическим выражением. [30] Логические выражения могут быть образованы операциями равенства и отношения (см. Таблица 1).

Оператор	Условие	Описание
==	a == b	a равно b
!=	a != b	a не равно b
>	a > b	a больше b
<	a < b	a меньше b
>=	a >= b	a больше или равно b
<=	a <= b	a меньше или равно b

Таблица 1. Логические выражения

Нельзя путать операцию = (операция присваивания) и операцию == (операция равенства) так как это приводит к логическим ошибкам, т. е. программа даже скомпилируется без ошибок, но работать будет не правильно.

Условный оператор или оператор выбора if записывается в двух формах, рассмотрим первую.

if(/*проверяемое условие*/)  

{  

   /*тело оператора выбора 1*/;  

}  

Фигурные скобки тела условного оператора можно опускать, если при истинности условия необходимо выполнить один оператор. Пример:

if(/*проверяемое условие*/)  

   /* оператор*/;  

Рассмотрим простейший пример использования оператора if (см. Листинг 3).

Условие задачи: даны два числа, необходимо их сравнить.

1. #include <iostream>  
2.   
3. using namespace std;  
4.    
5. int main()  
6. {  
7.   int a, b;  
8.   cout<<"Введите первое число: ";  
9.   cin>>a;  
10.   cout<<" Введите второе число: ";  
11.   cin>>b;  
12.   if(a>b)  
13.   {  
14.     cout<<a<<">"<<b<<endl;  
15.   }  
16.   if(a<b)  
17.   {  
18.     cout<<a<<"<"<<b<<endl;  
19.   }  
20.   if(a==b)  
21.     cout<<a<<"="<<b<<endl;  
22.   system("pause");  
23.   return 0;  
24. }  

Листинг 3

В строке 7 объявляются две переменные. После того как мы ввели два числа, программа начинает их сравнивание. Так как неизвестно, какие числа введет пользователь, необходимо предусмотреть все возможные случаи.

• 1-й случай: первое введенное число больше второго. (12-15 строки).
  Читается так: «Если ;а больше b, то делать соответствующий вывод на экран».
• 2-й случай: первое введенное число меньше второго. (16-19 строки).
  Читается так: «Если, а меньше b, то делать соответствующий вывод на экран».
• 3-й случай: первое введенное число равняется второму. (20-21 строки).
  Читается так: «Если, а равно b, то делать соответствующий вывод на экран».

Первые два оператора if написаны вместе с фигурными скобками, хотя можно было обойтись и без них, ведь при истинном условии у нас выполняется только оператор вывода. А в третьем операторе if скобки опущены, тем самым показано, что программа будет работать правильно и без них. Ниже показан пример работы программы, описанной выше (см. Рисунок 2).

Рисунок 2

Оператор if else

Оператор if else — это форма записи оператора выбора if. Оператор if else позволяет определить программисту действие, когда условие истинно и альтернативное действие, когда условие ложно. [31]

Синтаксис записи оператора выбора if else следующий:

if(/*проверяемое условие*/)  

{  

   /*тело оператора выбора 1*/;  

}  

else  

{  

  /*тело оператора выбора 2*/;  

}  

Читается так: «Если проверяемое условие истинно, то выполняется тело оператора выбора 1, иначе (то есть проверяемое условие ложно) выполняется тело оператора выбора 2.» [32]

Рассмотрим задачу с предыдущего раздела, с использованием if else (см. Листинг 4). Условие задачи следующее: «Даны два числа, необходимо их сравнить».

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. int main(int argc, char* argv[])  
6. {  
7. int a, b;  
8. cout<<"Введите первое число: ";  
9. cin>>a;  
10. cout<<"Введите второе число: ";  
11. cin>>b;  
12. if(a>=b)  
13. {  
14. cout<<a<<">="<<b<<endl;  
15. }  
16. else  
17. {  
18. cout<<a<<"<="<<b<<endl;  
19. }  
20. system("pause");  
21. return 0;  
22. }  

Листинг 4

В данном коде нас интересуют строки 12-19. Эти строки читаются так: если a (первое число) больше либо равно b (второе число), то выполнить оператор вывода в строке 14, иначе выполнить оператор вывода в строке 18.

В данном операторе if мы используем операции соотношений >= и <=. Условие перехода не совсем правильно, так как условие будет ложно только в том случае, если первое число будет меньше второго, во всех остальных случаях условие истинно.

Вывод программы следующий (см. Рисунок 3):

Рисунок 3

Оператор switch

Итак мы рассмотрели оператор с одиночным выбором if и оператор с двойным выбором if else, но в С++ еще имеется оператор множественного выбора switch, который мы сейчас детально рассмотрим.

switch(переменная или выражение)  

{  

  case значение_1:  

    код;  

    break;  

  case значение_2:  

    код;  

    break;  

  ...  

  default:  

    код;  

}  

На начальном этапе анализируется выражение или переменная. После этого осуществляется переход к той ветви программы, для которой значение переменной или выражения совпадает с указанным константным выражением. [33] Далее выполняется оператор или группа операторов пока не встретится зарезервированное слово break (оператор break будет рассмотрен более подробно в 3 главе данной работы, посвященной циклам). Если значение переменной или выражения не совпадает ни с одним константным выражением, то передается управление ветви программы содержащей зарезервированное слово default. После чего выполняется оператор или группа операторов данной ветви. [34]

Рассмотрим задачу с использованием оператора выбора switch (см. Листинг 5).

Условие задачи: написать программу, которая складывает, вычитает, умножает, делит два числа, введенных с клавиатуры. Разработать пользовательский интерфейс.

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. int main(int argc, char* argv[])  
6. {  
7.   int count;  
8.   double a,b;  
9.   cout<<"Введите первое число: ";  
10.   cin>>a;  
11.   cout<<"Введите второе число: ";  
12.   cin>>b;  
13.   cout<<"Выбирите действие:\r\n”  
14.        +”\t1-сложение\r\n”  
15.        +”\t2-вычитание\r\n”  
16.        +”\t3-умножение\r\n”  
17.        +”\t4-деление\r\n"  
18.        +”:”;  
19.   cin>>count;  
20.   switch(count)  
21.   {  
22.     case 1:  
23.       cout<<a<<"+"<<b<<"="<<a+b<<endl;  
24.       break;  
25.     case 2:  
26.       cout<<a<<"-"<<b<<"="<<a-b<<endl;  
27.       break;  
28.     case 3:     {  
29.       cout<<a<<"*"<<b<<"="<<a*b<<endl;  
30.       break;  
31.     case 4:  
32.       cout<<a<<"/"<<b<<"="<<a/b<<endl;  
33.       break;  
34.     default:  
35.       cout<<"Ошибка ввода"<<endl;  
36.   }  
37.   system("pause");  
38.   return 0;  
39. }  

Листинг 5

В 7 строке мы объявили переменную count целочисленного типа. Именно значение данной переменной программа будет сравнивать со значением константного выражения. В строке 8 объявлены две переменные вещественного типа данных для хранения введённых чисел. С 20 по 36 строки записан условный оператор множественного выбора switch. На начальном этапе анализируется переменная count.

Анализ проводится следующим образом:

• если переменная count равна единице, то выполняется оператор в 23 строке;
• если переменная count равна двойке, то выполняется оператор в 26 строке;
• если переменная count равна тройке, то выполняется оператор в 29 строке;
• если переменная count равна четырем, то выполняется блок оператор в 32 строке;
• если же значение переменной count не совпадает ни с одним константным выражением, то передается управление ветви программы, содержащей зарезервированное слово default. То есть будет выполнена следующая строка 35.

Оператор switch может содержать, а может и не содержать зарезервированное слово default. [35] Если значение переменной не совпадет ни с одним константным выражением и не будет default, то программное управление в этом случае просто перешло бы к первому оператору после switch. [36] В строках 22, 25, 28, 31 записаны константные выражения, с которыми программа сравнивает значение переменной count.
В строках 24, 27, 30, 33, записан оператор break, который необходим для следуюих целей. Допустим, пользователь ввел 2, то есть переменная count инициализировалась двойкой. Начинает работать условный оператор множественного выбора switch. То есть выполняется поиск двойки в константных выражениях. Сначала проверяется строка 22, мы видим, что в строке 22 константное выражение равно единице, а нам нужна двойка. Проверяем дальше. А дальше по порядку строка 25. Мы видим, что в строке 25 константное выражение равно двойке, то, что нужно. Переменная count равна константному выражению, выполняется оператор в 26 строке. И вот в 27-й строке записан оператор break, который заставляет программу перейти к первому оператору после оператора switch. В данном случае управление передается строке 37. А нужен этот переход только для того, чтобы не выполнялись заведомо ненужные действия. Если убрать оператор break, то программа будет дальше сравнивать значение переменной с константными выражениями, пока они все не закончатся и потом все равно передаст управление строке 37 (см. Рисунок 4).

Рисунок 4

Глава 3. Циклы

Иногда необходимо повторять одно и то же действие несколько раз подряд. Для этого используют циклы.

Цикл — многократное прохождение по одному и тому же коду программы. Циклы необходимы программисту для многократного выполнения одного и того же кода, пока истинно какое-то условие. Если условие всегда истинно, то такой цикл называется бесконечным, у такого цикла нет точки выхода.

В языке программирования С++ существуют такие циклы:

• цикл for;
• цикл while;
• цикл do  while.

Тело цикла будет выполняться до тех пор, пока условие будет истинно.

Цикл for

Форма записи оператора цикла for:

for(/*выражение1*/; /*выражение2*/; /*выражение3*/)  

{  

  /*один оператор или блок операторов*/;  

}  

Если в теле цикла for должен выполниться один оператор, то фигурные скобки можно опустить [37]:

for(/*выражение1*/; /*выражение2*/; /*выражение3*/)  

  /*один оператор*/;  

Рассмотрим подробно три выражения, записанные в круглых скобках цикла for.

Выражение 1 — объявление (и) или инициализация ранее объявленной переменной-счетчика, которая будет отвечать за истинность условия в цикле for. Переменная-счетчик всегда должна иметь целочисленный тип данных. Если переменная была объявлена в цикле (все равно в каком), по завершении цикла эта переменная будет уничтожена.

Выражение 2 — это условие продолжения цикла for, оно проверяется на истинность.

Выражение 3 изменяет значение переменной-счетчика. Без выражения 3 цикл считается бесконечным, так как изменение содержимого переменной count выполняться не будет, и если изначально условие было истинным, то цикл будет бесконечным, иначе программа даже не войдет в цикл.

Выражения 1, 2, 3 отделяются друг от друга обязательными разделителями, точкой с запятой. Тело цикла обрамляется фигурными скобками. Если тело цикла состоит из одного оператора, то фигурные скобки не нужны. Под изменением значения переменной подразумевается уменьшение или приращение значения, например:

for(int counter=0; counter<15; counter++)

выполняется приращение переменной counter с шагом 1 от 0 до 14

• ++ операция инкремента, увеличение значения переменной на единицу;
• -- операция декремента, уменьшение значения переменной на единицу.

Очень часто неправильно интерпретируется запись пределов в цикле for, в приведенном ранее приращение переменной counter выполняется с шагом 1 от 0 до 15. Особое внимание следует обратить на конечный предел. [38] [39] В условии продолжения цикла стоит знак отношения строго меньше, а значит, когда значение в переменной counter будет равно 14, выполнится выход из цикла. Ниже показан пример работы программы (см. Листинг 6).

1. #include <iostream>  
2.   
3. using namespace std;  
4.    
5. int main(int argc, char* argv[])  
6. {  
7.   for (int counter=0; counter<15; counter++) 
8.     cout<<counter<<" ";  
9.   cout<<endl;  
10.   system("pause");  
11.   return 0;  
12. }  

Листинг 6

В строках 8 и 9 записан цикл for без фигурных скобок. Если фигурные скобки отсутствуют, значит, телом цикла является следующий оператор после заголовка цикла, в данном случае это оператор вывода. Заголовком цикла for является строка 8.

Рисунок 5

Ниже показан результат работы программы с использованием декремента, для уменьшения значения переменной-счетчика (см. Листинг 7).

1. #include <iostream>  
2.   
3. using namespace std;  
4.    
5. int main(int argc, char* argv[])  
6. {  
7.   for(int count=14; count>=0; count--)  
8.     cout << " " << count;  
9.   cout << endl;  
10.   system("pause");  
11.   return 0;  
12. }  

Листинг 7

В заголовке цикла for в условии продолжения цикла использован нестрогий знак отношения >=, чтобы последним значением переменной-счётчика был 0.

Рисунок 6

Шаг в цикле for может быть отличным от единицы, а точнее, любым целым числом.

for(int i=0; i<=20; i+=5)

приращение переменной i от 0 до 20 включительно с шагом 5

В этом случае переменная counter будет равняться 5, 10, 15, и 20, после чего выполнится выход из цикла for.

for ( int i=20; i>= 0; i-=5)

изменение переменной i от 20 до 0 включительно с шагом 5

Далее показан код программы, которая подсчитывает количество чётных чисел в интервале от 0 до 50 включительно (см. Листинг 8).

1. #include <iostream>  
2.   
3. using namespace std;  
4.    
5. int main(int argc, char* argv[])  
6. {  
7.   int counter = 0;  
8.   for (int i=2; i<=50; i+=2)
9.     counter_even ++;  
10.   cout<<"Четных чисел: "<<counter<<endl;
11.   system("pause");  
12.   return 0;  
13. }  

Листинг 8

В строке 9 объявлена и инициализирована нулём переменная для хранения количества чётных чисел. В заголовке цикла for в строке 10 переменная counter инициализирована двойкой, так как двойка — первое чётное число, начиная с 0. Шаг цикла равен двум, таким образом, следующее чётное число это 4. В строке 11 переменная counter_even инкрементируется на каждом этапе цикла for. Результат работы программы показан ниже (см. Рисунок 7).

Рисунок 7

Цикл while

Оператор цикла while или цикл while — цикл, повторяющий одно и то же действие, пока условие продолжения цикла while остаётся истинным. [40]

while(/*условие продолжения цикла while*/)  

{  

  /*блок операторов*/;  

}  

Условие продолжения цикла должно быть истинно (true), как только условие стало ложным, выполняется выход из цикла. [41] Также как и в условных операторах выбора, фигурные скобки могут опускаться в том случае, если тело цикла — это один оператор. [42] Но, как правило, в цикле выполняется несколько операторов, так как кроме выполнения полезного действия необходимо делать условие цикла while ложным, иначе цикл будет бесконечным, что в свою очередь, приведет к зависанию программы. [43] [44]

Рассмотрим применение цикла while на примере движения автомобиля. Истинным условием цикла, в данном случае, является скорость автомобиля меньше 60 км/ч, а ложным — скорость автомобиля больше или равно 60 км/ч. Повторение цикла будет продолжаться, до тех пор пока скорость автомобиля не станет больше или равна 60 км/ч, после наступления этого момента условие цикла станет ложным, и программа выйдет из цикла. Рассмотрим фрагмент кода на C++ с циклом while, решающим поставленную задачу.

int speed = 5; // начальная скорость автомобиля  

while ( speed < 60 ) // заголовок цикла while  

speed += 10; // тело цикла  

Для начала в строке 1 была объявлена и инициализирована переменная speed. В строке 2 программа проверяет условие цикла while, 5 < 60 = true. Программа входит в цикл и выполняет оператор в строке 3. Теперь уже speed = 15. Опять выполняется проверка 15 < 60 = true. Условие истинно, значение в переменной изменяется, speed = 25. Таким образом, выполняются последовательные повторения цикла, переменная speed принимает следующие значения: 35, 45, 55, 65. Последнее изменение переменной speed приводит к тому, что условие в цикле while становится ложным 65 < 60 = false, и производится выход из цикла while. Таким образом, выполнилось 6 повторений, при этом speed = 65; — с таким значением переменной закончилась работа цикла while. В виде программы данная задача будет выглядеть следующим образом (см. Листинг 9):

1. #include <iostream>  
2.   
3. using namespace std;  
4.    
5. int main(int argc, char* argv[])  
6. {  
7.   int speed = 5, count = 1;  
8.   while (speed<60)  
9.   {  
10.     speed += 10;  
11.     cout<<count<<"-speed="<<speed<<endl;  
12.     count++;  
13.   }  
14.   system("pause");  
15.   return 0;  
16. }  

Листинг 9

В строке 14 добавлена переменная-счётчик для подсчёта прохождений цикла. Тело цикла увеличилось, поэтому пришлось поставить фигурные скобки. Результат работы программы показан на Рисунке 8:

Рисунок 8

Всего 6 повторений цикла, и после выхода из цикла while переменная speed = 65.

Еще одной иллюстрацией работы цикла while может стать игра «Отгадай число». Используя генератор случайных чисел, компьютер загадывает число от 1 до 10, включительно, пока пользователь не отгадает число, выход из цикла не произойдет (см. Листинг 10).

1. #include <iostream>  
2. #include <ctime>  
3.   
4. using namespace std;  
5.    
6. int main(int argc, char* argv[])  
7. {  
8.   srand( time( 0 ) );  
9.   int a, b;  
10.   a = 1+rand()%10;  
11.   cout << "Введите номер [1:10] : ";  
12.   cin >> b;  
13.   while (a!=b)  
14.   {  
15.     cout<<"Введите номер [1:10] : ";  
16.     cin>>b;  
17.   }  
18.   cout<<"Угадал!!!"<<endl;  
19.   system("pause");  
20.   return 0;  
21. }  

Листинг 10

Чтобы войти в цикл, необходимо инициализировать переменную enter_number, тогда цикл while начнёт корректную проверку условия. Именно для этого перед циклом while запрашиваем ввод числа. После того как пользователь ввёл число, начинает работать цикл while, выйти из которого получится только в случае угадывания числа. Результат работы программы можно увидеть на Рисунке 9:

Рисунок 9

Цикл do while

Цикл do while отличается от цикла while тем, что в do while сначала выполняется тело цикла, а затем проверяется условие продолжения цикла. [45] Из-за такой особенности do while называют циклом с постусловием. Таким образом, если условие do while заведомо ложное, то хотя бы один раз блок операторов в теле цикла do while выполнится. [46] Цикл do while отличается от цикла while структурой. В цикле while сначала выполняется проверка условия продолжения цикла, и если условие истинно, то только тогда выполняется тело цикла. Цикл do while работает противоположным образом: сначала выполняется тело цикла, а потом проверяется условие, вот почему тело цикла do while, хотя бы раз, выполнится. [47]

do  

{  

  /*блок операторов*/;  

}while(/*условие выполнения цикла*/);  

В начале цикла do while пишется зарезервированное слово do, после идут фигурные скобки, которые можно опускать в случае использования одного оператора в теле цикла do while. После закрывающей фигурной скобки, обозначающей конец тела цикла do while, стоит условие цикла do while, после которого обязательно нужно ставить точку с запятой. Рассмотрим программу с циклом do while, которая выполняет некоторые транзакции с денежным счётом в банке (см. Листинг 11).

1. #include <iostream>  
2. #include <ctime>  
3.   
4. using namespace std;  
5.    
6. int main(int argc, char* argv[])  
7. {  
8.   srand(time(0));  
9.   int balance = 8;  
10.   do  
11.   {  
12.     cout<<"Баланс: "<<balance<<endl;  
13.     int removal = rand()%3;  
14.     cout<<"Вычтено: "<<removal<<endl;  
15.     balance -= removal;  
16.   }while(balance>0);  
17.   system("pause");  
18.   return 0;  
19. }  

Листинг 11

В строке 11 объявлена переменная balance, она отвечает за остаток денежных средств на счету. С 10-й по 16-ю строки записан цикл do while. В цикле do while выполняются все транзакции со счётом balance, а именно — перевод денежных средств на какой-то другой счёт, строка 19. Строка 12 показывает остаток денежных средств на счету balance. В строке 13 объявлена переменная, в которой хранится вычитаемое значение, причём это значение генерируется случайно в интервале [0;2]. Переменная removal один раз объявляется в теле цикла do while, и каждый раз при повторении цикла эта переменная не переопределяется. А вот её значение меняется, в зависимости от того, какое число сгенерировалось. В строке 16 записано условие цикла do while, как только условие станет ложным, программа передаст управление следующему оператору, после цикла do while, строка 17. Результат работы программы приведен ниже (см. Рисунок 10).

Рисунок 10

Сначала показан остаток, а затем снятие суммы, после чего опять идёт остаток и так до тех пор, пока на счету не окажется денег. Последней выводимой строкой оказалась строка со снимаемой суммой, а потом цикл завершил свою работу. Хотя и не видно последнего остатка на счету, можно и так сказать, что он равен 0.

Если вспомнить один из предыдущих примеров, игру «Угадай число», то было бы правильнее использовать цикл do while, это позволило бы уменьшить код на 2 строки (см. Листинг 12).

1. #include <iostream>  
2. #include <ctime>  
3.   
4. using namespace std;  
5.    
6. int main(int argc, char* argv[])  
7. {  
8.   srand(time(0));  
9.   int a = 1+rand()%10;  
10.   int b;  
11.   do  
12.   {  
13.     cout<<"Введите число [1:10]: ";
14.     cin>>b;  
15.   }while(b!=a);  
16.   cout<<"Вы угадали"<<endl;  
17.   system("pause");  
18.   return 0;  
19. }  

Листинг 12

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

Ещё одна программа, которая вычисляет сумму чисел в заданном интервале показана ниже (см. Листинг 13).

1. #include <iostream>  
2.   
3. using namespace std;  
4.    
5. int main(int argc, char* argv[])  
6. {  
7.   int a, b;  
8.   cout<<"Введите начальное значение: ";  
9.   cin>>a;  
10.   cout<<"Введите конечное значение: ";  
11.   cin>>b;  
12.   int sum=0, count=a;  
13.   do  
14.   {  
15.     sum+=count;  
16.     count++;  
17.   }while(count<=b);  
18.   cout<<"Сумма: "<<sum<<endl;  
19.   system("pause");  
20.   return 0;  
21. }  

Листинг 13

После запуска программы необходимо ввести пределы интервала (первый и второй). После этого начинает работать цикл do while, строка 13. переменная sum предназначена для хранения накапливаемой суммы, строка 15. В строке 16 инкрементируется начальное значение предела, после каждого повторения цикла. Результат работы программы показан на Рисунке 11.

Рисунок 11

Интервал указан от -6 до 10 включительно, [-6;10]. Программа суммирует все целые числа из заданного интервала. Сумма формируется следующим образом: -6 -5 -4 -3 -2 -1 + 0 +1 +2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 34. Таким образом, циклически выполняется действие суммирования всех целых чисел из указанного пользователем интервала.

Оператор break

Оператором break уже был упомянут при изучении оператора множественного выбора switch. В теле оператора множественного выбора switch оператор break прерывал исполнение оператора switch. Когда оператор break выполняется в цикле, то досрочно прерывается исполнение оператора цикла, и управление передаётся следующему оператору после цикла. [48] [49] Ниже приведен пример программы с использованием оператора break. Программа печатает таблицу степеней двойки (см. Листинг 14).

1. #include <iostream>  
2. #include <cmath>  
3.   
4. using namespace std;  
5.   
6. int main(int argc, char* argv[])  
7. {  
8.   for(int i=0; i<=10; i++)  
9.   {  
10.     if( count == 6)  
11.     {  
12.       break;  
13.     }  
14.     cout<<"2^"<<i<<"="<<pow(2.0,i)<<endl;  
15.   }  
16.   system("pause");  
17.   return 0;  
18. }  

Листинг 14

В строке 8 записан заголовок цикла for. В цикле for объявлена переменная-счётчик i, значение которой меняется от 0 до 10 включительно. В строке 10 записан оператор условного выбора if, истинность условия которого запускает оператор break, который, в свою очередь, приводит к выходу из цикла for. В строке 14 запускается функция pow(). Условие продолжения цикла for будет истинно до тех пор, пока значение в переменной i <= 10. Тогда как выход из цикла for произойдёт раньше, чем условие продолжения цикла станет ложным. Выход из цикла for выполнится, когда значение в переменной count станет равным шести. Результат работы программы показан ниже (см. Рисунок 12):

Рисунок 12

Из приведенного выше примера видно, что таблица степеней двойки напечаталась, включительно, до пятой степени. Если убрать оператор условного выбора if, то напечатаются степени двойки до десятой включительно (см. Листинг 15).

1. #include <iostream>  
2. #include <cmath>  
3.   
4. using namespace std;  
5.   
6. int main(int argc, char* argv[])  
7. {  
8.   for(int i=0; i<=10; i++)  
9.   {  
10. //if(i == 6)  
11. //{  
12. // break;  
13. //}  
14.     i<<"2^"<<i<<"="<<pow(2.0,i)<<endl;  
15.   }  
16.   system("pause");  
17.   return 0;  
18. }  

Листинг 15

В строках 10-13 мы закомментировали оператор условного выбора if, таким образом, печатается таблица степеней двойки от нулевой до 10-й степени включительно (см. Рисунок 13).

Рисунок 13

Оператор continue

Оператор continue используется только внутри цикла. [50] В операторах for, while, do while, оператор continue выполняет пропуск оставшейся части кода тела цикла и переходит к следующей итерации цикла. [51] [52] Рассмотрим фрагмент кода с оператором continue.

int count = 0;  

do  

{  

  continue;  

  count++;  

} while(count<10)

В приведенном выше примере видно, что оператор do while бесконечный, так как каждая итерация цикла приводит к выполнению оператора continue, который пропускает операцию инкремента переменной-счётчика count и переходит на следующую итерацию цикла. Таким образом, значение в переменной count не меняется, а значит и условие всегда будет истинным. Разработаем программу с оператором continue. Программа должна работать циклически. Внутри цикла необходимо организовать ввод чисел. Если введено число от 0 до 10 включительно, то необходимо напечатать квадрат этого числа, в противном случае, используя оператор continue, пропустить оператор возведения в квадрат введенного числа. При введении отрицательного числа осуществляется выход из цикла (см. Листинг 16).

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. int main(int argc, char* argv[])  
6. {  
7.   int a;   
8.   do  
9.   {  
10.     cout<<"Введите число: ";  
11.     cin>>a;  
12.     if(a>10 || a<0)  
13.     {  
14.       continue;  
15.     }  
16.     cout<<"Квадрат числа: "<<a*a<<endl;  
17.   } while(a>=0);  
18.   system("pause");  
19.   return 0;  
20. }  

Листинг 16

Цикличность в программе организуется циклом с постусловием — do while. В цикле сначала считывается введённое число в переменную in_number, после чего выполняется проверка условия в операторе if. Условие оператора условного выбора if будет истинным в том случае, если введённое число будет строго меньше нуля или строго больше 10. Заданный интервал — [0;10]; число, взятое из этого интервала, возводится в квадрат. Истинность условия оператора if приводит к выполнению оператора continue в строке 13. А оператор continue пропускает операторы в строке 15 и переходит к проверке условия продолжения цикла do while. Условие в цикле будет истинно, пока вводимые числа будут строго больше 0. Результат работы программы показан ниже (см. Рисунок 14):

Рисунок 14

Сначала вводились числа 15 и 11, эти числа не входят в заданный интервал и поэтому квадрат этих чисел не вычислялся. Числа 5 и 9 принадлежат заданному интервалу, а значит, программа должна вычислить их квадраты. Когда было введено отрицательное число,  do while завершил свою работу.

Заключение

В ходе написания курсовой работы была проанализирована литература по заданной тематике. Были изучены и подробно описаны основные понятия, типы управляющих конструкций и их применение на практике.

В первой главе работы были рассмотрены основные управляющие конструкции языка программирования С++, такие как:

• Фигурные скобки;
• Запятая;
• Goto;
• Функции;
• Return;
• Исключения

Во второй главе были рассмотрены основные управляющие конструкции ветвления, такие как:

• If,
• Else,
• If else,
• switch.

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

• for
• while
• do while
• continue
• break

Были приведены основные понятия, описаны конструкции и методы их использования. Показаны способы комбинирования конструкций на примерах функций и оператора return, циклов и условий с использованием операторов continue, break и goto. Использование управляющих конструкций было проиллюстрировано конкретными примерами.

Библиография

[1] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 354 с.

[2] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 188 с.

[3] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец.

изд. — М.: Бином, 2003. — 29 с.

[4] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 57 с.

[5] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 208 с.

[6] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 163 с.

[7] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец.

изд. — М.: Бином, 2003. — 54 с.

[8] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец.

изд. — М.: Бином, 2003. — 84 с.

[9] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 159 с.

[10] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 65 с.

[11] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. —197 с.

[12] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 219 с.

[13] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 92 с.

[14] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 68 с.

[15] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 320 с.

[16] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 32 с.

[17] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 106 с.

[18] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 70 с.

[19] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 346 с.

[20] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 109 с.

[21] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 73 с.

[22] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 132 с.

[23] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 521 с.

[24] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 524 с.

[25] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 237 с.

[26] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 528 с.

[27] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 208 с.

[28] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 31 с.

[29] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 192 с.

[30] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 158 с.

[31] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 190 с.

[32] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 195 с.

[33] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 197 с.

[34] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 31 с.

[35] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 90 с.

[36] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 209 с.

[37] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 209 с.

[38] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 31 с.

[39] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 209 с.

[40] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 31 с.

[41] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 72 с.

[42] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 213 с.

[43] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 209 с.

[44] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 209 с.

[45] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 209 с.

[46] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 216 с.

[47] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 209 с.

[48] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 31 с.

[49] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 67 с.

[50] Страуструп Б. Язык программирования C++: Пер. с англ. — 3-е спец. изд. — М.: Бином, 2003. — 78 с.

[51] Липпман С. Б., Лажойе Ж. Язык программирования С++. Вводный курс: Пер. с англ. — 3-е изд. — М.: ДМК, 2001. — 219 с.

[52] Керниган Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. — 3-е изд. — СПб.: Вильямс, 2016. — 68 с.