1. Простые программы и алгоритмы. Сюрпризы, советы.

1.1. Составьте программу приветствия с использованием функции printf. По традиции принято печатать фразу "Hello, world !" ("Здравствуй, мир !").

1.2. Найдите ошибку в программе

    #include <stdio.h>
    main(){
        printf("Hello, world\n");
    }

Ответ: раз не объявлено иначе, функция main считается возвращающей целое значение (int). Но функция main не возвращает ничего - в ней просто нет оператора return.

Корректно было бы так:

    #include <stdio.h>
    main(){
        printf("Hello, world\n");
        return 0;
    }

    #include <stdio.h>
    void main(){
        printf("Hello, world\n");
        exit(0);
    }

    #include <stdio.h>
    int main(int argc, char *argv[]){
        printf("Hello, world\n");
        return 0;
    }

1.3. Найдите ошибки в программе

        #include studio.h
        main
        {
            int i
            i := 43
            print ('В году i недель')
        }

1.4. Что будет напечатано в приведенном примере, который является частью полной программы:

            int n;
            n = 2;
            printf ("%d + %d = %d\n", n, n, n + n);

1.5. В чем состоят ошибки?

            if( x > 2 )
            then    x = 2;
            if  x < 1
                    x = 1;

1.6.Напишите программу, печатающую ваше имя, место работы и адрес. В первом варианте программы используйте библиотечную функцию printf, а во втором - puts.

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

            a = b = 5
            a + b
            a++ + b
            ++a + b
            --a + b
            a-- + b

1.8. Цикл for

         for(INIT; CONDITION; INCR)
                 BODY
                 INIT;
         repeat:
                 if(CONDITION){
                         BODY;
                 cont:
                         INCR;
                         goto repeat;
                 }
         out:    ;

         while(COND)
                 BODY
         cont:
         repeat:
                 if(CONDITION){
                         BODY;
                         goto repeat;
                 }
         out:    ;

         do
                 BODY
         while(CONDITION)
         cont:
         repeat:
                 BODY;
                 if(CONDITION) goto repeat;
         out:    ;

В операторах цикла внутри тела цикла BODY могут присутствовать операторы break и continue; которые означают на наших схемах следующее:

         #define break     goto out
         #define continue  goto cont

1.9. Составьте программу печати прямоугольного треугольника из звездочек

              *
              **
              ***
              ****
              *****

1.10.Напишите операторы Си, которые выдают строку длины WIDTH, в которой сначала содержится x0 символов '-', затем w символов '*', и до конца строки - вновь символы '-'. Ответ:

    int x;
    for(x=0; x < x0;     ++x) putchar('-');
    for(   ; x < x0 + w; x++) putchar('*');
    for(   ; x < WIDTH ; ++x) putchar('-');
    putchar('\n');

    for(x=0; x < WIDTH; x++)
            putchar( x < x0     ? '-' :
                     x < x0 + w ? '*' :
                                  '-' );
    putchar('\n');

1.11.Напишите программу с циклами, которая рисует треугольник:

                    *
                   ***
                  *****
                 *******
                *********

    /* Треугольник из звездочек */
    #include <stdio.h>
    /* Печать n символов c */
    printn(c, n){
            while( --n >= 0 )
                    putchar(c);
    }
    int lines = 10;         /* число строк треугольника */
    void main(argc, argv) char *argv[];
    {
            register int nline;  /* номер строки */
            register int naster; /* количество звездочек в строке */
            register int i;
            if( argc > 1 )
                    lines = atoi( argv[1] );
            for( nline=0; nline < lines ; nline++ ){
                    naster = 1 + 2 * nline;
                    /* лидирующие пробелы */
                    printn(' ', lines-1  - nline);
                    /* звездочки */
                    printn('*', naster);
                    /* перевод строки */
                    putchar( '\n' );
            }
            exit(0);        /* завершение программы */
    }

1.12. В чем состоит ошибка?

    main(){  /* печать фразы 10 раз */
       int i;
       while(i < 10){
           printf("%d-ый раз\n", i+1);
           i++;
       }
    }

Ответ: автоматическая переменная i не была проинициализирована и содержит не 0, а какое-то произвольное значение. Цикл может выполниться не 10, а любое число раз (в том числе и 0 по случайности). Не забывайте инициализировать переменные, возьмите описание с инициализацией за правило!

       int i = 0;

В данном примере было бы еще лучше использовать цикл for, в котором все операции над индексом цикла собраны в одном месте - в заголовке цикла:

    for(i=0; i < 10; i++) printf(...);

1.13. Вспомогательные переменные, не несущие смысловой нагрузки (вроде счетчика повторений цикла, не используемого в самом теле цикла) принято по традиции обозначать однобуквенными именами, вроде i, j. Более того, возможны даже такие курьезы:

    main(){
      int  _ ;
      for( _ = 0; _ < 10; _++) printf("%d\n", _ );
    }

1.14. Найдите 2 ошибки в программе:

            main(){
                    int x = 12;
                    printf( "x=%d\n" );
                    int y;
                    y = 2 * x;
                    printf( "y=%d\n", y );
            }

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

1.15. Найдите ошибку:

    int n;
    n = 12;
    main(){
            int y;
            y = n+2;
            printf( "%d\n", y );
    }

Ответ: выполняемый оператор n=12 находится вне тела какой-либо функции. Следует внести его в main() после описания переменной y, либо переписать объявление перед main() в виде

    int n = 12;

В последнем случае присваивание переменной n значения 12 выполнит компилятор еще во время компиляции программы, а не сама программа при своем запуске. Точно так же происходит со всеми статическими данными (описанными как static, либо расположенными вне всех функций); причем если их начальное значение не указано явно - то подразумевается 0 ('\0', NULL, ""). Однако нулевые значения не хранятся в скомпилированном выполняемом файле, а требуемая "чистая" память расписывается при старте программы.

1.16. По поводу описания переменной с инициализацией:

    TYPE x = выражение;

    TYPE x;         /* описание */
    x = выражение;  /* вычисление начального значения */

    #include <stdio.h>
    extern double sqrt();   /* квадратный корень */
    double x   = 1.17;
    double s12 = sqrt(12.0);            /* #1 */
    double y   = x * 2.0;               /* #2 */
    FILE  *fp  = fopen("out.out", "w"); /* #3 */
    main(){
      double ss = sqrt(25.0) + x;       /* #4 */
      ...
    }

Ответ: при инициализации статических данных (а s12, y и fp таковыми и являются, так как описаны вне какой-либо функции) выражение должно содержать только константы, поскольку оно вычисляется КОМПИЛЯТОРОМ. Поэтому ни использование значений переменных, ни вызовы функций здесь недопустимы (но можно брать адреса от переменных).

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

1.17. Напишите программу, реализующую эхо-печать вводимых символов. Программа должна завершать работу при получении признака EOF. В UNIX при вводе с клавиатуры признак EOF обычно обозначается одновременным нажатием клавиш CTRL и D (CTRL чуть раньше), что в дальнейшем будет обозначаться CTRL/D; а в MS DOS - клавиш CTRL/Z. Используйте getchar() для ввода буквы и putchar() для вывода.

1.18. Напишите программу, подсчитывающую число символов поступающих со стандартного ввода. Какие достоинства и недостатки у следующей реализации:

    #include <stdio.h>
    main(){ double cnt = 0.0;
            while (getchar() != EOF) ++cnt;
            printf("%.0f\n", cnt );
    }

Ответ: и достоинство и недостаток в том, что счетчик имеет тип double. Достоинство можно подсчитать очень большое число символов; недостаток - операции с double обычно выполняются гораздо медленнее, чем с int и long (до десяти раз), программа будет работать дольше. В повседневных задачах вам вряд ли понадобится иметь счетчик, отличный от long cnt; (печатать его надо по формату "%ld").

1.19. Составьте программу перекодировки вводимых символов со стандартного ввода по следующему правилу:

            a -> b
            b -> c
            c -> d
            ...
            z -> a
     другой символ -> *

1.20. Составьте программу перекодировки вводимых символов со стандартного ввода по следующему правилу:

            B -> A
            C -> B
            ...
            Z -> Y
     другой символ -> *

1.21. Напишите программу, печатающую номер и код введенного символа в восьмеричном и шестнадцатеричном виде. Заметьте, что если вы наберете на вводе строку символов и нажмете клавишу ENTER, то программа напечатает вам на один символ больше, чем вы набрали. Дело в том, что код клавиши ENTER, завершившей ввод строки - символ '\n' тоже попадает в вашу программу (на экране он отображается как перевод курсора в начало следующей строки!).

1.22. Разберитесь, в чем состоит разница между символами '0' (цифра нуль) и '\0' (нулевой байт). Напечатайте

      printf( "%d %d %c\n", '\0', '0', '0' );

    main(){
            int c = 060;  /* код символа '0' */
            printf( "%c %d %o\n", c, c, c);
    }

    int c = 060;

    char c = '0';

1.23. Что напечатает программа?

    #include <stdio.h>
    void main(){
            printf("ab\0cd\nxyz");
            putchar('\n');
    }

    'a','b','c','d','\n','\0'

    'a','b','\0','c','d','\n','x','y',z','\0'

Что строка "abcd\0" - избыточна, поскольку будет иметь на конце два нулевых байта (что не вредно, но зачем?). Что printf печатает строку до нулевого байта, а не до закрывающей кавычки. Программа эта напечатает ab и перевод строки.

Вопрос: чему равен sizeof("ab\0cd\nxyz")? Ответ: 10.

1.24. Напишите программу, печатающую целые числа от 0 до 100.

1.25. Напишите программу, печатающую квадраты и кубы целых чисел.

1.26. Напишите программу, печатающую сумму квадратов первых n целых чисел.

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

1.28. Напишите программу, переводящую скорость из километров в час в метры в секундах.

1.29. Напишите программу, шифрующую текст файла путем замены значения символа (например, значение символа C заменяется на C+1 или на ~C ).

1.30.

Напишите программу, которая при введении с клавиатуры буквы печатает на терминале ключевое слово, начинающееся с данной буквы. Например, при введении буквы 'b' печатает "break".

1.31.

Напишите программу, отгадывающую задуманное вами число в пределах от 1 до 200, пользуясь подсказкой с клавиатуры "=" (равно), "<" (меньше) и ">" (больше). Для угадывания числа используйте метод деления пополам.

1.32. Напишите программу, печатающую степени двойки

            1, 2, 4, 8, ...

1.33.

Напишите подпрограмму вычисления квадратного корня с использованием метода касательных (Ньютона):

       x(0)   =  a
                 1      a
       x(n+1) =  - * ( ----  + x(n))
                 2     x(n)

Внимание! В данной задаче массив не нужен. Достаточно хранить текущее и предыдущее значения x и обновлять их после каждой итерации.

1.34. Напишите программу, распечатывающую простые числа до 1000.

            1, 2, 3, 5, 7, 11, 13, 17, ...
    /*#!/bin/cc primes.c -o primes -lm
     *        Простые числа.
     */
    #include <stdio.h>
    #include <math.h>
    int debug = 0;
    /* Корень квадратный из числа по методу Ньютона */
    #define eps 0.0001
    double  sqrt (x) double x;
    {
        double  sq, sqold, EPS;
        if (x < 0.0)
            return -1.0;
        if (x == 0.0)
            return 0.0;  /* может привести к делению на 0 */
        EPS = x * eps;
        sq = x;
        sqold = x + 30.0;         /* != sq */
        while (fabs (sq * sq - x) >= EPS) {
        /*     fabs( sq - sqold )>= EPS    */
            sqold = sq;
            sq = 0.5 * (sq + x / sq);
        }
        return sq;
    }
    /* таблица прoстых чисел */
    int is_prime (t) register int    t; {
        register int    i, up;
        int             not_div;
        if (t == 2 || t == 3 || t == 5 || t == 7)
            return 1;               /* prime */
        if (t % 2 == 0 || t == 1)
            return 0;               /* composite */
        up = ceil (sqrt ((double) t)) + 1;
        i = 3;
        not_div = 1;
        while (i <= up && not_div) {
            if (t % i == 0) {
                if (debug)
                    fprintf (stderr, "%d поделилось на %d\n",
                                       t,               i);
                not_div = 0;
                break;
            }
            i += 2;  /*
                      * Нет смысла проверять четные,
                      * потому что если делится на 2*n,
                      * то делится и на 2,
                      * а этот случай уже обработан выше.
                      */
        }
        return not_div;
    }
    #define COL 6
    int     n;
    main (argc, argv) char **argv;
    {
        int     i,
                j;
        int     n;
        if( argc < 2 ){
            fprintf( stderr, "Вызов: %s число [-]\n", argv[0] );
            exit(1);
        }
        i = atoi (argv[1]); /* строка -> целое, ею изображаемое */
        if( argc > 2 ) debug = 1;
        printf ("\t*** Таблица простых чисел от 2 до %d ***\n", i);
        n = 0;
        for (j = 1; j <= i; j++)
            if (is_prime (j)){
                /* распечатка в COL колонок */
                printf ("%3d%s", j, n == COL-1 ? "\n" : "\t");
                if( n == COL-1 ) n = 0;
                else             n++;
            }
        printf( "\n---\n" );
        exit (0);
    }

1.35.

Составьте программу ввода двух комплексных чисел в виде A + B * I (каждое на отдельной строке) и печати их произведения в том же виде. Используйте scanf и printf.

Перед тем, как использовать scanf, проверьте себя: что неверно в нижеприведенном операторе?

    int x;
    scanf( "%d", x );

1.36.

Напишите подпрограмму вычисления корня уравнения f(x)=0 методом деления отрезка пополам. Приведем реализацию этого алгоритма для поиска целочисленного квадратного корня из целого числа (этот алгоритм может использоваться, например, в машинной графике при рисовании дуг):

    /* Максимальное unsigned long число */
    #define MAXINT (~0L)
    /* Определим имя-синоним для типа unsigned long */
    typedef unsigned long ulong;
    /* Функция, корень которой мы ищем: */
    #define FUNC(x, arg)  ((x) * (x) - (arg))
    /* тогда x*x - arg = 0 означает  x*x = arg, то есть
     * x = корень_квадратный(arg)     */
    /* Начальный интервал. Должен выбираться исходя из
     * особенностей функции FUNC */
    #define  LEFT_X(arg)  0
    #define RIGHT_X(arg) (arg > MAXINT)? MAXINT : (arg/2)+1;
    /* КОРЕНЬ КВАДРАТНЫЙ, округленный вниз до целого.
     * Решается по методу деления отрезка пополам:
     *    FUNC(x, arg) = 0;       x = ?
     */
    ulong i_sqrt( ulong arg ) {
       register ulong   mid,   /* середина интервала    */
                        rgt,   /* правый край интервала */
                        lft;   /* левый край интервала  */
       lft = LEFT_X(arg); rgt = RIGHT_X(arg);
       do{ mid = (lft + rgt + 1 )/2;
    /* +1 для ошибок округления при целочисленном делении */
           if( FUNC(mid, arg) > 0 ){
                  if( rgt == mid ) mid--;
                  rgt =  mid ;  /* приблизить правый край */
           } else lft =  mid ;  /* приблизить левый край  */
       } while( lft < rgt );
       return mid;
    }
    void main(){ ulong i;
       for(i=0; i <= 100; i++)
           printf("%ld -> %lu\n", i, i_sqrt(i));
    }

Использованное нами при объявлении переменных ключевое слово register означает, что переменная является ЧАСТО ИСПОЛЬЗУЕМОЙ, и компилятор должен попытаться разместить ее на регистре процессора, а не в стеке (за счет чего увеличится скорость обращения к этой переменной). Это слово используется как

    register тип переменная;
    register переменная; /* подразумевается тип int */

1.37. Напишите программу, вычисляющую числа треугольника Паскаля и печатающую их в виде треугольника.

            C(0,n)   = C(n,n)   = 1          n = 0...
            C(k,n+1) = C(k-1,n) + C(k,n)     k = 1..n
            n - номер строки

1.38.

Напишите функцию вычисления определенного интеграла методом Монте-Карло. Для этого вам придется написать генератор случайных чисел. Си предоставляет стандартный датчик ЦЕЛЫХ равномерно распределенных псевдослучайных чисел: если вы хотите получить целое число из интервала [A..B], используйте

    int x = A + rand() % (B+1-A);

Чтобы получать разные последовательности следует задавать некий начальный параметр последовательности (это называется "рандомизация") при помощи

    srand( число ); /* лучше нечетное */

Чтобы повторить одну и ту же последовательность случайных чисел несколько раз, вы должны поступать так:

    srand(NBEG); x=rand(); ... ; x=rand();
    /* и повторить все сначала */
    srand(NBEG); x=rand(); ... ; x=rand();

    static unsigned long int next = 1L;
    int rand(){
      next = next * 1103515245 + 12345;
      return ((unsigned int)(next/65536) % 32768);
    }
    void srand(seed) unsigned int seed;
    {     next = seed;    }

    char t[sizeof(long)];
    time(t); srand(t[0] + t[1] + t[2] + t[3] + getpid());

1.39. Напишите функцию вычисления определенного интеграла по методу Симпсона.

    /*#!/bin/cc $* -lm
     * Вычисление интеграла по методу Симпсона
     */
    #include <math.h>
    extern double integral(), sin(), fabs();
    #define PI 3.141593
    double myf(x) double x;
    {      return sin(x / 2.0);      }
    int niter;  /* номер итерации */
    void main(){
            double integral();
            printf("%g\n", integral(0.0, PI, myf, 0.000000001));
            /* Заметьте, что myf, а не myf().
             * Точное значение интеграла равно 2.0
             */
            printf("%d итераций\n", niter );
    }
    double integral(a, b, f, eps)
            double a, b;    /* концы отрезка */
            double eps;     /* требуемая точность */
            double (*f)();  /* подынтегральная функция */
    {
            register long i;
            double fab = (*f)(a) + (*f)(b); /* сумма на краях */
            double h, h2;   /* шаг и удвоенный шаг */
            long n, n2;     /* число точек разбиения и оно же удвоенное */
            double Sodd, Seven;  /* сумма значений f в нечетных и в
                                    четных точках */
            double S, Sprev;/* значение интеграла на данной
                               и на предыдущей итерациях */
            double x;       /* текущая абсцисса */
            niter = 0;
            n = 10L;        /* четное число */
            n2 = n * 2;
            h = fabs(b - a) / n2;   h2 = h * 2.0;
            /* Вычисляем первое приближение */
            /* Сумма по нечетным точкам: */
            for( Sodd = 0.0, x = a+h, i = 0;
                                      i < n;
                                      i++, x += h2 )
                    Sodd += (*f)(x);
            /* Сумма по четным точкам: */
            for( Seven = 0.0, x = a+h2, i = 0;
                                        i < n-1;
                                        i++, x += h2 )
                    Seven += f(x);
            /* Предварительное значение интеграла: */
            S = h / 3.0 * (fab + 4.0 * Sodd + 2.0 * Seven );
            do{
                    niter++;
                    Sprev = S;
                    /* Вычисляем интеграл с половинным шагом */
                    h2 = h;      h /= 2.0;
                    if( h == 0.0 ) break;   /* потеря значимости */
                    n  = n2;     n2 *= 2;
                    Seven = Seven + Sodd;
                    /* Вычисляем сумму по новым точкам: */
                    for( Sodd = 0.0, x = a+h, i = 0;
                                              i < n;
                                              i++, x += h2 )
                    Sodd += (*f)(x);
                    /* Значение интеграла */
                    S = h / 3.0 * (fab + 4.0 * Sodd + 2.0 * Seven );
            } while( niter < 31 && fabs(S - Sprev) / 15.0 >= eps );
            /* Используем условие Рунге для окончания итераций */
            return ( 16.0 * S - Sprev ) / 15.0 ;
            /* Возвращаем уточненное по Ричардсону значение */
    }

1.40. Где ошибка?

    struct time_now{
      int  hour, min, sec;
    } X = { 13, 08, 00 }; /* 13 часов 08 минут 00 сек.*/

1.41. Дан текст:

       int i = -2;
       i <<= 2;
       printf("%d\n", i); /* печать сдвинутого i : -8 */
       i >>= 2;
       printf("%d\n", i); /* печатается -2 */

       int i = -2;
       i <<= 2;
    /*
       printf("%d\n", i); /* печать сдвинутого i : -8 */
       i >>= 2;
    */
       printf("%d\n", i); /* печатается -2 */

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

    #ifdef COMMENT
      ... закомментированный текст ...
    #endif /*COMMENT*/

    /**/ printf("here");/* отладочная выдача включена  */
    /*   printf("here");/* отладочная выдача выключена */

    /* выключено();    /**/
       включено();     /**/

А вот дешевый способ быстро исключить оператор (с возможностью восстановления) конец комментария занимает отдельную строку, что позволяет отредактировать такой текст редактором почти не сдвигая курсор:

       /*printf("here");
        */

1.42. Почему программа печатает неверное значение для i2 ?

    int main(int argc, char *argv[]){
            int i1, i2;
            i1 = 1;         /* Инициализируем i1 /
            i2 = 2;         /* Инициализируем i2 */
            printf("Numbers %d %d\n", i1, i2);
            return(0);
    }

    int main(int argc, char *argv[]){
            int i1, i2;
            i1 = 1;         /* Инициализируем i1 */
            i2 = 2;         /* Инициализируем i2 */
            printf("Numbers %d %d\n", i1, i2);
            return(0);
    }

1.43. А вот "шальной" комментарий.

    void main(){
            int n    = 10;
            int *ptr = &n;
            int x, y = 40;
            x = y/*ptr     /* должно быть 4 */  + 1;
            printf( "%d\n", x );    /* пять */
            exit(0);
    }
    /* или такой пример из жизни - взят из переписки в Relcom */
    ...
    cost = nRecords/*pFactor     /* divided by Factor, and  */
           + fixMargin;          /* plus the precalculated  */
    ...

Поэтому бинарные операции принято окружать пробелами.

    x = y / *ptr   /* должно быть 4 */  + 1;

1.44.

Найдите ошибки в директивах препроцессора Си ^* (вертикальная черта обозначает левый край файла).

            |
            | #include <stdio.h>
            |#include  < sys/types.h >
            |#   define inc (x) ((x) + 1)
            |#define N 12;
            |#define X -2
            |
            |...  printf( "n=%d\n", N );
            |...  p = 4-X;

Ответ: в первой директиве стоит пробел перед #. Диез должен находиться в первой позиции строки. Во второй директиве в <> находятся лишние пробелы, не относящиеся к имени файла - препроцессор не найдет такого файла! В данном случае "красота" пошла во вред делу. В третьей - между именем макро inc и его аргументом в круглых скобках (x) стоит пробел, который изменяет весь смысл макроопределения: вместо макроса с параметром inc(x) мы получаем, что слово inc будет заменяться на (x)((x)+1). Заметим однако, что пробелы после # перед именем директивы вполне допустимы. В четвертом случае показана характерная опечатка - символ ; после определения. В результате написанный printf() заменится на

            printf( "n=%d\n", 12; );

В пятом случае ошибки нет, но нас ожидает неприятность в строке p=4-X; которая расширится в строку p=4--2; являющуюся синтаксически неверной. Чтобы избежать подобной ситуации, следовало бы написать

            p = 4 - X;  /* через пробелы */

            #define X (-2)

1.45. Напишите функцию max(x, y), возвращающую большее из двух значений. Напишите аналогичное макроопределение. Напишите макроопределения min(x, y) и abs(x) (abs модуль числа). Ответ:

    #define abs(x)   ((x)  <  0   ? -(x) : (x))
    #define min(x,y) (((x) < (y)) ?  (x) : (y))

    #define abs(x)  (x < 0 ? -x : x )
                вызываем
    abs(-z)                  abs(a|b)
                получаем
    (-z < 0 ? --z : -z )     (a|b < 0 ? -a|b : a|b )

У нас появилась "дикая" операция --z; а выражение a|b<0 соответствует a|(b<0), с совсем другим порядком операций! Поэтому заключение всех аргументов макроса в его теле в круглые скобки позволяет избежать многих неожиданных проблем. Придерживайтесь этого правила!

Вот пример, показывающий зачем полезно брать в скобки все определение:

    #define div(x, y)     (x)/(y)

         z = sizeof div(1, 2);
             превратится в
         z = sizeof(1) / (2);

    #define div(x, y) ((x) / (y))

1.46.

Макросы, в отличие от функций, могут порождать непредвиденные побочные эффекты:

    int sqr(int x){ return x  *  x; }
    #define SQR(x)       ((x) * (x))
    main(){ int y=2, z;
       z = sqr(y++); printf("y=%d z=%d\n", y, z);
       y = 2;
       z = SQR(y++); printf("y=%d z=%d\n", y, z);
    }

       z = ((y++) * (y++));

1.47. ANSI ANSI препроцессор^** языка Си имеет оператор ## - "склейка лексем":

    #define VAR(a, b)       a ## b
    #define CV(x)           command_ ## x
    main(){
      int VAR(x, 31) = 1;
      /* превратится в int x31 = 1; */
      int CV(a) = 2; /* даст int command_a = 2; */
      ...
    }

    #define VAR(a, b)       a/**/b

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

1.48.

Напишите программу, распечатывающую максимальное и минимальное из ряда чисел, вводимых с клавиатуры. Не храните вводимые числа в массиве, вычисляйте max и min сразу при вводе очередного числа!

    #include <stdio.h>
    main(){
      int max, min, x, n;
      for( n=0; scanf("%d", &x) != EOF; n++)
            if( n == 0 ) min = max = x;
            else{
               if( x > max ) max = x;
               if( x < min ) min = x;
            }
      printf( "Ввели %d чисел: min=%d max=%d\n",
                     n,            min,   max);
    }

Напишите аналогичную программу для поиска максимума и минимума среди элементов массива, изначально min=max=array[0];

1.49.

Напишите программу, которая сортирует массив заданных чисел по возрастанию (убыванию) методом пузырьковой сортировки. Когда вы станете более опытны в Си, напишите сортировку методом Шелла.

    /*
     * Сортировка по методу Шелла.
     * Сортировке подвергается массив указателей на данные типа obj.
     *      v------.-------.------.-------.------0
     *             !       !      !       !
     *             *       *      *       *
     *            элементы типа obj
     * Программа взята из книги Кернигана и Ритчи.
     */
    #include <stdio.h>
    #include <string.h>
    #include <locale.h>
    #define obj char
    static shsort (v,n,compare)
    int n;              /* длина массива */
    obj *v[];           /* массив указателей */
    int (*compare)();   /* функция сравнения соседних элементов */
    {
            int g,      /* расстояние, на котором происходит сравнение */
                i,j;    /* индексы сравниваемых элементов */
            obj *temp;
            for( g = n/2 ; g > 0  ; g /= 2 )
            for( i = g   ; i < n  ; i++    )
            for( j = i-g ; j >= 0 ; j -= g )
            {
                    if((*compare)(v[j],v[j+g]) <= 0)
                        break;      /* уже в правильном порядке */
                    /* обменять указатели */
                    temp = v[j]; v[j] = v[j+g]; v[j+g] = temp;
                    /* В качестве упражнения можете написать
                     * при помощи curses-а программу,
                     * визуализирующую процесс сортировки:
                     * например, изображающую эту перестановку
                     * элементов массива */
            }
    }
    /* сортировка строк */
    ssort(v) obj **v;
    {
            extern less();  /* функция сравнения строк */
            int len;
            /* подсчет числа строк */
            len=0;
            while(v[len]) len++;
            shsort(v,len,less);
    }
    /* Функция сравнения строк.
     * Вернуть целое меньше нуля, если a <  b
     *                      ноль, если a == b
     *               больше нуля, если a >  b
     */
    less(a,b) obj *a,*b;
    {
            return strcoll(a,b);
            /* strcoll - аналог strcmp,
             * но с учетом алфавитного порядка букв.
             */
    }
    char *strings[] = {
            "Яша", "Федя", "Коля",
            "Гриша", "Сережа", "Миша",
            "Андрей Иванович", "Васька",
            NULL
    };
    int main(){
            char **next;
            setlocale(LC_ALL, "");
            ssort( strings );
            /* распечатка */
            for( next = strings ; *next ; next++ )
                    printf( "%s\n", *next );
            return 0;
    }

^* Препроцессор Си - это программа /lib/cpp

^** ANSI - American National Standards Institute, разработавший стандарт на язык Си и его окружение.

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. В каком случае оправдано использование оператора goto?

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

1.53. К какому if-у относится else?

    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. Почему 128 превратилось в отрицательное число?

    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), снова превратив число в положительное.

1.70. Почему

    printf("%d\n", '\377' == 0377 );
    printf("%d\n", '\xFF' == 0xFF );

    printf("%d %d\n", '\377', 0377);

1.71. Рассмотрим программу

    #include <stdio.h>
    int main(int ac, char **av){
            int c;
            while((c = getchar()) != EOF)
                    switch(c){
                    case 'ы': printf("Буква ы\n"); break;
                    case 'й': printf("Буква й\n"); break;
                    default:  printf("Буква с кодом %d\n", c); break;
                    }
            return 0;
    }

    % a.out
    йфыв
    Буква с кодом 202
    Буква с кодом 198
    Буква с кодом 217
    Буква с кодом 215
    Буква с кодом 10
    ^D
    %

Ответ: русские буквы имеют восьмой бит (левый) равный 1. В case такой байт приводится к типу int расширением знакового бита. В итоге получается отрицательное число. Пример:

    void main(void){
            int c = 'й';
            printf("%d\n", c);
    }
    печатает -54

    #include <stdio.h>
    /* Одно из двух */
    #define U(c)    ((c) & 0xFF)
    #define UC(c)   ((unsigned char) (c))
    int main(int ac, char **av){
            int c;
            while((c = getchar()) != EOF)
                    switch(c){
                    case U('ы'):    printf("Буква ы\n"); break;
                    case UC('й'):   printf("Буква й\n"); break;
                    default:        printf("Буква с кодом %d\n", c); break;
                    }
            return 0;
    }

    % a.out
    йфыв
    Буква й
    Буква с кодом 198
    Буква ы
    Буква с кодом 215
    Буква с кодом 10
    ^D
    %

    case 0312:

    int c;
            ...
    if(c == 'й') ...

    if(c == UC('й')) ...

1.72.

Рассмотрим программу, которая должна напечатать числа от 0 до 255. Для этих чисел в качестве счетчика достаточен один байт:

    int main(int ac, char *av[]){
        unsigned char ch;
        for(ch=0; ch < 256; ch++)
            printf("%d\n", ch);
        return 0;
    }

Однако эта программа зацикливается, поскольку в момент, когда ch==255, это значение меньше 256. Следующим шагом выполняется ch++, и ch становится равно 0, ибо для char вычисления ведутся по модулю 256 (2 в 8 степени). То есть в данном случае 255+1=0

Решений существует два: первое - превратить unsigned char в int. Второе - вставить явную проверку на последнее значение диапазона.

    int main(int ac, char *av[]){
        unsigned char ch;
        for(ch=0; ; ch++){
            printf("%d\n", ch);
            if(ch == 255) break;
        }
        return 0;
    }

1.73. Подумайте, почему для

    unsigned a, b, c;
    a < b + c    не эквивалентно   a - b < c

    a = 1; b = 3; c = 2;
    printf( "%u\n", a - b );     /* 4294967294, хотя в
                       нормальной арифметике 1 - 3 = -2 */
    printf( "%d\n", a < b + c ); /* 1 */
    printf( "%d\n", a - b < c ); /* 0 */

1.74. Дан текст:

    short x = 40000;
    printf("%d\n", x);

Печатается -25536. Объясните эффект. Указание: каково наибольшее представимое короткое целое (16 битное)? Что на самом деле оказалось в x? (лишние слева биты - обрубаются).

1.75. Почему в примере

            double x = 5 / 2;
            printf( "%g\n", x );

Ответ: производится целочисленное деление, затем в присваивании целое число 2 приводится к типу double. Чтобы получился ответ 2.5, надо писать одним из следующих способов:

            double x = 5.0 / 2;
            x = 5 / 2.0;
            x = (double) 5 / 2;
            x = 5 / (double) 2;
            x = 5.0 / 2.0;

Объясните, почему следующие три оператора выдают такие значения:

            double g = 9.0;
            int t = 3;
            double dist = g *  t * t / 2;    /* 40.5 */
                   dist = g * (t * t / 2);   /* 36.0 */
                   dist = g * (t * t / 2.0); /* 40.5 */

1.76. Странслируйте пример на машине с длиной слова int равной 16 бит:

            long n  = 1024 * 1024;
            long nn =  512 *  512;
            printf( "%ld %ld\n", n, nn );

Ответ: результат умножения (2**20 и 2**18) - это целое число; однако оно слишком велико для сохранения в 16 битах, поэтому старшие биты обрубаются. Получается 0.

Затем в присваивании это уже обрубленное значение приводится к типу long (32 бита) это все равно будет 0.

Чтобы получить корректный результат, надо чтобы выражение справа от = уже имело тип long и сразу сохранялось в 32 битах. Для этого оно должно иметь хоть один операнд типа long:

            long n = (long) 1024 * 1024;
            long nn =        512 *  512L;

1.77. Найдите ошибку в операторе:

    x - = 4;   /* вычесть из x число 4 */

    x @= expr;

    x = x @ expr;

Однако имеется тонкое отличие a=a+n от a+=n; оно заключается в том, сколько раз вычисляется a. В случае a+=n единожды; в случае a=a+n два раза.

    #include <stdio.h>
    static int x = 0;
    int *iaddr(char *msg){
            printf("iaddr(%s) for x=%d evaluated\n", msg, x);
            return &x;
    }
    int main(){
            static int a[4];
            int *p, i;
            printf( "1: "); x = 0; (*iaddr("a"))++;
            printf( "2: "); x = 0; *iaddr("b") += 1;
            printf( "3: "); x = 0; *iaddr("c") = *iaddr("d") + 1;
            for(i=0, p = a; i < sizeof(a)/sizeof(*a); i++) a[i] = 0;
            *p++ += 1;
            for(i=0; i < sizeof(a)/sizeof(*a); i++)
                    printf("a[%d]=%d ", i, a[i]);
            printf("offset=%d\n", p - a);
            for(i=0, p = a; i < sizeof(a)/sizeof(*a); i++) a[i] = 0;
            *p++ = *p++ + 1;
            for(i=0; i < sizeof(a)/sizeof(*a); i++)
                    printf("a[%d]=%d ", i, a[i]);
            printf("offset=%d\n", p - a);
            return 0;
    }

    1: iaddr(a) for x=0 evaluated
    2: iaddr(b) for x=0 evaluated
    3: iaddr(d) for x=0 evaluated
    iaddr(c) for x=0 evaluated
    a[0]=1 a[1]=0 a[2]=0 a[3]=0 offset=1
    a[0]=1 a[1]=0 a[2]=0 a[3]=0 offset=2

    a[i++] += z;

    a[i] = a[i] + z; i++;

    a[i++] = a[i++] + z;

1.78. Операция y = ++x; эквивалентна

    y = (x = x+1, x);

    y = (tmp = x, x = x+1, tmp);

    y = (x += 1) - 1;

Пусть x=1. Какие значения будут присвоены x и y после выполнения оператора

            y = ++x + ++x + ++x;

1.79. Пусть i=4. Какие значения будут присвоены x и i после выполнения оператора

            x = --i + --i + --i;

1.80. Пусть x=1. Какие значения будут присвоены x и y после выполнения оператора

            y = x++ + x++ + x++;

1.81. Пусть i=4. Какие значения будут присвоены i и y после выполнения оператора

            y = i-- + i-- + i--;

1.82. Корректны ли операторы

    char *p = "Jabberwocky"; char s[] = "0123456789?";
    int i = 0;
    s[i] = p[i++]; или *p   = *++p;
                   или s[i] = i++;
              или даже *p++ = f( *p );

Ответ: нет, стандарт не предусматривает, какая из частей присваивания вычисляется первой: левая или правая. Поэтому все может работать так, как мы и подразумевали, но может и иначе! Какое i используется в s[i]: 0 или уже 1 (++ уже сделан или нет), то есть

    int i = 0; s[i] = i++;     это
    s[0]  = 0;      или же     s[1] = 0;  ?

    s[i++] = p[i++];

    int i=0, j=0;
    s[i++] = p[j++];

    if( a[i++] < b[i] )...;

Порядок вычисления операндов не определен, поэтому неясно, что будет сделано прежде: взято значение b[i] или значение a[i++] (тогда будет взято b[i+1] ). Надо писать так, чтобы не полагаться на особенности вашего компилятора:

    if( a[i] < b[i+1] )...;  или  *p = *(p+1);
    i++;                          ++p;

Твердо усвойте, что i++ и ++i не только выдают значения i и i+1 соответственно, но и изменяют значение i. Поэтому эти операторы НЕ НАДО использовать там, где по смыслу требуется i+1, а не i=i+1. Так для сравнения соседних элементов массива

       if( a[i] < a[i+1] ) ... ;  /* верно */
       if( a[i] < a[++i] ) ... ;  /* неверно */

1.83.

Порядок вычисления операндов в бинарных выражениях не определен (что раньше вычисляется - левый операнд или же правый ?). Так пример

    int f(x,s) int x; char *s;
    {  printf( "%s:%d ", s, x ); return x; }
    main(){
       int x = 1;
       int y = f(x++, "f1") + f(x+=2, "f2");
       printf("%d\n", y);
    }

            f1:1 f2:4 5
               либо
            f2:3 f1:3 6

            int y = 2;
            int x = ((y = 4) * y );
            printf( "%d\n", x );

            y = 4;  x = y * y;

1.84. Законен ли оператор

            f(x++, x++);   или  f(x, x++);

            f( c = getchar(), c );

            c = getchar();  f(c, c);

            ...
            case '+':
                    push(pop()+pop()); break;
            case '-':
                    push(pop()-pop()); break;
            ...

            ...
            case '+':
                    push(pop()+pop()); break;
            case '-':
                    { int x = pop(); int y = pop();
                      push(y - x); break;
                    }
            ...

      int x = 0;
      printf( "%d %d\n", x = 2, x );   /* 2 0 либо 2 2 */

      struct pnt{ int x; int y; }arr[20]; int i=0;
      ...
      scanf( "%d%d", & arr[i].x, & arr[i++].y );

            main(){
               int i = 3;
               printf( "%d %d %d\n", i += 7, i++, i++ );
            }

который показывает, что на IBM PC ^* - и PDP-11 ^** = аргументы функций вычисляются справа налево (пример печатает 12 4 3). Впрочем, другие компиляторы могут вычислять их слева направо (как и подсказывает нам здравый смысл).

1.85.

Программа печатает либо x=1 либо x=0 в зависимости от КОМПИЛЯТОРА - вычисляется ли раньше правая или левая часть оператора вычитания:

    #include <stdio.h>
    void main(){
            int c = 1;
            int x = c - c++;
            printf( "x=%d c=%d\n", x, c );
            exit(0);
    }

    left = c; right = c++; x = left - right;

    right = c++; left = c; x = left - right;

Вот еще достойная задачка:

    x = c-- - --c;  /* c-----c */

^* IBM ("Ай-би-эм") - International Buisiness Machines Corporation. Персональные компьютеры IBM PC построены на базе микропроцессоров фирмы Intel.

^** PDP-11 - (Programmed Data Processor) - компьютер фирмы DEC (Digital Equipment Corporation), у нас известный как СМ-1420. Эта же фирма выпускает машину VAX.

1.86.

Напишите программу, которая устанавливает в 1 бит 3 и сбрасывает в 0 бит 6.

Биты в слове нумеруются с нуля справа налево. Ответ:

            int x = 0xF0;
            x |=  (1 << 3);
            x &= ~(1 << 6);

    #define A  0x08             /* вход свободен  */
    #define B  0x40             /* выход свободен */
    установка флагов            : x |=    A|B;
    сброс флагов                : x &=  ~(A|B);
    проверка флага A            : if( x & A ) ...;
    проверка, что оба флага есть: if((x & (A|B)) == (A|B))...;
    проверка, что обоих нет     : if((x & (A|B)) == 0 )...;
    проверка, что есть хоть один: if( x & (A|B))...;
    проверка, что есть только A : if((x & (A|B)) == A)...;
    проверка, в каких флагах
      различаются x и y         : diff = x ^ y;

1.87.

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

    #define   SET(n,a) (a[(n)/BITS] |=  (1L <<((n)%BITS)))
    #define   CLR(n,a) (a[(n)/BITS] &= ~(1L <<((n)%BITS)))
    #define ISSET(n,a) (a[(n)/BITS] &   (1L <<((n)%BITS)))
    #define BITS 8 /* bits per char (битов в байте) */
    /* Перечислимый тип */
    enum fruit { APPLE, PEAR, ORANGE=113,
                 GRAPES, RAPE=125, CHERRY};
    /* шкала:   n из интервала 0..(25*BITS)-1 */
    static char fr[25];
    main(){
      SET(GRAPES, fr);  /* добавить в множество */
      if(ISSET(GRAPES, fr)) printf("here\n");
      CLR(GRAPES, fr);  /* удалить из множества */
    }

1.88.

Напишите программу, распечатывающую все возможные перестановки массива из N элементов. Алгоритм будет рекурсивным, например таким: в качестве первого элемента перестановки взять i-ый элемент массива. Из оставшихся элементов массива (если такие есть) составить все перестановки порядка N-1. Выдать все перестановки порядка N, получающиеся склейкой i-ого элемента и всех (по очереди) перестановок порядка N-1.

Взять следующее i и все повторить.

Главная проблема здесь - организовать оставшиеся после извлечения i-ого элемента элементы массива в удобную структуру данных (чтобы постоянно не копировать массив).

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

    /* ГЕНЕРАТОР ПЕРЕСТАНОВОК ИЗ n ЭЛЕМЕНТОВ ПО m */
    extern void *calloc(unsigned nelem, unsigned elsize);
    /* Динамический выделитель памяти, зачищенной нулями.
     * Это стандартная библиотечная функция.
     * Обратная к ней - free();
     */
    extern void free(char *ptr);
    static int N, M, number;
    static char *scale;     /* шкала выбранных элементов */
           int  *res;       /* результат */
    /* ... текст определений SET, CLR, ISSET, BITS ... */
    static void choose(int ind){
      if(ind == M){ /* распечатать перестановку */
         register i;
         printf("Расстановка #%04d", ++number);
         for(i=0; i < M; i++) printf(" %2d", res[i]);
         putchar('\n'); return;
      } else
      /* Выбрать очередной ind-тый элемент перестановки
       * из числа еще не выбранных элементов.
       */
      for(res[ind] = 0; res[ind] < N; ++res[ind])
         if( !ISSET(res[ind], scale)) {
            /* элемент еще не был выбран */
            SET(res[ind], scale);      /* выбрать */
            choose(ind+1);
            CLR(res[ind], scale);      /* освободить */
         }
    }
    void arrange(int n, int m){
      res   = (int *)  calloc(m, sizeof(int));
      scale = (char *) calloc((n+BITS-1)/BITS, 1);
      M = m; N = n; number = 0;
      if( N >= M ) choose(0);
      free((char *) res); free((char *) scale);
    }
    void main(int ac, char **av){
       if(ac != 3){ printf("Arg count\n"); exit(1); }
       arrange(atoi(av[1]), atoi(av[2]));
    }

Программа должна выдать n!/(n-m)! расстановок, где x! = 1*2*...*x - функция "факториал". По определению 0! = 1. Попробуйте переделать эту программу так, чтобы очередная перестановка печаталась по запросу:

    res = init_iterator(n, m);
    /* печатать варианты, пока они есть */
    while( next_arrangement (res))
           print_arrangement(res, m);
    clean_iterator(res);

1.89.

Напишите макроопределения циклического сдвига переменной типа unsigned int на skew бит влево и вправо (ROL и ROR). Ответ:

    #define BITS 16     /* пусть целое состоит из 16 бит */
    #define ROL(x,skew) x=(x<<(skew))|(x>>(BITS-(skew)))
    #define ROR(x,skew) x=(x>>(skew))|(x<<(BITS-(skew)))

            |abcdef|        исходно
           abcdef00          << 2
             0000abcdef      >> 4
             ------         операция |
             cdefab         результат

В случае signed int потребуется накладывать маску при сдвиге вправо из-за того, что левые биты при >> не заполняются нулями. Приведем пример для сдвига переменной типа signed char (по умолчанию все char - знаковые) на 1 бит влево:

    #define CHARBITS 8
    #define ROLCHAR1(x) x=(x<<1)|((x>>(CHARBITS-1)) & 01)

    на 2 бита надо делать &  03
    на 3                  &  07
    на 4                  & 017
    на skew               & ~(~0 << skew)

1.90.

Напишите программу, которая инвертирует (т.е. заменяет 1 на 0 и наоборот) N битов, начинающихся с позиции P, оставляя другие биты без изменения. Возможный ответ:

    unsigned x, mask;
    mask = ~(~0 << N) << P;
    x = (x & ~mask) | (~x & mask);
                 /*   xnew   */

      ~0            = 11111....11111
      ~0 << N       = 11111....11000  /* N нулей */
    ~(~0 << N)      = 00000....00111  /* N единиц */
    ~(~0 << N) << P = 0...01110...00
    /* N единиц на местах P+N-1..P */

1.91.

Операции умножения * и деления / и % обычно достаточно медленны. В критичных по скорости функциях можно предпринять некоторые ручные оптимизации, связанные с представлением чисел в двоичном коде (хороший компилятор делает это сам!) - пользуясь тем, что операции +, &, >> и << гораздо быстрее. Пусть у нас есть

    unsigned int x;

    x * (2**n)  = x << n
    x / (2**n)  = x >> n
    x % (2**n)  = x - ((x >> n) << n)
    x % (2**n)  = x & (2**n - 1)
                  это  11...111  n двоичных единиц

    x * 8   = x << 3;
    x / 8   = x >> 3; /* деление нацело     */
    x % 8   = x &  7; /* остаток от деления */
    x * 80  = x*64 + x*16  = (x << 6) + (x << 4);
    x * 320 = (x * 80) * 4 = (x * 80) << 2 =
                             (x << 8) + (x << 6);
    x * 21  = (x << 4) + (x << 2) + x;
    x & 1   = x % 2 = четное(x)? 0:1 = нечетное(x)? 1:0;
    x & (-2) = x & 0xFFFE = | если x = 2*k      то 2*k
                            | если x = 2*k + 1  то 2*k
                            | то есть округляет до четного

    days_in_year = (year % 4 == 0) ? 366 : 365;

    days_in_year = ((year & 0x03) == 0) ? 366 : 365;

    x = x & (a|~a) = (x & a) | (x & ~a) = (x&a) + (x&~a)

    x - (x % 2**n) = x - (x &  (2**n - 1)) =
                   =      x & ~(2**n - 1)  = (x>>n) << n
    x - (x%8) = x-(x&7) = x & ~7

1.92. Обычно мы вычисляем min(a,b) так:

    #define min(a, b) (((a) < (b)) ? (a) : (b))

    if(a < b) min = a;
    else      min = b;

Здесь есть операция сравнения и условный переход. Однако, если (a < b) эквивалентно условию (a - b) < 0, то мы можем избежать сравнения. Это предположение верно при

    (unsigned int)(a - b) <= 0x7fffffff.

При этих условиях

    min(a, b) = b + ((a - b) & ((a - b) >> 31));

1. Случай 1: a < b

   Здесь (a - b) < 0, поэтому старший (левый, знаковый) бит разности (a - b) равен 1.
   Следовательно, (a - b) >> 31 == 0xffffffff, и мы имеем:

   	min(a, b)       = b + ((a - b) & ((a - b) >> 31))
   			    = b + ((a - b) & (0xffffffff))
   			    = b + (a - b)
   			    = a
   

   что корректно.

2. Случай 2: a >= b

   Здесь (a - b) >= 0, поэтому старший бит разности (a - b) равен 0. Тогда (a - b) >> 31 == 0, и мы имеем:

   	min(a, b)       = b + ((a - b) & ((a - b) >> 31))
   			    = b + ((a - b) & (0x00000000))
   			    = b + (0)
   			    = b
   

   что также корректно.

1.93. Есть ли быстрый способ определить, является ли X степенью двойки? Да, есть.

    int X является степенью двойки
    тогда и только тогда, когда
            (X & (X - 1)) == 0

    X = bbbbbbbbbb10000...

    X               = bbbbbbbbbb10000...
    X - 1           = bbbbbbbbbb01111...
    -----------------------------------    X & (X - 1)     = bbbbbbbbbb00000...

Другими словами, X & (X-1) имеет эффект обнуления последнего единичного бита. Если X - степень двойки, то он содержит в двоичном представлении ровно ОДИН такой бит, поэтому его гашение обращает результат в ноль. Если X - не степень двойки, то в слове есть хотя бы ДВА единичных бита, поэтому X & (X-1) должно содержать хотя бы один из оставшихся единичных битов - то есть не равняться нулю.

Следствием этого служит программа, вычисляющая число единичных битов в слове X:

    int popc;
    for (popc = 0; X != 0; X &= X - 1)
            popc++;

1.94.

Функция для поиска номера позиции старшего единичного бита в слове. Используется бинарный поиск: позиция находится максимум за 5 итераций (двоичный логарифм 32х), вместо 32 при линейном поиске.

    int highbit (unsigned int x)
    {
            int i;
            int h = 0;
            for (i = 16; i >= 1; i >>= 1) {
                    if (x >> i) {
                            h += i;
                            x >>= i;
                    }
            }
            return (h);
    }

1.95.

Напишите функцию, округляющую свой аргумент вниз до степени двойки.

    #include <stdio.h>
    #define INT short
    #define INFINITY (-999)
    /* Функция, выдающая число, являющееся округлением вниз
     * до степени двойки.
     * Например:
     *      0000100010111000110
     *      заменяется на
     *      0000100000000000000
     * то есть остается только старший бит.
     * В параметр power2 возвращается номер бита,
     * то есть показатель степени двойки. Если число == 0,
     * то эта степень равна минус бесконечности.
     */
    unsigned INT round2(unsigned INT x, int *power2){
    /* unsigned - чтобы число рассматривалось как
     * битовая шкала, а сдвиг >> заполнял левые биты
     * нулем, а не расширял вправо знаковый бит.
     * Идея функции: сдвигать число >> пока не получится 1
     * (можно было бы выбрать 0).
     * Затем сдвинуть << на столько же разрядов, при этом все правые
     * разряды заполнятся нулем, что и требовалось.
     */
            int n = 0;
            if(x == 0){
                    *power2 = -INFINITY; return 0;
            }
            if(x == 1){
                    *power2 = 0; return 1;
            }
            while(x != 1){
                x >>= 1;
                n++;
                if(x == 0 || x == (unsigned INT)(-1)){
                    printf("Вижу %x: похоже, что >> расширяет знаковый бит.\n"
                           "Зациклились!!!\n", x);
                    return (-1);
                }
            }
            x <<= n;
            *power2 = n; return x;
    }
    int counter[ sizeof(unsigned INT) * 8];
    int main(void){
            unsigned INT i;
            int n2;
            for(i=0; ; i++){
                round2(i, &n2);
                if(n2 == -INFINITY) continue;
                counter[n2]++;
                /* Нельзя писать for(i=0; i < (unsigned INT)(-1); i++)
                 * потому что такой цикл бесконечен!
                 */
                if(i == (unsigned INT) (-1)) break;
            }
            for(i=0; i < sizeof counter/sizeof counter[0]; i++)
                    printf("counter[%u]=%d\n", i, counter[i]);
            return 0;
    }

1.96.

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

    #include <stdio.h>
    int nbits_table[256];
    int countBits(unsigned char c){
        int nbits = 0;
        int bit;
        for(bit = 0; bit < 8; bit++){
                if(c & (1 << bit))
                        nbits++;
        }
        return nbits;
    }
    void generateTable(){
        int c;
        for(c=0; c < 256; c++){
            nbits_table[ (unsigned char) c ] = countBits(c);
            /* printf("%u=%d\n", c, nbits_table[ c & 0377 ]); */
        }
    }
    int main(void){
        int c;
        unsigned long bits  = 0L;
        unsigned long bytes = 0L;
        generateTable();
        while((c = getchar()) != EOF){
                bytes++;
                bits += nbits_table[ (unsigned char) c ];
        }
        printf("%lu байт\n", bytes);
        printf("%lu единичных бит\n", bits);
        printf("%lu нулевых бит\n", bytes*8 - bits);
        return 0;
    }

1.97.

Напишите макрос swap(x, y), обменивающий значениями два своих аргумента типа int.

    #define swap(x,y) {int tmp=(x);(x)=(y);(y)=tmp;}
     ... swap(A, B); ...

            int x,  y;      /*  A    B   */
            x = x ^ y;      /*  A^B  B   */
            y = x ^ y;      /*  A^B  A   */
            x = x ^ y;      /*    B  A   */

1.98.

Напишите функцию swap(x, y) при помощи указателей. Заметьте, что в отличие от макроса ее придется вызывать как

     ... swap(&A, &B); ...

1.99.

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

    f(x,y)      { return(x   +    y); }     и
    f(муж,жена) { return(муж + жена); }

    f(xyz, 43+1);

В Си это означает, что формальным параметрам (в качестве локальных переменных) присваиваются начальные значения, равные значениям фактических параметров:

    x = xyz; y = 43 + 1; /*в теле ф-ции их можно менять*/

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

Что печатает программа?

    char str[] = "строка1";
    char lin[] = "строка2";
    f(str) char str[];      /* формальный параметр. */
    {       printf( "%s %s\n", str, str );         }
    main(){
            char *s = lin;
                          /* фактический параметр: */
            f(str);       /* массив str            */
            f(lin);       /* массив lin            */
            f(s);         /* переменная s          */
            f("строка3"); /* константа             */
            f(s+2);       /* значение выражения    */
    }

Обратите внимание, что параметр str из f(str) и массив str[] - это две совершенно РАЗНЫЕ вещи, хотя и называющиеся одинаково. Переименуйте аргумент функции f и перепишите ее в виде

    f(ss) char ss[];      /* формальный параметр. */
    {       printf( "%s %s\n", ss, str );         }

1.100. Поговорим более подробно про область видимости имен.

    int x = 12;
    f(x){  int y = x*x;
           if(x) f(x - 1);
    }
    main(){ int x=173, z=21; f(2); }

           -+               +- вершина стека
            |локал    y=0   |
            |аргумент x=0   |  f(0)
            |---------------|--------    "кадр"  |локал    y=1   |
     frame  |аргумент x=1   |  f(1)
            |---------------|--------       |локал    y=4   |
            |аргумент x=2   |  f(2)
            |---------------|--------       |локал    z=21  |
    auto:   |локал    x=173 |  main()
    ================================== дно стека
    static:  глобал   x=12
    ==================================

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

Что напечатает программа? Постарайтесь ответить на этот вопрос не выполняя программу на машине!

                                            x1 x2 x3 x4 x5
    int x = 12;                    /* x1 */ |  .  .  .  .
    f(){                                    |___  .  .  .
      int x = 8;       /* x2, перекрытие */ :  |  .  .  .
      printf( "f: x=%d\n", x );    /* x2 */ :  |  .  .  .
      x++;                         /* x2 */ :  |  .  .  .
    }                                       :--+  .  .  .
    g(x){                          /* x3 */ :______  .  .
      printf( "g: x=%d\n", x );    /* x3 */ :     |  .  .
      x++;                         /* x3 */ :     |  .  .
    }                                       :-----+  .  .
    h(){                                    :_________  .
      int x = 4;                   /* x4 */ :        |  .
      g(x);                        /* x4 */ :        |___
      { int x = 55; }              /* x5 */ :        :  |
      printf( "h: x=%d\n", x );    /* x4 */ :        |--+
    }                                       :--------+
    main(){                                 |
      f(); h();                             |
      printf( "main: x=%d\n", x ); /* x1 */ |
    }                                    ---

    f: x=8
    g: x=4
    h: x=4
    main: x=12

Обратите внимание на функцию g. Аргументы функции служат копиями фактических параметров (т.е. являются локальными переменными функции, проинициализированными значениями фактических параметров), поэтому их изменение не приводит к изменению фактического параметра. Чтобы изменять фактический параметр, надо передавать его адрес!

1.101.

Поясним последнюю фразу. (Внимание! Возможно, что данный пункт вам следует читать ПОСЛЕ главы про указатели). Пусть мы хотим написать функцию, которая обменивает свои аргументы x и y так, чтобы выполнялось x < y. В качестве значения функция будет выдавать (x+y)/2. Если мы напишем так:

    int msort(x, y) int x, y;
    { int tmp;
      if(x > y){ tmp=x; x=y; y=tmp; }
      return (x+y)/2;
    }
    int x=20, y=8;
    main(){
      msort(x,y); printf("%d %d\n", x, y); /* 20 8 */
    }

то мы не достигнем желаемого эффекта. Здесь переставляются x и y, которые являются локальными переменными, т.е. копиями фактических параметров. Поэтому вне функции эта перестановка никак не проявляется!

Чтобы мы могли изменить аргументы, копироваться в локальные переменные должны не сами значения аргументов, а их адреса:

    int msort(xptr, yptr) int *xptr, *yptr;
    { int tmp;
      if(*xptr > *yptr){tmp= *xptr;*xptr= *yptr;*yptr=tmp;}
      return (*xptr + *yptr)/2;
    }
    int x=20, y=8, z;
    main(){
      z = msort(&x,&y);
      printf("%d %d %d\n", x, y, z); /* 8 20 14 */
    }

Обратите внимание, что теперь мы передаем в функцию не значения x и y, а их адреса &x и &y.

Именно поэтому (чтобы x смог измениться) стандартная функция scanf() требует указания адресов:

    int x; scanf("%d", &x); /* но не scanf("%d", x); */

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

    int xx=12, *xxptr = &xx, a[2] = { 13, 17 };
    int *fy(){ return &y; }
            msort(&x, &a[0]);       msort(a+1, xxptr);
            msort(fy(), xxptr);

            msort(&(x+1), &y);   и  msort(&x, &17);

Заметим еще, что при работе с адресами мы можем направить указатель в неверное место и получить непредсказуемые результаты:

            msort(&xx - 20, a+40);

Резюме: если аргумент служит только для передачи значения В функцию - его не надо (хотя и можно) делать указателем на переменную, содержащую требуемое значение (если только это уже не указатель). Если же аргумент служит для передачи значения ИЗ функции - он должен быть указателем на переменную возвращаемого типа (лучше возвращать значение как значение функции - return-ом, но иногда надо возвращать несколько значений - и этого главного "окошка" не хватает).

Контрольный вопрос: что печатает фрагмент?

    int a=2, b=13, c;
    int f(x, y, z) int x, *y, z;
    {
            *y += x; x *= *y; z--;
            return (x + z - a);
    }
    main(){ c=f(a, &b, a+4); printf("%d %d %d\n",a,b,c); }

1.102.

Формальные аргументы функции - это такие же локальные переменные. Параметры как бы описаны в самом внешнем блоке функции:

    char *func1(char *s){
            int s;        /* ошибка: повторное определение имени s */
            ...
    }
    int func2(int x, int y){
            int z;
            ...
    }

    int func2(){
            int x = безымянный_аргумент_1_со_стека;
            int y = безымянный_аргумент_2_со_стека;
            int z;
            ...
    }

1.103. Все параметры функции можно разбить на 3 класса:

• in - входные;
• out - выходные, служащие для возврата значения из функции; либо для изменения данных, находящихся по этому адресу;
• in/out - для передачи значения в функцию и из функции.

Два последних типа параметров должны быть указателями. Иногда (особенно в прототипах и в документации) бывает полезно указывать класс параметра в виде комментария:

    int f( /*IN*/    int  x,
           /*OUT*/   int *yp,
           /*INOUT*/ int *zp){
       *yp = ++x + ++(*zp);
       return (*zp *= x) - 1;
    }
    int x=2, y=3, z=4, res;
    main(){  res = f(x,  &y,  &z);
     printf("res=%d  x=%d y=%d z=%d\n",res,x,y,z);
             /*  14     2    8   15   */
    }

Это полезно потому, что иногда трудно понять - зачем параметр описан как указатель. То ли по нему выдается из функции информация, то ли это просто указатель на данные (массив), передаваемые в функцию. В первом случае указуемые данные будут изменены, а во втором - нет. В первом случае указатель должен указывать на зарезервированную нами область памяти, в которой будет размещен результат. Пример на эту тему есть в главе "Текстовая обработка" (функция bi_conv).

1.104. Известен такой стиль оформления аргументов функции:

    void func(   int    arg1
             ,   char  *arg2      /* argument 2 */
             ,   char  *arg3[]
             ,   time_t time_stamp
             ){ ... }

Суть его в том, что запятые пишутся в столбик и в одну линию с ( и ) скобками для аргументов. При таком стиле легче добавлять и удалять аргументы, чем при версии с запятой в конце. Этот же стиль применим, например, к перечислимым типам:

    enum {  red
         ,  green
         ,  blue
         };

1.105. В чем ошибка?

    char *val(int x){
         char str[20];
         sprintf(str, "%d", x);
         return str;
    }
    void main(){
         int x = 5; char *s = val(x);
         printf("The values:\n");
         printf("%d %s\n", x, s);
    }

Ответ: val возвращает указатель на автоматическую переменную. При выходе из функции val() ее локальные переменные (в частности str[]) в стеке уничтожаются - указатель s теперь указывает на испорченные данные! Возможным решением проблемы является превращение str[] в статическую переменную (хранимую не в стеке):

    static char str[20];

    printf("%s %s\n", val(1), val(2));

так как под оба вызова val() используется один и тот же буфер str[] и будет печататься "1 1" либо "2 2", но не "1 2". Более правильным будет задание буфера для результата val() как аргумента:

    char *val(int x, char str[]){
          sprintf(str, "%d", x);
          return str;
    }
    void main(){
         int x=5, y=7;
         char s1[20], s2[20];
         printf("%s %s\n", val(x, s1), val(y, s2));
    }

1.106. Каковы ошибки (не синтаксические) в программе^*?

            main() {
               double y; int x = 12;
               y = sin (x);
               printf ("%s\n", y);
            }

• стандартная библиотечная функция sin() возвращает значение типа double, но мы нигде не информируем об этом компилятор. Поэтому он считает по умолчанию, что эта функция возвращает значение типа int и делает в присваивании y=sin(x) приведение типа int к типу левого операнда, т.е. к double. В результате возвращаемое значение (а оно на самом деле - double) интерпретируется неверно (как int), подвергается приведению типа (которое портит его), и результат получается совершенно не таким, как надо. Подобная же ошибка возникает при использовании функций, возвращающих указатель, например, функций malloc() и itoa(). Поэтому если мы пользуемся библиотечной функцией, возвращающей не int, мы должны предварительно (до первого использования) описать ее, например^** :

  	extern double sin();
  	extern long   atol();
  	extern char  *malloc(), *itoa();
  

  Это же относится и к нашим собственным функциям, которые мы используем прежде, чем определяем (поскольку из заголовка функции компилятор обнаружит, что она выдает не целое значение, уже после того, как странслирует обращение к ней):

  	/*extern*/ char *f();
  	main(){
  		char *s;
  		s = f(1); puts(s);
  		}
  		char *f(n){ return "knights" + n; }
  

  Функции, возвращающие целое, описывать не требуется. Описания для некоторых стандартных функций уже помещены в системные include-файлы. Например, описания для математических функций (sin, cos, fabs, ...) содержатся в файле /usr/include/math.h. Поэтому мы могли бы написать перед main

  	#include <math.h>
  

  вместо

  	extern double sin(), cos(), fabs();
  

• библиотечная функция sin() требует аргумента типа double, мы же передаем ей аргумент типа int (который короче типа double и имеет иное внутреннее представление). Он будет неправильно проинтерпретирован функцией, т.е. мы вычислим синус отнюдь НЕ числа 12. Следует писать:

  	y = sin( (double) x );
  	и  sin(12.0); вместо sin(12);
  

• в printf мы печатаем значение типа double по неправильному формату: следует использовать формат %g или %f (а для ввода при помощи scanf() - %lf). Очень частой ошибкой является печать значений типа long по формату %d вместо %ld .

Первых двух проблем в современном Си удается избежать благодаря заданию прототипов функций (о них подробно рассказано ниже, в конце главы "Текстовая обработка"). Например, sin имеет прототип

double sin(double x);

1.107. Найдите ошибку:

            int sum(x,y,z){  return(x+y+z); }
            main(){
                    int s = sum(12,15);
                    printf("%d\n", s);
            }

Заметим, что если бы для функции sum() был задан прототип, то компилятор поймал бы эту нашу оплошность! Заметьте, что сейчас значение z в sum() непредсказуемо. Если бы мы вызывали

            s = sum(12,15,17,24);

А вот пример опасной ошибки, которая не ловится даже прототипами:

            int x;   scanf("%d%d", &x );

Второе число по формату %d будет считано неизвестно по какому адресу и разрушит память программы. Ни один компилятор не проверяет соответствие числа %-ов в строке формата числу аргументов scanf и printf.

1.108. Что здесь означают внутренние (,,) в вызове функции f() ?

    f(x, y, z){
            printf("%d %d %d\n", x, y, z);
    }
    main(){ int t;
            f(1, (2, 3, 4), 5);
            f(1, (t=3,t+1), 5);
    }

Ответ: (2,3,4) - это оператор "запятая", выдающий значение последнего выражения из списка перечисленных через запятую выражений. Здесь будет напечатано 1 4 5. Кажущаяся двойственность возникает из-за того, что аргументы функции тоже перечисляются через запятую, но это совсем другая синтаксическая конструкция. Вот еще пример:

    int y = 2, x;
    x = (y+4, y, y*2); printf("%d\n", x);      /*  4 */
    x =  y+4, y, y*2 ; printf("%d\n", x);      /*  6 */
    x = (x=y+4, ++y, x*y); printf("%d\n", x);  /* 18 */

Сначала обратим внимание на первую строку. Это - объявление переменных x и y (причем y - с инициализацией), поэтому запятая здесь - не ОПЕРАТОР, а просто разделитель объявляемых переменных! Далее следуют три строки выполняемых операторов. В первом случае выполнилось x=y*2; во втором x=y+4 (т.к. приоритет у присваивания выше, чем у запятой). Обратите внимание, что выражение без присваивания (которое может вообще не иметь эффекта или иметь только побочный эффект) вполне законно:

    x+y;   или   z++;   или   x == y+1;   или   x;

    f(12,x);        putchar('Ы');

Оператор "запятая" разделяет выражения, а не просто операторы, поэтому если хоть один из перечисленных операторов не выдает значения, то это является ошибкой:

    main(){ int i, x = 0;
      for(i=1; i < 4; i++)
          x++, if(x > 2) x = 2; /* используй { ; } */
    }

    void f(){}
      ...
      for(i=1; i < 4; i++)
          x++, f();

Вот еще один пример того, как можно переписать один и тот же фрагмент, применяя разные синтаксические конструкции:

    if( условие ) { x = 0; y = 0; }
    if( условие )   x = 0, y = 0;
    if( условие )   x = y = 0;

1.109. Найдите опечатку:

            switch(c){
            case 1:
                    x++; break;
            case 2:
                    y++; break;
            defalt:
                    z++; break;
            }

^* Для трансляции программы, использующей стандартные математические функции sin, cos, exp, log, sqrt, и.т.п. следует задавать ключ компилятора -lm

	cc file.c -o file -lm

^** Слово extern ("внешняя") не является обязательным, но является признаком хорошего тона - вы сообщаете программисту, читающему эту программу, что данная функция реализована в другом файле, либо вообще является стандартной и берется из библиотеки.

1.110. Почему программа зацикливается и печатает совсем не то, что нажато на клавиатуре, а только 0 и 1?

            while ( c = getchar() != 'e')
                    printf("%d %c\n, c, c);

            while ((c = getchar()) != 'e')
                    printf("%d %c\n, c, c);

           вместо
    if(  x & 01  == 0 ) ...     if( c&0377  > 0300)...;
           надо:
    if( (x & 01) == 0 ) ...     if((c&0377) > 0300)...;

    FILE *fp;
    if( fp = fopen( "файл", "w" ) == NULL ){
        fprintf( stderr, "не могу писать в файл\n");
        exit(1);
    }
    fprintf(fp,"Good bye, %s world\n","cruel"); fclose(fp);

В этом примере файл открывается, но fp равно 0 (логическое значение!) и функция fprintf() не срабатывает (программа падает по защите памяти^*).

Исправьте аналогичную ошибку (на приоритет операций) в следующей функции:

    /* копирование строки from в to */
    char *strcpy( to, from ) register char *from, *to;
    {
         char *p = to;
         while( *to++ = *from++ != '\0' );
         return p;
    }

1.111.

Сравнения с нулем (0, NULL, '\0') в Си принято опускать (хотя это не всегда способствует ясности).

        if( i == 0 ) ...;    -->    if( !i ) ... ;
        if( i != 0 ) ...;    -->    if(  i ) ... ;

    char s[20], *p ;
    for(p=s; *p != '\0'; p++ ) ... ;
         будет
    for(p=s; *p; p++ ) ... ;

    char s[81], *gets();
    while( gets(s) != NULL ) ... ;
         будет
    while( gets(s)) ... ;

1.112. Истинно ли выражение

            if( 2 < 5 < 4 )

Ответ: да! Дело в том, что Си не имеет логического типа, а вместо "истина" и "ложь" использует целые значения "не 0" и "0" (логические операции выдают 1 и 0). Данное выражение в условии if эквивалентно следующему:

            ((2 < 5) < 4)

            if( a < x < b )

            if( a < x && x < b )

1.113.

Данная программа должна печатать коды вводимых символов. Найдите опечатку; почему цикл сразу завершается?

      int c;
      for(;;) {
          printf("Введите очередной символ:");
          c = getchar();
          if(c = 'e') {
             printf("нажато e, конец\n"); break;
          }
          printf( "Код %03o\n", c & 0377 );
      }

Присваивание в Си (а также операции +=, -=, *=, и.т.п.) выдает новое значение левой части, поэтому синтаксической ошибки здесь нет! Написанный оператор равносилен

          c = 'e'; if( c ) ... ;

и, поскольку 'e'!= 0, то условие оказывается истинным! Это еще и следствие того, что в Си нет специального логического типа (истина/ложь). Будьте внимательны: компилятор не считает ошибкой использование оператора = вместо == внутри условий if и условий циклов (хотя некоторые компиляторы выдают предупреждение).

Еще аналогичная ошибка:

    for( i=0; !(i = 15) ; i++ ) ... ;

    static char s[20] = "   abc"; int i=0;
    while(s[i] = ' ') i++;
    printf("%s\n", &s[i]); /* должно напечататься abc */

То, что оператор присваивания имеет значение, весьма удобно:

    int x, y, z;           это на самом деле
    x = y = z = 1;         x = (y = (z = 1));

    y=f( x += 2 );       // вместо x+=2; y=f(x);
    if((y /= 2) > 0)...; // вместо y/=2; if(y>0)...;

    #include <stdio.h>
    main(){
      int sum = 0, card; char answer[36];
      srand( getpid());  /* рандомизация */
      do{  printf( "У вас %d очков. Еще? ", sum);
           if( *gets(answer) == 'n' ) break;
           /* иначе маловато будет */
           printf( "  %d очков\n",
                   card = 6 + rand() % (11 - 6 + 1));
      } while((sum += card) < 21);      /* SIC ! */
      printf ( sum == 21 ? "очко\n"   :
               sum >  21 ? "перебор\n":
                           "%d очков\n", sum);
    }

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

    #include <stdio.h>
    int width = 20; /* начальное значение ширины поля */
    int len; char str[512];
    main(){
      while(gets(str)){
        if((len = strlen(str)) > width){
    fprintf(stderr,"width увеличить до %d\n", width=len);
        }
        printf("|%*.*s|\n", -width, width, str);
      }
    }

a.out < входнойФайл > /dev/null

1.114. Почему программа "зависает" (на самом деле - зацикливается) ?

            int x = 0;
            while( x < 100 );
                    printf( "%d\n", x++ );
            printf( "ВСЕ\n" );

Мораль: не надо ставить ; где попало. Еще мораль: даже отступы в оформлении программы не являются гарантией отсутствия ошибок в группировке операторов.

1.115.

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

            x = 1 << 2 + 1 ;

будет 8, а не 5, поскольку сложение выполнится первым. Мораль: в затруднительных и неочевидных случаях лучше явно указывать приоритеты при помощи круглых скобок:

            x = (1 << 2) + 1 ;

            int bigFlag = 1, x = 2;
            x = x + bigFlag ? 40 : 1;
            printf( "%d\n", x );

            x = (x + bigFlag) ? 40 : 1;

            x = x + (bigFlag ? 40 : 1);

Заметим, что () указывают только приоритет, но не порядок вычислений. Так, компилятор имеет полное право вычислить

    long a = 50, x; int b = 4;
    x = (a * 100) / b;
      /* деление целочисленное с остатком ! */
    и как   x = (a * 100)/b = 5000/4 = 1250
    и как   x = (a/b) * 100 = 12*100 = 1200

невзирая на наши скобки, поскольку и * и / имеют одинаковый приоритет (хотя это "право" еще не означает, что он обязательно так поступит). Такие операторы приходится разбивать на два, т.е. вводить промежуточную переменную:

    { long a100 = a * 100; x = a100 / b; }

1.116.

Составьте программу вычисления тригонометрической функции. Название функции и значение аргумента передаются в качестве параметров функции main (см. про argv и argc в главе "Взаимодействие с UNIX"):

            $ a.out sin 0.5
            sin(0.5)=0.479426

Для преобразования строки в значение типа double воспользуйтесь стандартной функцией atof().

      char *str1, *str2, *str3; ...
      extern double atof();    double x = atof(str1);
      extern long   atol();    long   y = atol(str2);
      extern int    atoi();    int    i = atoi(str3);

    sscanf(str1, "%f",  &x);
    sscanf(str2, "%ld", &y); sscanf(str3,"%d", &i);

К слову заметим, что обратное преобразование - числа в текст - удобнее всего делается при помощи функции sprintf(), которая аналогична printf(), но сформированная ею строка-сообщение не выдается на экран, а заносится в массив:

            char represent[ 40 ];
            int i = ... ;
            sprintf( represent, "%d", i );

1.117. Составьте программу вычисления полинома n-ой степени:

               n          n-1
     Y = A  * X + A    * X    + ... + A0
          n        n-1

     Y = A0 + X * ( A1 + X * ( A2 + ... + X * An )))...)

    poly( x, n, an, an-1, ... a0 );

    #include <varargs.h>
    double poly(x, n, va_alist)
           double x; int n; va_dcl
    {
      va_list args;
      double sum = 0.0;
      va_start(args); /* инициализировать список арг-тов */
      while( n-- >= 0 ){
         sum *= x;
         sum += va_arg(args, double);
         /* извлечь след. аргумент типа double */
      }
      va_end(args);   /* уничтожить список аргументов */
      return sum;
    }
    main(){
                            /* y = 12*x*x + 3*x + 7 */
      printf( "%g\n", poly(2.0, 2, 12.0,    3.0,  7.0));
    }

    double poly(double x, int n, ...);

В этом примере использованы макросы va_нечто. Часть аргументов, которая является списком переменной длины, обозначается в списке параметров как va_alist, при этом она объявляется как va_dcl в списке типов параметров. Заметьте, что точка-с-запятой после va_dcl не нужна! Описание va_list args; объявляет специальную "связную" переменную; смысл ее машинно зависим. va_start(args) инициализирует эту переменную списком фактических аргументов, соответствующих va_alist-у. va_end(args) деинициализирует эту переменную (это надо делать обязательно, поскольку инициализация могла быть связана с конструированием списка аргументов при помощи выделения динамической памяти; теперь мы должны уничтожить этот список и освободить память). Очередной аргумент типа TYPE извлекается из списка при помощи

    TYPE x = va_arg(args, TYPE);

Нельзя указывать в качестве типов char, short, float:

    char ch = va_arg(args, char);

    int ch = va_arg(args, int);

1.118. Еще об одной ловушке в языке Си на PDP-11 (и в компиляторах бывают ошибки!):

            unsigned x = 2;
            printf( "%ld %ld",
                    - (long) x,
                    (long)  -x
            );

Этот фрагмент напечатает числа -2 и 65534. Во втором случае при приведении к типу long был расширен знаковый бит. Встроенная операция sizeof выдает значение типа unsigned. Подумайте, каков будет эффект в следующем фрагменте программы?

            static struct point{ int  x,  y    ;}
                          p =  {     33, 13   };
            FILE *fp = fopen( "00", "w" );
            /* вперед на длину одной структуры */
            fseek( fp, (long)  sizeof( struct point ), 0 );
            /* назад на длину одной структуры */
     /*!*/  fseek( fp, (long) -sizeof( struct point ), 1 );
            /* записываем в начало файла одну структуру */
            fwrite( &p, sizeof p, 1, fp );
            /* закрываем файл */
            fclose( fp );

Где должен находиться минус во втором вызове fseek для получения ожидаемого результата? (Данный пример может вести себя по-разному на разных машинах, вопросы касаются PDP-11).

1.119. Обратимся к указателям на функции:

    void g(x){ printf("%d: here\n", x); }
    main(){
      void (*f)() = g;  /* Указатель смотрит на функцию g() */
      (*f)(1); /* Старая форма вызова функции по указателю */
        f (2); /* Новая  форма вызова */
      /* В обоих случаях вызывается g(x); */
    }

    typedef void (*(*FUN))(); /* Попытка изобразить
            рекурсивный тип typedef FUN (*FUN)(); */
    FUN  g(FUN f){ return f; }
    void main(){
         FUN y = g(g(g(g(g))));
         if(y == g) printf("OK\n");
    }

            char *f(){
                    return "Hello, user!";
            }
            g(func)
                char * (*func)();
            {
                    puts((*func)());
            }
            main(){
                    g(f);
            }

            main(){
                    g(f());
            }

            #include <signal.h>
            f(){ printf( "Good bye.\n" ); exit(0); }
            main(){
                 signal ( SIGINT, f() );
                 ...
            }

Запомните, что f() - это ЗНАЧЕНИЕ функции f (т.е. она вызывается и нечто возвращает return-ом; это-то значение мы и используем), а f - это АДРЕС функции f (раньше это так и писалось &f), то есть метка начала ее машинных кодов ("точка входа").

^* "Падать" - программистский жаргон. Означает "аварийно завершаться". "Защита памяти" - обращение по некорректному адресу. В UNIX такая ошибка ловится аппаратно, и программа будет убита одним из сигналов: SIGBUS, SIGSEGV, SIGILL. Система сообщит нечто вроде "ошибка шины". Знайте, что это не ошибка аппаратуры и не сбой, а ВАША ошибка!

^** Конструкция //текст, которая будет изредка попадаться в дальнейшем - это комментарий в стиле языка C++. Такой комментарий простирается от символа // до конца строки.

1.120.

Что напечатает программа? (Пример посвящен указателям на функции и массивам функций):

    int f(n){ return n*2; }
    int g(n){ return n+4; }
    int h(n){ return n-1; }
    int (*arr[3])() = { f, g, h };
    main(){
     int i;
     for(i=0; i < 3; i++ )
         printf( "%d\n", (*arr[i])(i+7) );
    }

1.121. Что напечатает программа?

    extern double sin(), cos();
    main(){ double x; /* cc -lm */
      for(x=0.0; x < 1.0; x += 0.2)
        printf("%6.4g %6.4g %6.4g\n",
            (x > 0.5 ? sin : cos)(x), sin(x), cos(x));
    }

    extern double sin(), cos();
    main(){ double x; double (*f)();
      for(x=0.0; x < 1.0; x += 0.2){
            f = (x > 0.5 ? sin : cos);
            printf("%g\n", (*f)(x));
      }
    }

1.122. Рассмотрите четыре реализации функции факториал:

         n! = 1 * 2 * ... * n
     или n! = n * (n-1)!   где 0! = 1

    /* ЦИКЛ (ИТЕРАЦИЯ) */
    int factorial1(n){ int res = 1;
        while(n > 0){ res *= n--; }
        return res;
    }
    /* ПРОСТАЯ РЕКУРСИЯ */
    int factorial2(n){
        return (n==0 ? 1 : n * factorial2(n-1));
    }
    /* Рекурсия, в которой функция вызывается рекурсивно
     * единственный раз - в операторе return, называется
     * "хвостовой рекурсией" (tail recursion) и
     * легко преобразуется в цикл */
    /* АВТОАППЛИКАЦИЯ */
    int fi(f, n) int (*f)(), n;
    {   if(n == 0) return 1;
        else       return n * (*f)(f, n-1);
    }
    int factorial3(n){ return fi(fi, n); }
    /* РЕКУРСИЯ С НЕЛОКАЛЬНЫМ ПЕРЕХОДОМ */
    #include <setjmp.h>
    jmp_buf checkpoint;
    void fact(n, res) register int n, res;
    {   if(n) fact(n - 1, res * n);
        else  longjmp(checkpoint, res+1);
    }
    int factorial4(n){ int res;
        if(res = setjmp(checkpoint)) return (res - 1);
        else fact(n, 1);
    }

1.123.

Напишите функцию, печатающую целое число в системе счисления с основанием base. Ответ:

         printi( n, base ){
            register int i;
            if( n < 0 ){  putchar( '-' ); n = -n;   }
            if( i = n / base )
                    printi( i, base );
            i = n % base ;
            putchar( i >= 10 ? 'A' + i - 10 : '0' + i );
         }

Попробуйте написать нерекурсивный вариант с накоплением ответа в строке. Приведем рекурсивный вариант, накапливающий ответ в строке s и пользующийся аналогом функции printi: функция prints - такая же, как printi, но вместо вызовов putchar(нечто); в ней написаны операторы

            *res++ = нечто;

    static char *res;
     ... текст функции prints ...
    char *itos( n, base, s )
         char *s; /* указывает на char[] массив для ответа */
    {
            res = s; prints(n, base); *res = '\0';
            return s;
    }
    main(){ char buf[20]; printf( "%s\n", itos(19,2,buf); }

1.124.

Напишите функцию для побитной распечатки целого числа. Имейте в виду, что число содержит 8 * sizeof(int) бит. Указание: используйте операции битового сдвига и &. Ответ:

    printb(n){
      register i;
      for(i = 8 * sizeof(int) - 1; i >= 0; --i)
         putchar(n & (1 << i) ? '1':'0');
    }

1.125.

Напишите функцию, склоняющую существительные русского языка в зависимости от их числа. Например:

     printf( "%d кирпич%s", n, grammar( n, "ей", "", "а" ));

     char *grammar( i, s1, s2, s3 )
     char *s1, /* прочее */
          *s2, /* один */
          *s3; /* два, три, четыре */
     {
            i = i % 100;
            if( i > 10 && i <= 20 ) return s1;
            i = i % 10;
            if( i == 1 ) return s2;
            if( i == 2 || i == 3 || i == 4 )
                   return s3;
            return s1;
     }

1.126.

Напишите оператор printf, печатающий числа из интервала 0..99 с добавлением нуля перед числом, если оно меньше 10 :

            00 01 ... 09 10 11 ...