Такие выражения, как x=0, или i++, или printf(...), становятся операторами, если за ними следует точка с запятой, как, например,

 
     x = 0;
     i++;
     printf(...);

В языке "C" точка с запятой является признаком конца оператора, а не разделителем операторов, как в языках типа Алгола.

 
     if  (выражение)
             оператор-1
     else
             оператор-2,

Где часть else является необязательной. Сначала вычисляется выражение; если оно "истинно" (т.е. значение выражения отлично от нуля), то выполняется оператор-1. Если оно ложно (значение выражения равно нулю), и если есть часть с else, то вместо оператора-1 выполняется оператор-2.

Так как if просто проверяет численное значение выражения, то возможно некоторое сокращение записи. Самой очевидной возможностью является запись

  
    if  (выражение)

 
    if  (выражение !=0)

То, что часть else в конструкции if - else является необязательной, приводит к двусмысленности в случае, когда else опускается во вложенной последовательности операторов if. Эта неоднозначность разрешается обычным образом - else связывается с ближайшим предыдущим if, не содержащим else. Например, в

  
 if ( n > 0 )
    if( a > b )
            z = a;
    else
            z = b;

  
 if (n > 0)      {
    if (a > b)
            z = a;
 }
 else
    z = b;

Tакая двусмысленность особенно пагубна в ситуациях типа

  
 if (n > 0)
    for (i = 0; i < n; i++)
            if (s[i] > 0) {
     printf("...");
     return(i);
            }
 else   /* wrong */
    printf("ERROR - n is zero\n");

Между прочим, обратите внимание, что в

  
  if (a > b)
     z = a;
  else
     z = b;

3.3. else - if

Конструкция

  
  if (выражение)
     оператор
  else    if (выражение)
             оператор
  else    if (выражение)
             оператор
  else
     оператор

Последняя часть с else имеет дело со случаем, когда ни одно из проверяемых условий не выполняется. Иногда при этом не надо предпринимать никаких явных действий; в этом случае хвост

 
    else
       оператор

Для иллюстрации выбора из трех возможных вариантов приведем программу функции, которая методом половинного деления определяет, находится ли данное значение х в отсортированном массиве v. Элементы массива v должны быть расположены в порядке возрастания. Функция возвращает номер позиции (число между 0 и n-1), в которой значение х находится в v, и -1, если х не содержится в v.

  
 binary(x, v, n) /* find x in v[0]...v[n-1] */
 int x, v[], n;
 {
    int low, high, mid;
 
    low = 0;
    high = n - 1;
    while (low <= high) {
            mid = (low + high) / 2;
            if (x < v[mid])
     high = mid - 1;
            else if (x > v[mid])
     low = mid + 1;
            else   /* found match */
     return(mid);
    }
    return(-1);
 }

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

      
 main() /* count digits,white space, others */
 {
    int c, i, nwhite, nother, ndigit[10];
 
    nwhite = nother = 0;
    for (i = 0; i < 10; i++)
            ndigit[i] = 0;
 
    while ((c = getchar()) != EOF)
             switch(c) {
             case '0':
             case '1':
             case '2':
             case '3':
             case '4':
             case '5':
             case '6':
             case '7':
             case '8':
             case '9':
      ndigit[c-'0']++;
      break;
             case ' ':
             case '\n':
             case '\t':
      nwhite++;
      break;
             default :
      nother++;
      break;
             }
     printf("digits =");
     for (i = 0; i < 10; i++)
             printf(" %d", ndigit[i]);
     printf("\nwhite space = %d, other = %d\n",
             nwhite, nother);

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

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

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

Заведите привычку ставить оператор break после последнего случая (в данном примере после default), даже если это не является логически необходимым. В один прекрасный день, когда вы добавите в конец еще один случай, эта маленькая мера предосторожности избавит вас от неприятностей.

Упражнение 3-1.

Мы уже сталкивались с операторами цикла while и for. В конструкции

  
 while (выражение)
    оператор

Оператор

  
 for (выражение 1; выражение 2; выражение 3)
    оператор

  
 выражение 1;
 while (выражение 2) {
    оператор
    выражение 3;
 }

Грамматически все три компонента в for являются выражениями. наиболее распространенным является случай, когда выражение 1 и выражение 3 являются присваиваниями или обращениями к функциям, а выражение 2 - условным выражением. Любая из трех частей может быть опущена, хотя точки с запятой при этом должны оставаться. Если отсутствует выражение 1 или выражение 3, то оно просто выпадает из расширения. Если же отсутствует проверка, выражение 2, то считается, как будто оно всегда истинно, так что

  
  for (;;)        {
     ...
  }

  
 while ((c = getchar())== ' ' 
    || c == '\n' || c == '\t');    
         /* skip white space characters */

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

  
  for (i = 0; i < n; i++)

В качестве большего по размеру примера приведем другой вариант функции atoi, преобразующей строку в ее численный эквивалент. Этот вариант является более общим; он допускает присутствие в начале символов пустых промежутков и знака + или -. (В главе 4 приведена функция atof, которая выполняет то же самое преобразование для чисел с плавающей точкой).

Общая схема программы отражает форму поступающих данных:

• пропустить пустой промежуток, если он имеется
• извлечь знак, если он имеется
• извлечь целую часть и преобразовать ее

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

  
 atoi(s)   /* convert s to integer */
 char s[];
 {
 int i, n, sign;
 for(i=0; s[i]==' ' ||
          s[i]=='\n' || s[i]=='\t';i++)
    ; /* skip white space */
 sign = 1;
 if(s[i] == '+' || s[i] == '-')  /* sign */
    sign = (s[i++]=='+') ? 1 : - 1;
 for( n = 0; s[i] >= '0' && s[i] <= '9'; i++)
    n = 10 * n + s[i] - '0';
 return(sign * n);
 }

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

      
 shell(v, n)   /* sort v[0]...v[n-1]
                into increasing order */
 int v[], n;
 {
   int gap, i, j, temp;
 
   for (gap = n/2; gap > 0; gap /= 2)
      for (i = gap; i < n; i++)
   for (j=i-gap; j>=0 && v[j]>v[j+gap]; j-=gap) {
    temp = v[j];
    v[j] = v[j+gap];
    v[j+gap] = temp;
   }
 }

Здесь имеются три вложенных цикла. Самый внешний цикл управляет интервалом между сравниваемыми элементами, уменьшая его от n/2 вдвое при каждом проходе, пока он не станет равным нулю. Средний цикл сравнивает каждую пару элементов, разделенных на величину интервала; самый внутренний цикл переставляет любую неупорядоченную пару. Так как интервал в конце концов сводится к единице, все элементы в результате упорядочиваются правильно. Отметим, что в силу общности конструкции for внешний цикл укладывается в ту же самую форму, что и остальные, хотя он и не является арифметической прогрессией.

Последней операцией языка "C" является запятая ",", которая чаще всего используется в операторе for. Два выражения, разделенные запятой, вычисляются слева направо, причем типом и значением результата являются тип и значение правого операнда. Таким образом, в различные части оператора for можно включить несколько выражений, например, для параллельного изменения двух индексов. Это иллюстрируется функцией reverse(s), которая располагает строку s в обратном порядке на том же месте.

  
  reverse(s)    /* reverse string s in place */
  char s[];
  {
  int c, i, j;
 
  for(i = 0, j = strlen(s) - 1; i < j; i++, j--)  {
     c = s[i];
     s[i] = s[j];
     s[j] = c;
  }
  }

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

Упражнение 3-2.

Как уже отмечалось в главе 1, циклы while и for обладают тем приятным свойством, что в них проверка окончания осуществляется в начале, а не в конце цикла. Третий оператор цикла языка "C", do-while, проверяет условие окончания в конце, после каждого прохода через тело цикла; тело цикла всегда выполняется по крайней мере один раз. Синтаксис этого оператора имеет вид:

  
   do
      оператор
   while (выражение)

Сначала выполняется оператор, затем вычисляется выражение. Если оно истинно, то оператор выполняется снова и т.д. Если выражение становится ложным, цикл заканчивается.

Как и можно было ожидать, цикл do-while используется значительно реже, чем while и for, составляя примерно пять процентов от всех циклов. Тем не менее, иногда он оказывается полезным, как, например, в следующей функции itoa, которая преобразует число в символьную строку (обратная функции atoi). Эта задача оказывается несколько более сложной, чем может показаться сначала. Дело в том, что простые методы выделения цифр генерируют их в неправильном порядке. Мы предпочли получить строку в обратном порядке, а затем обратить ее.

      
 itoa(n,s)   /*convert n to characters in s */
 char s[];
 int n;
 {
 int i, sign;
 
 if ((sign = n) < 0)   /* record sign */
    n = -n;     /* make n positive */
 i = 0;
 do {    /* generate digits in reverse order */
    s[i++] = n % 10 + '0';/* get next digit */
 }   while ((n /=10) > 0); /* delete it */
 if (sign < 0)
    s[i++] = '-'
 s[i] = '\0';
 reverse(s);
 }

Цикл do-while здесь необходим, или по крайней мере удобен, поскольку, каково бы ни было значение n, массив s должен содержать хотя бы один символ. Мы заключили в фигурные скобки один оператор, составляющий тело do-while, хотя это и не обязательно, для того, чтобы торопливый читатель не принял часть while за начало оператора цикла while.

Упражнение 3-3.

При представлении чисел в двоичном дополнительном коде наш вариант itoa не справляется с наибольшим отрицательным числом, т.е. Со значением n равным -2 в степени m-1, где m - размер слова. объясните почему. Измените программу так, чтобы она правильно печатала это значение на любой машине.

Упражнение 3-4.

Напишите аналогичную функцию itob(n,s), которая преобразует целое без знака n в его двоичное символьное представление в s. Запрограммируйте функцию itoh, которая преобразует целое в шестнадцатеричное представление.

Упражнение 3-5.

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

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

  
  #define MAXLINE 1000
  main()    /* remove trailing blanks and tabs */
  {
  int n;
  char line[MAXLINE];
 
  while ((n = getline(line,MAXLINE)) > 0) {
   while (--n >= 0)
         if (line[n] != ' ' && line[n] != '\t'
         && line[n] != '\n')
               break;
   line[n+1] = '\0';
   printf("%s\n",line);
  }
  }

Функция getline возвращает длину строки. Внутренний цикл начинается с последнего символа line (напомним, что --n уменьшает n до использования его значения) и движется в обратном направлении в поиске первого символа, который отличен от пробела, табуляции или новой строки. Цикл прерывается, когда либо найден такой символ, либо n становится отрицательным (т.е., когда просмотрена вся строка). Советуем вам убедиться, что такое поведение правильно и в том случае, когда строка состоит только из символов пустых промежутков.

В качестве альтернативы к break можно ввести проверку в сам цикл:

  
 while ((n = getline(line,MAXLINE)) > 0) {
  while (--n >= 0
      && (line[n] == ' ' || line[n] == '\t'
      || line[n] == '\n'))
            ;
    ...
 }

Оператор continue родственен оператору break, но используется реже; он приводит к началу следующей итерации охватывающего цикла (for, while, do ). В циклах while и do это означает непосредственный переход к выполнению проверочной части; в цикле for управление передается на шаг реинициализации. (Оператор continue применяется только в циклах, но не в переключателях. Оператор continue внутри переключателя внутри цикла вызывает выполнение следующей итерации цикла).

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

  
 for (i = 0; i < n; i++) {
  if (a[i] < 0) /* skip negative elements */
        continue;
      ...  /* do positive elements */
 }

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

Упражнение 3-6.

В языке "C" предусмотрен и оператор goto, которым бесконечно злоупотребляют, и метки для ветвления. С формальной точки зрения оператор goto никогда не является необходимым, и на практике почти всегда можно обойтись без него. Мы не использовали goto в этой книге.

Тем не менее, мы укажем несколько ситуаций, где оператор goto может найти свое место. Наиболее характерным является его использование тогда, когда нужно прервать выполнение в некоторой глубоко вложенной структуре, например, выйти сразу из двух циклов. Здесь нельзя непосредственно использовать оператор break, так как он прерывает только самый внутренний цикл. Поэтому:

      
   for ( ... )
      for ( ... )    {
              ...
              if (disaster)
       goto ERROR;
      }
   ...
 
 ERROR:
    clean up the mess

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

В качестве другого примера рассмотрим задачу нахождения первого отрицательного элемента в двумерном массиве. (Многомерные массивы рассматриваются в главе 5). Вот одна из возможностей:

  
   for (i = 0; i < n; i++)
      for (j = 0; j < m; j++)
              if (v[i][j] < 0)
       goto found;
      /* didn't find */
   ...
 found:
   /* found one at positoin i, j */
   ...

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

  
 found = 0;
 for (i = 0; i < n && !found; i++)
    for (j = 0; j < m && !found; j++)
            found = v[i][j] < 0;
 if (found)
    /* it was at i-1, j-1 */
    ...
 else
    /* not found */
    ...

Хотя мы не являемся в этом вопросе догматиками, нам все же кажется, что если и нужно использовать оператор goto, то весьма умеренно.