Управляющие конструкции языка Си. Представление программ в виде функций. Работа с памятью. Структуры

Цикл for

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

for (инициализация; условие продолжения; итератор)
    тело цикла;

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

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

Рассмотрим пример суммирования массива с использованием цикла for:

double a[100]; // Массив a содержит не более 100 эл-тов
int n;         // Реальная длина массива a (n <= 100)
double sum;    // Переменная для суммы эл-тов массива
int i;         // Переменная цикла
. . .
sum = 0.0;
for (i = 0; i < n; ++i) {
    sum += a[i]; // Увеличиваем сумму на a[i]
}

Здесь целочисленная переменная i используется в качестве переменной цикла. В операторе инициализации переменной i присваивается значение 0. Условием продолжения цикла является условие i<n. Итератор ++i увеличивает переменную i на единицу. Таким образом, переменная i последовательно принимает значения 0, 1, 2,..., n-1. Для каждого значения i выполняется тело цикла.

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

for (инициализация; условие; итератор;)
{
    тело цикла;             
}

инициализация;
while (условие) {
    тело цикла;
}

Например, фрагмент с суммированием массива реализуется с использованием цикла while следующим образом:

for (i=0; i < n; ++i)
{
    sum += a[i];  
}

i = 0;
while (i < n) {
    sum += a[i];
   ++i;
}

В принципе, конструкция цикла for не нужна: она реализуется с помощью цикла while, он проще и понятнее. Однако большинство программистов продолжают использовать цикл for. Связано это, скорее всего, с традицией и привычками, поскольку в более ранних языках программирования, например, в первых версиях Фортрана, арифметический цикл был основным, а цикл while приходилось реализовывать с помощью операторов if и goto.

Операция "запятая" и цикл for

В цикле for

for (инициализация; условие продолжения; итератор)
    тело цикла;

в качестве инициализации и итератора можно использовать любые выражения, в частности, операцию присваивания = и операцию увеличения значения переменной на единицу ++. Как быть, если необходимо выполнить несколько действий при инициализации или в итераторе? Можно, конечно, использовать цикл while, но любители цикла for поступают другим образом. Для этого язык Си предоставляет операцию " запятая ", которая позволяет объединить несколько выражений в одно. У операции " запятая " два аргумента, которые вычисляются последовательно слева направо. Результатом операции является последнее вычисленное, т.е. правое, значение. Пример:

int x, y, z;
x = 5;
z = (y = x + 10, ++x);  // y = 15, x = 6, z = 6

Здесь при вычислении выражения в скобках сначала вычисляется первое подвыражение y = x+10, в результате которого в y записывается значение 15, значение первого подвыражения также равно 15. Затем вычисляется стоящее после запятой второе подвыражение ++x, в результате чего значение x увеличивается и становится равным 6, значение второго подвыражения также равно 6. Значением операции " запятая " является значение второго подвыражения, т.е. 6. В результате значение 6 присваивается переменной z.

Наличие операции " запятая " отражает эстетскую сторону первоначального варианта языка Cи 70-х годов XX века: в нем почти любая запись имела какой-то смысл. Позже программисты пришли к пониманию того, что надежность программы важнее краткости и изящества, и приняли более строгий ANSI -стандарт языка Си 1989 г., который несколько ограничил свободу творчества в области Си-программ.

Тем не менее, операцию " запятая " по-прежнему можно использовать в заголовке цикла for, когда нужно выполнить несколько действий при инициализации или в итераторе. Например, фрагмент суммирования массива

sum = 0.0;
for (i = 0; i < n; ++i) {
    sum += a[i];
}

можно переписать следующим "эстетским" образом:

for (sum = 0.0, i = 0; i < n; sum += a[i], ++i);

Здесь тело цикла вообще пустое, все действия вынесены в заголовок цикла! Лучше избегать такого стиля программирования: он ничего не добавляет в смысле эффективности готовой программы, но делает текст менее понятным и, таким образом, увеличивает вероятность ошибок.

Конструкции, которые лучше не использовать

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

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

Цикл do...while

Цикл do...while имеет вид

do
    действие;
while (условие);

Действие лучше всегда обрамлять фигурными скобками, даже когда оно состоит только из одного оператора, например,

do {
    x *= 2;
} while (x < n);

Цикл do...while является циклом с постусловием. Сначала выполняется тело цикла и только после этого проверяется условие продолжения цикла. Если условие истинно, то тело цикла повторяется, и так до бесконечности, пока условие не станет ложным. Таким образом, тело цикла выполняется всегда, даже если условие ложно с самого начала. Это является потенциальным источником ошибок. Лучше всегда использовать цикл с предусловием while (прежде чем прыгнуть, лучше сначала посмотреть, куда прыгаешь!).

Приведем пример ошибочного использования цикла do...while. Пусть переменная n содержит целое положительное число. Надо записать в целочисленную переменную p максимальную степень двойки, не превосходящую n. Ранее этот фрагмент уже был реализован с помощью цикла while (раздел 3.5.5):

int n, p;
. . .
p = 1;
while (2*p <= n) {
    p *= 2;
}

Попытка использовать цикл do...while может привести к ошибке:

int n, p;
. . .
p = 1;
do {
    p *= 2;
} while (2*p <= n);

Программа работает неверно при n = 1 (в переменную p записывается двойка вместо единицы), поскольку тело цикла do...while всегда выполняется один раз независимо от истинности условия, которое проверяется лишь после выполнения тела цикла. Такого рода ошибки в "крайних" ситуациях наиболее опасны в программировании: программа правильно работает почти во всех ситуациях, кроме нескольких исключений. Но известно, что большинство катастроф происходит как раз в результате исключительного стечения обстоятельств!

Оператор switch (вычисляемый goto)

Оператор switch имеет следующий вид:

switch (выражение) {
    case значение_1:
        фрагмент_1;
    case значение_2:
        фрагмент_2;
    case значение_3:
        фрагмент_3;
    . . .
    default:        // Необязательный фрагмент
        фрагмент_N;
}

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

1. сначала вычисляется значение выражения в заголовке switch ;
2. затем осуществляется переход на метку " case L:", где константа L совпадает с вычисленным значением выражения в заголовке;
3. если такого значения нет среди меток внутри тела switch, то
   • если есть метка " default:", то осуществляется переход на нее;
   • если метка " default:" отсутствует, то ничего не происходит.

Подчеркнем, что после перехода на метку " case L:" текст программы выполняется последовательно. Например, при выполнении фрагмента программы

int n, k;
n = 2;
switch (n) {
    case 1:
        k = 2;
    case 2:
        k = 4;
    case 3:
        k = 8;
}

переменной k будет присвоено значение 8, а не 4. Дело в том, что при переходе на метку " case 2:" будут выполнена сначала строка

k = 4;

и затем строка

k = 8;

что делает приведенный фрагмент совершенно бессмысленным (оптимизирующий компилятор вообще исключит строки " k = 2; " и " k = 4; " из кода готовой программы!). Чтобы исправить этот фрагмент, следует использовать оператор

break;

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

int n, k;
n = 2;
switch (n) {
    case 1:
        k = 2;
        break;
    case 2:
        k = 4;
        break;
    case 3:
        k = 8;
        break;
}

В результате выполнения этого фрагмента переменной k будет присвоено значение 4. Если бы значение n равнялось 1, то k было бы присвоено значение 2, если n равнялось бы 3, то 8. Если n не равно ни 1, ни 2, ни 3, то ничего не происходит.

Оператор switch иногда совершенно необосновано называют оператором выбора. На самом деле, для выбора следует использовать конструкцию if...else if..., см. раздел 3.5.3. Например, приведенный фрагмент лучше реализовать следующим образом:

if (n == 1) {
    k = 2;
}
else if (n == 2) {
    k = 4;
}
else if (n == 3) {
    k = 8;
}

Оператор switch по сути своей является оператором перехода goto с вычисляемой меткой. Ему присущи многие недостатки goto, например, проблемы с инициализацией локальных переменных при входе в блок. Кроме того, switch не позволяет записывать условия в виде логических выражений, что ограничивает сферу его применения. Рекомендуется никогда не использовать оператор switch: выбор в стиле if...else if... во всех отношениях лучше!