1.50.

    /* Алгоритм быстрой сортировки. Работа алгоритма "анимируется"
     * (animate-оживлять) при помощи библиотеки curses.
     *      cc -o qsort qsort.c -lcurses -ltermcap
     */
    #include "curses.h"
    #define N 10     /* длина массива */
    /* массив, подлежащий сортировке */
    int target [N] = {
            7, 6, 10, 4, 2,
            9, 3,  8, 5, 1
    };
    int maxim;      /* максимальный элемент массива */
    /* quick sort */
    qsort (a, from, to)
            int a[];      /* сортируемый массив */
            int from;     /* левый начальный индекс */
            int to;       /* правый конечный индекс */
    {
            register i, j, x, tmp;
            if( from >= to ) return;
            /* число элементов <= 1 */
            i = from; j = to;
            x = a[ (i+j) / 2 ];     /* значение из середины */
            do{
                    /* сужение вправо */
                    while( a[i] < x ) i++ ;
                    /* сужение влево */
                    while( x < a[j] ) j--;
                    if( i <= j ){   /* обменять */
                            tmp = a[i]; a[i] = a[j] ; a[j] = tmp;
                            i++;  j--;
                            demochanges();  /* визуализация */
                    }
            } while( i <= j );
            /* Теперь обе части сошлись в одной точке.
             * Длина левой части = j - from + 1
             *       правой      = to - i   + 1
             * Все числа в левой части меньше всех чисел в правой.
             * Теперь надо просто отсортировать каждую часть в отдельности.
             * Сначала сортируем более короткую (для экономии памяти
             * в стеке ). Рекурсия:
             */
            if( (j - from)  <  (to - i) ){
                    qsort( a, from, j );
                    qsort( a, i, to   );
            } else {
                    qsort( a, i,   to );
                    qsort( a, from, j );
            }
    }
    int main (){
            register i;
            initscr();      /* запуск curses-а */
            /* поиск максимального числа в массиве */
            for( maxim = target[0], i = 1 ;  i < N ; i++ )
                    if( target[i] > maxim )
                        maxim = target[i];
            demochanges();
            qsort( target, 0, N-1 );
            demochanges();
            mvcur( -1, -1, LINES-1, 0);
            /* курсор в левый нижний угол */
            endwin();       /* завершить работу с curses-ом */
            return 0;
    }
    #define GAPY  2
    #define GAPX 20
    /* нарисовать картинку */
    demochanges(){
            register i, j;
            int h = LINES - 3 * GAPY - N;
            int height;
            erase();        /* зачистить окно */
            attron( A_REVERSE );
            /* рисуем матрицу упорядоченности */
            for( i=0 ; i < N ; i++ )
                    for( j = 0; j < N ; j++ ){
                        move( GAPY + i , GAPX + j * 2 );
                        addch( target[i] >= target[j] ? '*' : '.' );
                        addch( ' ' );
                        /* Рисовать '*' если элементы
                         * идут в неправильном порядке.
                         * Возможен вариант проверки target[i] > target[j]
                         */
                    }
            attroff( A_REVERSE );
            /* массив */
            for( i = 0 ; i < N ; i++ ){
                    move( GAPY + i , 5 );
                    printw( "%4d", target[i] );
                    height = (long) h * target[i] / maxim ;
                    for( j = 2 * GAPY + N + (h - height) ;
                                          j < LINES - GAPY; j++ ){
                            move( j, GAPX + i * 2 );
                            addch( '|' );
                    }
            }
            refresh();      /* проявить картинку */
            sleep(1);
    }

1.51.

Реализуйте приведенный фрагмент программы без использования оператора goto и без меток.

            if ( i > 10 ) goto M1;
            goto M2;
            M1: j = j + i; flag = 2; goto M3;
            M2: j = j - i; flag = 1;
            M3:       ;

Заметьте, что помечать можно только оператор (может быть пустой); поэтому не может встретиться фрагмент

    { ..... Label:  }  а только { ..... Label: ; }

1.52.

Ответ: при выходе из вложенных циклов, т.к. оператор break позволяет выйти только из самого внутреннего цикла (на один уровень).

1.53.

    if(...) ... if(...) ... else ...

Вообще же лучше явно расставлять скобки (для ясности):

    if(...){ ... if(...) ...   else ... }
    if(...){ ... if(...) ... } else ...

1.54.

Макроопределение, чье тело представляет собой последовательность операторов в {...} скобках (блок), может вызвать проблемы при использовании его в условном операторе if с else-частью:

    #define MACRO   { x=1; y=2; }
    if(z)   MACRO;
    else    .......;

    if(z)   { x=1; y=2; } /* конец if-а */ ;
    else    .......;      /* else ни к чему не относится */

    if(...)  один_оператор;
    else     .....
             либо
    if(...){ последовательность; ...; операторов; }
    else     .....

    #define MACRO do{ x=1; y=2; }while(0)

    if(z)   do{ x=1; y=2; }while(0);
    else    .......;

1.55.

    int  x = 12;
         if( x < 20 and x > 10 ) printf( "O'K\n");
    else if( x > 100 or x < 0  ) printf( "Bad x\n");
    else                         printf( "x=%d\n", x);

    #define and &&
    #define or  ||

1.56.

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

    int i = 0;
    char *s = "   3 spaces";
    while(*s == ' ' || *s++ == '\t')
            printf( "Пробел %d\n", ++i);

Ответ: логические операции || и && выполняются слева направо; как только какое-то условие в || оказывается истинным (а в && ложным) - дальнейшие условия просто не вычисляются. В нашем случае условие *s==' ' сразу же верно, и операция s++ из второго условия не выполняется! Мы должны были написать хотя бы так:

    while(*s == ' ' || *s == '\t'){
            printf( "Пробел %d\n", ++i); s++;
    }

    if( x != 0.0 && y/x < 1.0 ) ... ;

Если бы мы не вставили проверку на 0, мы могли бы получить деление на 0. В данном же случае при x==0 деление просто не будет вычисляться. Вот еще пример:

    int a[5], i;
    for(i=0; i < 5 && a[i] != 0; ++i) ...;

Если i выйдет за границу массива, то сравнение a[i] с нулем уже не будет вычисляться, т.е. попытки прочесть элемент не входящий в массив не произойдет.

Это свойство && позволяет писать довольно неочевидные конструкции, вроде

    if((cond) && f());
        что оказывается эквивалентным
    if( cond ) f();

    if(C1 && C2 && C3) DO;
            эквивалентно
    if(C1) if(C2) if(C3) DO;

    if(C1 || C2 || C3) DO;
            эквивалентно
         if(C1) goto ok;
    else if(C2) goto ok;
    else if(C3){ ok: DO; }

    #include <stdio.h>
    main(argc, argv) int argc; char *argv[];
    {  FILE *fp;
       if(argc < 2 || (fp=fopen(argv[1], "r")) == NULL){
            fprintf(stderr, "Плохое имя файла\n");
            exit(1); /* завершить программу */
       }
       ...
    }

Если argc==1, то argv[1] не определено, однако в этом случае попытки открыть файл с именем argv[1] просто не будет предпринято!

Ниже приведен еще один содержательный пример, представляющий собой одну из возможных схем написания "двуязычных" программ, т.е. выдающих сообщения на одном из двух языков по вашему желанию. Проверяется переменная окружения MSG (или LANG):

                                    ЯЗЫК:
    1)  "MSG=engl"                английский
    2)   MSG нет в окружении      английский
    3)  "MSG=rus"                 русский

    #include <stdio.h>
    int _ediag = 0; /* язык диагностик: 1-русский */
    extern char *getenv(), *strchr();
    #define ediag(e,r) (_ediag?(r):(e))
    main(){  char *s;
    _ediag = ((s=getenv("MSG"))   != NULL   &&
               strchr("rRрР", *s) != NULL);
    printf(ediag("%d:english\n", "%d:русский\n"), _ediag);
    }

Если переменная MSG не определена, то s==NULL и функция strchr(s,...) не вызывается (ее первый фргумент не должен быть NULL-ом). Здесь ее можно было бы упрощенно заменить на *s=='r'; тогда если s равно NULL, то обращение *s было бы незаконно (обращение по указателю NULL дает непредсказуемые результаты и, скорее всего, вызовет крах программы).

1.57.

    a && b     =     ! ( !a || !b )
    a || b     =     ! ( !a && !b )

    ! !a       =     a
    ! (a == b) =    (a != b)

    if( c != 'a' && c != 'b' && c != 'c' )...;
            превращается в
    if( !(c == 'a' || c == 'b' || c == 'c')) ...;

1.58.

Пример, в котором используются побочные эффекты вычисления выражений. Обычно значение выражения присваивается некоторой переменной, но это не необходимо. Поэтому можно использовать свойства вычисления && и || в выражениях (хотя это не есть самый понятный способ написания программ, скорее некоторый род извращения). Ограничение тут таково: все части выражения должны возвращать значения.

    #include <stdio.h>
    extern int errno;       /* код системной ошибки */
    FILE *fp;
    int openFile(){
            errno = 0;
            fp = fopen("/etc/inittab", "r");
            printf("fp=%x\n", fp);
            return(fp == NULL ? 0 : 1);
    }
    int closeFile(){
            printf("closeFile\n");
            if(fp) fclose(fp);
            return 0;
    }
    int die(int code){
            printf("exit(%d)\n", code);
            exit(code);
            return 0;
    }
    void main(){
            char buf[2048];
            if( !openFile()) die(errno); closeFile();
            openFile()    || die(errno); closeFile();
              /* если файл открылся, то die() не вычисляется */
            openFile() ? 0 : die(errno); closeFile();
            if(openFile()) closeFile();
            openFile()  && closeFile();
              /* вычислить closeFile() только если openFile() удалось */
            openFile()  && (printf("%s", fgets(buf, sizeof buf, fp)), closeFile());
    }

1.59.

1.60.

1.61.

    for ( i = 36; i > 0; i /= 2 )
          printf ( "%d%s", i,
                           i==1 ? ".\n":", ");

1.62.

    main {
         int i, j, k(10);
         for ( i = 0, i <= 10, i++   ){
               k[i] = 2 * i + 3;
               for ( j = 0, j <= i, j++ )
                     printf ("%i\n", k[j]);
         }
    }

Обратите внимание на формат %i, существует ли такой формат? Есть ли это тот формат, по которому следует печатать значения типа int?

1.63.

Напишите программу, которая распечатывает элементы массива. Напишите программу, которая распечатывает элементы массива по 5 чисел в строке.

1.64.

Составьте программу считывания строк символов из стандартного ввода и печати номера введенной строки, адреса строки в памяти ЭВМ, значения строки, длины строки.

1.65.

Стилистическое замечание: в операторе return возвращаемое выражение не обязательно должно быть в ()-скобках. Дело в том, что return - не функция, а оператор.

    return  выражение;
    return (выражение);

Однако если вы вызываете функцию (например, exit) - то аргументы должны быть в круглых скобках: exit(1); но не exit 1;

1.66.

Избегайте ситуации, когда функция в разных ветвях вычисления то возвращает некоторое значение, то не возвращает ничего:

    int func (int x) {
        if( x > 10  ) return x*2;
        if( x == 10 ) return (10);
        /* а здесь - неявный return; без значения */
    }

1.67.

Напишите программу, запрашивающую ваше имя и "приветствующую" вас. Напишите функцию чтения строки. Используйте getchar() и printf().

Ответ:

    #include <stdio.h>  /* standard input/output */
    main(){
       char buffer[81]; int i;
       printf( "Введите ваше имя:" );
       while((i = getstr( buffer, sizeof buffer )) != EOF){
              printf( "Здравствуй, %s\n", buffer );
              printf( "Введите ваше имя:" );
       }
    }
    getstr( s, maxlen )
     char *s;    /* куда поместить строку */
     int maxlen; /* длина буфера:
                    макс. длина строки = maxlen-1 */
    {  int c;    /* не char! (почему ?) */
       register int i = 0;
       maxlen--; /* резервируем байт под конечный '\0' */
       while(i < maxlen && (c = getchar()) != '\n'
                        &&  c != EOF )
              s[i++] = c;
       /* обратите внимание, что сам символ '\n'
        * в строку не попадет */
       s[i] = '\0';  /* признак конца строки */
       return (i == 0 && c == EOF) ? EOF : i;
       /* вернем длину строки  */
    }

      fgetstr(buffer,sizeof(buffer),stdin);

    char *fgetstr(char *s, int maxlen, register FILE *fp){
      register c; register char *cs = s;
      while(--maxlen > 0 && (c = getc(fp)) != EOF){
        if(c == '\n') break;  /* @1 */
        *cs++ = c;            /* @2 */
      }
      if(c == EOF && cs == s) return NULL;
      /* Заметьте, что при EOF строка s не меняется! */
      *cs = '\0'; return s;
    }

Исследуйте поведение этих функций, когда входная строка слишком длинная (длиннее maxlen). Замечание: вместо нашей "рукописной" функции getstr() мы могли бы использовать стандартную библиотечную функцию gets(buffer).

1.68.

Объясните, почему d стало отрицательным и почему %X печатает больше F, чем в исходном числе? Пример выполнялся на 32-х битной машине.

    main(){
      unsigned short u = 65535;  /* 16 бит: 0xFFFF */
               short d = u;      /* 15 бит + знаковый бит */
      printf( "%X %d\n", d, d);  /* FFFFFFFF -1 */
    }

1.69.

    main()
    {
      /*signed*/ char c  = 128; /* биты: 10000000 */
      unsigned   char uc = 128;
      int  d = c;   /* используется 32-х битный int */
      printf( "%d %d %x\n", c, d, d );
      /*       -128 -128 ffffff80 */
           d = uc;
      printf( "%d %d %x\n", uc, d, d );
      /*       128 128 80       */
    }

Ответ: при приведении char к int расширился знаковый бит (7-ой), заняв всю старшую часть слова. Знаковый бит int-а стал равен 1, что является признаком отрицательного числа. То же будет происходить со всеми значениями c из диапазона 128..255 (содержащими бит 0200). При приведении unsigned char к int знаковый бит не расширяется.

Можно было поступить еще и так:

    printf( "%d\n", c & 0377 );

Здесь c приводится к типу int (потому что при использовании в аргументах функции тип char ВСЕГДА приводится к типу int), затем &0377 занулит старший байт полученного целого числа (состоящий из битов 1), снова превратив число в положительное.

© Copyright А. Богатырев, 1992-95
Си в UNIX