Вы уже познакомились с базовыми алгоритмическими конструкциями, такими как ветвление, цикл и т.п. В этом уроке поговорим про алгоритмизацию. Такие же конструкции встречаются и в большинстве высокоуровневых языков программирования, в том числе и в языке С.
Управляющий оператор if
Простая форма оператора if
Оператор if — управляющий оператор языка С, реализующий ветвление алгоритма.
if (выражение)
    оператор1;
или
if (выражение)
{
    оператор1;
    оператор2;
}





Если выражение в скобках истинно, то оператор выполняется, в противном случае — пропускается. Оператор может быть простым или составным (блоком, выделенным с обеих сторон {}). Круглые скобки вокруг выражения обязательны.

Примеры:
if (x > max)
    max = x;
if (x < min || x > max)
{
     max *= 2;
     min /= 2;
}

Полная форма оператора if
if (выражение)
    оператор1;
else
    оператор2;




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

Пример:
​​​​​​​if (x != 0)
{
    y /= x;
}
else
{
     y = 0;
}
Возможны серии вложенных операторов if-else (как и любых других управляющих операторов, перечисленных далее), однако такая запись является не самой предпочтительной, так как ее сложно воспринимать человеческому глазу. При использовании вложенных операторов if-else, else связывается с ближайшим if.
if (c > ' ')
    if ( c >= '0' && c <= '9')
        ++digits;
     else
        ++non_digits;

ВАЖНО
Помните, что любой код пишется и поддерживается человеком,
поэтому старайтесь писать такой код, который легко
поддерживать и читать. Вместо вложенного if-else можно
воспользоваться управляющим оператором switch
Оператор switch
Оператор switch — управляющий оператор языка С, реализующий алгоритмическую структуру выбор.

Синтаксис оператора switch определен следующим образом:
switch (выражение)
{
     case const1: оператор;
     case const2: оператор;
     . . .
     default: оператор;
}

​​​​​​​

Выражение в скобках должно быть целого типа (можно использовать символьные константы, так как их тип целый). Выражение вычисляется и сравнивается с различными константами, записанными после ключевого слова case. Допускается использование констант целого или символьного типа или константное выражение указанных типов (например, 5, 'a', 2048/512). Если подходящая константа найдена, вычисления продолжаются с оператора, следующего за словом case, соответствующим этой константе. Затем выполняются все последующие операторы вплоть до появления оператора break или завершающей оператор switch скобки }. Метки case могут располагаться в любом порядке, но значения соответствующих констант должны быть различными.

switch, case, default и break — ключевые слова. Оператор break вызывает немедленный выход из оператора switch.

Метка default может отсутствовать. Если же она есть и среди указанных констант не найдено подходящей, управление передается операторам, следующим за меткой default. Если default отсутствует и среди указанных констант не найдено подходящей, оператор switch пропускается.

Если значение в операторе switch совпадает с одной из констант, вычисления продолжаются после соответствующей метки. Последующие операторы выполняются до тех пор, пока не встретится оператор break, независимо от того, предшествуют этим операторам какие-либо метки case. Говорят, что выполнение «проваливается», если не встретился оператор break. Распространенная ошибка состоит в пропуске оператора break, когда необходим выход из оператора switch.

Пример:
switch(x)
{
   case ‘a’:
   case ‘A’:
       y *= 5;
       break;
   case ‘b’:
   case ‘B’:
       y /= 3;
       break;
   default:
       y = 0;
}
Когда требуется использовать оператор switch, а когда конструкцию if-else? Нельзя применять оператор switch, когда выбор вариантов основан на вычислении значения переменной или выражения вещественного типа. Удобного способа применить оператор switch в случае, когда возможные значения переменной попадают в некоторый диапазон, также не существует. Проще написать, например, так:
​​​​​​​if (x < 1000 && x > 2)
При замене этой строки оператором switch придется ввести в программу метки для всех целых чисел от 3 до 999. Тем не менее, если есть возможность использования оператора switch, ею надо воспользоваться, если это позволит воспринимать код более удобно.
Оператор цикла while
Оператор цикла while — управляющий оператор языка С, реализующий выполнение цикла-пока в алгоритме. Синтаксис оператора цикла while определяется следующим образом:
while (выражение)
    оператор;
или
while (выражение)
{
     оператор;
}




Вычисляется выражение; если оно истинно (ненулевое), выполняется оператор. Выражение вычисляется снова и, если оно остается истинным, снова выполняется оператор, и т.д. Если выражение ложно, происходит выход из цикла. Как правило, значение выражения изменяется в результате выполнения некоторых действий в цикле. Оператор в цикле while выполняется 0 или более раз. Оператор может быть простым или составным (блоком). Частный случай простого оператора — пустой оператор.

Примеры:
size_t i = 1;
while (i <= 5)
{
    ++i;
}
size_t x = 0;
size_t y = 10;
while (x++ != y--)
    ; // нулевое выражение
Оператор цикла do-while
Оператор цикла do-while — управляющий оператор языка С, реализующий выполнение цикла-до в алгоритме.
Синтаксис оператора цикла do-while определяется следующим образом:
​​​​​​​do
   оператор;
while (выражение);
или
​​​​​​​do
{
    оператор;
}
while (выражение);
Цикл do-while похож на цикл while за исключением того, что значение выражения проверяется после выполнения оператора. Поэтому тело цикла выполняется как минимум один раз. Если значение выражения истинно, тело цикла выполняется повторно, выражение вновь вычисляется и т.д., до тех пор пока значение выражения не станет ложным. Оператор может быть как простым, так и составным.

Пример:
size_t num = 2;
size_t pow = 5;

do
{
    num *= num;
    --pow;
}
while (pow > 0);
Оператор цикла for
Оператор цикла for — управляющий оператор языка С, реализующий выполнение цикла «для» в алгоритме. Этот оператор очень удобен для представления счетных циклов, однако он может использоваться и для итерационных и поисковых циклов. Синтаксис оператора цикла for определяется следующим образом:
for (выражение1; выражение2; выражение3)
    оператор;
​​​​​​​

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

выражение2 цикла for всегда используется в качестве условия его окончания.

выражение1 часто применяется для инициализации переменных, а выражение3 для их изменения.

выражение1 вычисляется один раз при входе в цикл; выражение2 используется многократно как условие окончания; выражение3 вычисляется многократно после выполнения операторов тела цикла.

Оператор for эквивалентен следующей последовательности операторов:
выражение1;
while (выражение2)
{
оператор;
выражение3;
}
Преимущество синтаксиса оператора цикла for по сравнению с синтаксисом оператора цикла while заключается в том, что управляющие выражения цикла собраны вместе, что повышает удобочитаемость программы.

Пример:
size_t pow = 0;

for (size_t num = 1024; num > 0; num /= 2)
    ++pow;
Операторы break и continue
Операторы break и continue являются операторами передачи управления, не входящими в число базовых алгоритмических структур, на основании которых строятся структурные программы. Однако они используются достаточно часто.

Управляющий оператор break осуществляет немедленный выход из циклов while, do-while и for. Одиночный оператор break не может использоваться для выхода из более чем одного уровня вложения циклов. Оператор break может использоваться и для выхода из оператора switch.

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







Оператор goto
Управляющий оператор goto вызывает безусловный переход управления на выполнение оператора, перед которым указана соответствующая метка.
​​​​​​​goto метка;
Метка (label) — это идентификатор, завершаемый двоеточием, который помечает оператор.
​​​​​​​метка: оператор;
Метки видны только внутри своей функции (о функциях поговорим далее).
Часто говорят, что структурное программирование — это программирование без goto. Строго говоря, в этом операторе нет никакой необходимости. Оператор goto можно использовать только для выхода из глубоко вложенных циклов. В противном случае использование goto делает структуру программы запутанной и трудной для отладки. На использование оператора goto провоцирует плохо продуманный алгоритм.

Пример:
// goto можно использовать, чтобы легко выйти из многоуровневого цикла
for (int x = 0; x < 3; ++x)
{
   for (int y = 0; y < 3; ++y)
    {
      if (x + y >= 3)
          goto endloop;
    }
}
endloop:;
Функции
Функция — это именованный фрагмент программы. Данные могут передаваться в функцию и функция может возвращать данные. Функция состоит из составного оператора (тела функции) и идентификатора (имени функции).
// Определение функции.
// Определяет функцию с именем “sum” и телом “{ return x+y; }”
int sum(int x, int y)
{
     return x + y;
}
Функция может принимать 0 или более параметров, которые инициализируются из аргументов оператора вызова функции, и может возвращать значение в блок ее вызова с помощью оператора return.
int n = sum(1, 2); // параметры x и y инициализируются аргументами 1 и 2
ВАЖНО
Комбинацию из имени функции, списка аргументов и возвращаемого\
значения называют прототипом функции
Тело функции предоставляется в определении функции. Каждая функция должна быть определена только 1 раз на всю программу, если только она не является inline-функцией.

Вложенные функции по стандарту недопустимы.
ВАЖНО
​​​​​​​Функции не имеют доступа к локальным переменным из области ее вызова.
Переданные аргументы по факту являются копиями этих локальных переменных, то есть не зависят от них.
Объявление функции
Объявление функции используется для предоставления информации об имени функции, типе возвращаемого значения и списка аргументов в текущей области видимости. Это крайне полезно для модульной структуризации программы, так как любая вызывающая функция должна быть проинформирована о виде вызываемой функции (то есть, должна знать ее прототип).
Объявление может быть сделано перед вызывающей функцией или внутри ее.

Например, объявление функции sum, определенной выше, будет выглядеть так:
​​​​​​​int sum(int x, int y);
Имея такую запись в текущем файле и определение — в другом, можно осуществлять вызов функции.

Возможно, сейчас это кажется немного избыточным, но на практике будет понятно, почему это удобно.
Назначение стека при вызове функции
Стек — это область памяти, используемая выполняемой программой для временного запоминания значений.
При вызове функции происходит следующее:
Все значения передаваемых аргументов функции помещаются на стек. Затем запоминаются значения существенных регистров
Управление передается вызванной функции. Значения аргументов связываются с соответствующими областями памяти на стеке, выделенными под формальные параметры, указанные в прототипе функции
Затем определяется расположение на стеке для локальных переменных
Этот набор параметров, регистров и автоматических переменных для вызова функции называется кадром (frame). Если вызванная функция выполняет вызов другой функции, на стек помещается еще один кадр. Только один кадр является активным в любой момент времени. Активная часть стека «растет» при вызове функции и «сокращается» при выходе из функции. Стековое пространство все время повторно используется, и это является причиной того, почему автоматические переменные имеют до инициализации неопределенные значения. Они зависят от того, какие значения запоминались в соответствующем месте памяти до данного вызова функции.

Проще рассмотреть этот механизм на примере.
float g(double val)
{
    int count;
    . . .
}

int f(int x, int sum)
{
    double total;
    g(20.5);
    . . .
}

int main()
{
    int x = 10;
    int y = 100;
    f(5, 10);
    . . .
}




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

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

Примеры:
​​​​​​​int func1(void)
{
    ...
    if (n==0 || n==1)
        return 1;
    else
        return 0;
}
Функция func1() возвращает значение целого типа.
void func2(void)
{
    ...
    return;
}
Функция func2() не возвращает никакого значения.
Рекурсивные функции
Функция в языке программирования С может быть рекурсивной, т.е. может вызывать сама себя. Каждый раз, когда функция вызывает себя, на стек помещается новый кадр. Функция должна вызывать себя условно, например, внутри оператора if, иначе бесконечная рекурсия переполнит стек.

Следующий пример позволяет вычислить факториал числа 5, используя рекурсию:
​​​​​​​int factorial(int num);
int main()
{
    int num = 5;
    int fact = factorial(num);
}

int factorial(int num)
{
    if (num == 0)
    {
        return 0;
    }
    else if (num == 1)
    {
        return 1;
    }
    else
    {
        return num * factorial(num - 1);
    }
}
Точки входа / выхода программы
Каждая программа на С начинает свое выполнение из функции с именем main, которая либо завершается, либо вызывает другие функции. Выйдя из функции main, программа завершается. Функция main вызывается операционной системой в тот момент, когда пользователь запускает программу.
int main (void) { body }
int main (int argc, char *argv[]) { body }

У функции main есть свои параметры, инициализируемые ОС при старте:
argc — неотрицательное значение, отражающее количество аргументов, переданное программе из того окружения, в котором она запущена.
argv — список переданных аргументов, начиная с имени программы.
​​​​​​​

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