Ветвление процесса выполнения программ

Для решения многих задач требуется многократное повторение одних и тех же действий. На практике это реализуется либо с помощью рекурсии либо с помощью итерации. Итерация – это повторение одних и тех же действий определенное количество раз. Основным методом итерации является цикл. Циклы в С++ могут быть трех видов:

· цикл с предусловием – while

· цикл с постусловием – do…while

· цикл с управляющей переменной – for

Оператор цикла While

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

Синтаксис оператора цикла с предусловием следующий:

while (выражение условия)

{

операторы тела цикла;

}

Выражение условия – это любое выражения языка С++ , а оператор – любой допустимый оператор или блок операторов. Если выражение истинно – возвращает значение 1, выполняется тело цикла (блок операторов), после чего выражение условия проверяется снова. Так будет продолжаться до тех пор, пока выражение не станет ложным (0); тогда цикл while завершится, а выполнение программы продолжится со следующей строки.

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

Пример. В приведенном ниже листинге программы на экран выводятся все значения переменной х, начиная с начального (х=0), увеличиваясь на единицу с каждой итерацией, до тех пор, пока х < 5.

0: #include <iostream>

1:

2: int main()

3: {

4: int x=0; //присвоение начального значения

5:

6: while(x<5) // проверка, истинно ли еще условие

7: {

8: x++; // тело цикла

9: std::cout<<"x= "<<x<<"\n";

10: }

11: std::cout<<" Complete. x: "<<x<<"\n";

12: return 0;

13: }

Сначала проверяется условие, и если оно истинно, то выполняется тело цикла. В данном случае условию удовлетворяют все х значения переменной х, меньшие 5. Если условие истинно, то значение переменной х увеличивается на 1 (выполняются операторы тела цикла), а следующая строка выводит это значение на экран. Как только значение счетчика достигает 5 (условие ложно), все тело цикла пропускается и программа переходит к строке 11.

Результат работы программы:

x= 1

x= 2

x= 3

x= 4

x= 5

Completex: 5

Условие, проверяемое в цикле while может состоять из нескольких выражений, объединенных логическими операторами: &&, | |, ! . Например, приведенная ниже программа демонстрирует реализацию логической задачи. Вводятся два положительных числа – одно меньше, другое больше, их значения размещаются соответственно в переменных small и large. Далее меньшее начинает увеличиваться на единицу, а большее уменьшаться на два, процесс продолжается до тех пор, пока значения чисел не «встретятся». Цель задачи – определить эти числа. Для решения необходимо проверить три условия продолжения цикла:

- меньшее число меньше большего (small < large);

- большее больше нуля (0 < large);

- меньшее число меньше максимально допустимого.

0: #include <iostream>

1: using namespace std;

2: int main() {

3: unsigned short small; // от 0 до 65 535

4: unsigned long large; // от 0 до 4 294 967 295

5: const unsigned short MAX= 65535; //объявление константы МАХ и

6: //присвоение ей значения[3]

7: cout<<"Enter a small number: ";

8: cin>>small;

9: cout<<"Enter a large number: ";

10: cin>>large;

11: // при каждой итерации проверяются три условия

12: while (small<large && large > 0 && small < MAX)

13: {

14: small++;

15: large -=2;

16: }

17: cout<<"\nSmall: "<<small<<" Large: "<<large<<endl;

18: return 0; }

Результат

Enter a small number: 2

Enter a large number: 100000

Small: 33335 Large: 33334

Оператор цикла do…while

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

// Пример игнорирования цикла при заведомо ложном условии

#include <iostream>

#include <windows.h>

using namespace std;

int main()

{

char str[20];

int x;

CharToOem("Сколько приветов? : ", str);

cout<<str;

cin>>x;

while (x>0)

{

CharToOem("Привет!\n", str);

cout<<str;

x--;

}

return 0;

}

Перегрузка функций

Важной возможностью С++ является перегрузка функций (function overloading). Перегрузка функций не только обеспечивает механизм, посредством которого в С++ реализуется механизм, называемый полиморфизмом (многообразие форм), но и формирует то ядро, вокруг которого развивается вся среда программирования на С++. Под полиморфизмом функций понимают существование в программе нескольких перегруженных функций разного назначения. Перегруженные функции позволяют упростить программы, допуская обращение к одному имени для выполнения близких по смыслу действий.

Язык С++ позволяет создать несколько разных функций с одинаковым именем (функции-тезки), при этом функции отличаются:

• либо типом;
• либо числом своих аргументов;
• либо типом и числом аргументов.

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

Существует условие, которому обязаны удовлетворять функции-тезки – функции должны отличаться друг от друга списком параметров, а именно:

• типом или количеством параметров;
• тем и другим одновременно.

Например, рассмотрим следующие объявления перегруженных функций:

Int myFunction (int, int);

Int myFunction (long, long);

Int myFunction (long);

Функция myFunction перегружена с тремя различными списками параметров: первая и вторая отличаются типами параметров, а третья – типом и количеством.

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

Механизм перезагрузки функций необходим, например, тогда, когда требуется создать функцию, которая удваивает любое передаваемое ей значение. При этом необходимо иметь возможность передавать ей значения типа int, long, float или double. Без перегрузки функций пришлось бы создавать четыре различные функции:

int DblInt (int);

long DblLongt (long);

float DblInt (float);

double DblDouble (double);

С помощью же перегрузки функций достаточно использовать следующие объявления:

int Dbl (int); // объявление функции удвоения целых чисел

long Dbl (long); // объявление функции удвоения чисел типа long

float Dbl (float); // объявление функции удвоения чисел типа float

double Dbl (double); // объявление функции удвоения чисел типа double

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

Вышесказанное рассмотрим на примере. Здесь функция Dbl()перегружается для приема параметров четырех типов.

// полиморфизм функций

#include <iostream>

using namespace std;

// прототипы перегруженных функций

int Dbl (int);

long Dbl (long);

float Dbl (float);

double Dbl (double);

int main ()

{// инициализация переменных

int myInt = 6500;

long myLong=65000;

float myFloat=6.5F;

double myDouble=6.5e20;

// объявление переменных для хранения удвоенного значения

int doubledInt;

long doubledLong;

float doubldedFloat;

double doubledDouble;

// вывод на экран значений переменных

cout <<"myInt: "<<myInt<<"\n";

cout<<"myLong: "<<myLong<<"\n";

cout<<"myFloat: "<<myFloat<<"\n";

cout<<"myDouble: "<<myDouble<<"\n";

// вызов перегруженных функций и

// присвоение переменным возвращаемых ими значений

doubledInt = Dbl (myInt);

doubledLong = Dbl (myLong);

doubldedFloat = Dbl (myFloat);

doubledDouble = Dbl (myDouble);

//вывод значений

cout<<"doubleInt: "<<doubledInt<<"\n";

cout<<"doubleILong: "<<doubledLong<<"\n";

cout<<"doubleFloat: "<<doubldedFloat<<"\n";

cout<<"doubleDouble: "<<doubledDouble<<"\n";

return 0;

}

//определение функций

int Dbl (int original)

{

return 2*original;

}

long Dbl (long original)

{

return 2*original;

}

float Dbl (float original)

{

return 2*original;

}

double Dbl (double original)

{

return 2*original;

}

Результат:

myInt: 6500

myLong: 65000

myFloat: 6.5

myDouble: 6.5е+020

doubleInt: 13000

doubleILong: 130000

doubleFloat: 13

doubleDouble: 1.3е+021