Автоматический пропуск пробелов перед %s не позволяет считывать по %s строки, лидирующие пробелы которых должны сохраняться. Чтобы лидирующие пробелы также считывались, следует использовать формат

     scanf("%[^\n]%*1[\n]", s);

в котором модификатор длины 1 заставляет игнорировать только один символ \n, а не ВСЕ пробелы и переводы строк, как "\n". К сожалению (как показал эксперимент) этот формат не в состоянии прочесть пустую строку (состоящую только из \n). Поэтому можно сделать глобальный вывод: строки надо считывать при помощи функций gets() и fgets()!

1.135.

Еще пара слов про scanf: scanf возвращает число успешно прочитанных им данных (обработанных %-ов) или EOF в конце файла. Неудача может наступить, если данное во входном потоке не соответствует формату, например строка

            12 quack

            int d1; double f; scanf("%d%lf", &d1, &f);

В этом случае scanf прочтет 12 по формату %d в переменную d1, но слово quack не отвечает формату %lf, поэтому scanf прервет свою работу и выдаст значение 1 (успешно прочел один формат). Строка quack останется невостребованной - ее прочитают последующие вызовы функций чтения; а сейчас f останется неизмененной.

1.136.

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

    const int x = 22;
    x = 33; /* ошибка: константу нельзя менять */

         const char *pc = "abc";
         pc[1]  = 'x';    /* ошибка */
         pc     = "123";  /* OK */

         char *const cp = "abc";
         cp[1]  = 'x';    /* OK */
         cp     = "123";  /* ошибка */

         const char *const cpc = "abc";
         cpc[1] = 'x';    /* ошибка */
         cpc    = "123";  /* ошибка */

               int a = 1;
         const int b = 2;
         const int *pca  = &a;   /* OK, просто рассматриваем a как константу */
         const int *pcb  = &b;   /* OK */
               int *pb   = &b;   /* ошибка, так как тогда возможно было бы написать */
                   *pb   = 3;    /* изменить константу b */

1.137.

Стандартная функция быстрой сортировки qsort (алгоритм quick sort) имеет такой формат: чтобы отсортировать массив элементов типа TYPE

    TYPE arr[N];
          надо вызывать
    qsort(arr,/* Что сортировать? Не с начала: arr+m    */
          N,  /* Сколько первых элементов массива?      */
              /* можно сортировать только часть: n < N  */
          sizeof(TYPE),/* Или sizeof arr[0]             */
                       /* размер одного элемента массива*/
          cmp);

    int cmp(TYPE *a1, TYPE *a2);

функция сравнения элементов *a1 и *a2. Ее аргументы - АДРЕСА двух каких-то элементов сортируемого массива. Функцию cmp мы должны написать сами - это функция, задающая упорядочение элементов массива. Для сортировки по возрастанию функция cmp() должна возвращать целое

       < 0, если  *a1 должно идти раньше *a2    <
       = 0, если  *a1 совпадает с        *a2   ==
       > 0, если  *a1 должно идти после  *a2    >

            char *arr[N]; ...
            cmps(s1, s2) char **s1, **s2;
            { return strcmp(*s1, *s2); }

(Про strcmp смотри раздел "Массивы и строки"). Заметим, что в некоторых системах программирования (например в TurboC++^*) вы должны использовать функцию сравнения с прототипом

    int cmp (const void *a1, const void *a2);

    cmps (const void *s1, const void *s2)
    { return strcmp(*(char **)s1, *(char **)s2); }

    int cmps(char **s1, char **s2){
        return strcmp(*s1, *s2);
    }
    typedef int (*CMPS)(const void *, const void *);
    qsort((void *) array, ..., ..., (CMPS) cmps);

    int cmps(const void *A, const void *B){
        return strcmp(A, B);
    }

            int arr[N]; ...
            cmpi(i1, i2) int *i1, *i2;
            { return *i1 - *i2; }

            struct XXX{ int key; ... } arr[N];
            cmpXXX(st1, st2) struct XXX *st1, *st2;
            { return( st1->key  -  st2->key ); }

            long arr[N]; ...
            cmpl(L1, L2) long *L1, *L2;
            { return *L1 - *L2; }

Ответ: оказывается, что нет. Функция cmpl должна возвращать целое, а разность двух long-ов имеет тип long. Поэтому компилятор приводит эту разность к типу int (как правило обрубанием старших битов). При этом (если long-числа были велики) результат может изменить знак! Например:

    main(){
      int n; long a = 1L; long b = 777777777L;
      n = a - b;  /* должно бы быть отрицательным... */
      printf( "%ld %ld %d\n", a, b, n );
    }

            cmpl(L1, L2) long *L1, *L2; {
                    if( *L1 == *L2 ) return   0;
                    if( *L1 <  *L2 ) return (-1);
                                     return   1;
            }

            cmpl(L1, L2) long *L1, *L2; {
                return( *L1 == *L2 ?  0 :
                        *L1 <  *L2 ? -1 : 1 );
            }

Учтите, что для использования функции сравнения вы должны либо определить функцию сравнения до ее использования в qsort():

            int cmp(...){ ... } /* реализация */
                    ...
            qsort(..... , cmp);

            int cmp();
            qsort(..... , cmp);
                    ...
            int cmp(...){ ... } /* реализация */

1.138.

Пусть у нас есть две программы, пользующиеся одной и той же структурой данных W:

     a.c                          b.c
    --------------------------   -----------------------------
    #include <fcntl.h>           #include <fcntl.h>
    struct W{ int x,y; }a;       struct W{ int x,y; }b;
    main(){  int fd;             main(){  int fd;
      a.x = 12; a.y = 77;          fd = open("f", O_RDONLY);
      fd = creat("f", 0644);       read(fd, &b, sizeof b);
      write(fd, &a, sizeof a);     close(fd);
      close(fd);                   printf("%d %d\n", b.x, b.y);
    }                            }

            struct W { long x,y; };
                    или
            struct W { char c; int x,y; };

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

• типы данных (typedef);
• структуры и объединения;
• константы (определения #define);
• прототипы функций;

             W.h
            ----------------------
           struct W{ long x, y; };
     a.c                          b.c
    --------------------------   -----------------
    #include <fcntl.h>           #include <fcntl.h>
    #include "W.h"               #include "W.h"
    struct W a;                  struct W b;
    main(){  ...                 main(){  ...
                                    printf("%ld...

Кроме того, вынесение общих фрагментов текста программы (определений структур, констант, и.т.п.) в отдельный файл экономит наши силы и время - вместо того, чтобы набивать один и тот же текст много раз в разных файлах, мы теперь пишем в каждом файле единственную строку - директиву #include. Кроме того, экономится и место на диске, ведь программа стала короче! Файлы включения имеют суффикс .h, что означает "header-file" (файл-заголовок).

Синхронную перекомпиляцию всех программ в случае изменения include-файла можно задать в файле Makefile - программе для координатора make^** -:

    all: a b
            echo Запуск a и b
            a ; b
    a: a.c W.h
            cc a.c -o a
    b: b.c W.h
            cc b.c -o b

    цель: список_целей_от_которых_зависит
            команда

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

1.139.

Программа на Си может быть размещена в нескольких файлах. Каждый файл выступает в роли "модуля", в котором собраны сходные по назначению функции и переменные. Некоторые переменные и функции можно сделать невидимыми для других модулей. Для этого надо объявить их static:

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

Аргументы функции нельзя объявлять static:

         f(x) static x; { x++; }

Таким образом все переменные и функции в данном файле делятся на две группы:

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

Если мы используем в файле-модуле функции и переменные, входящие в интерфейс другого файла-модуля, мы должны объявить их как extern ("внешние"). Для функций описатели extern и int можно опускать:

    // файл A.c
    int x, y, z;              // глобальные
    char ss[200];             // глоб.
    static int v, w;          // локальные
    static char *s, p[20];    // лок.
    int f(){ ... }            // глоб.
    char *g(){ ... }          // глоб.
    static int h(){ ... }     // лок.
    static char *sf(){ ... }  // лок.
    int fi(){ ... }           // глоб.
    // файл B.c
    extern int x, y;
    extern z;           // int можно опустить
    extern char ss[];   // размер можно опустить
    extern int f();
    char *g();          // extern можно опустить
    extern fi();        // int можно опустить

    extern int x, y;  /* import from A.c     */
    char *tgetstr();  /* import from termlib */

    CFLAGS = -O
    AB:     A.o     B.o
            cc A.o B.o -o AB
    A.o:    A.c
            cc -c $(CFLAGS) A.c
    B.o:    B.c
            cc -c $(CFLAGS) B.c

       cc A.c B.c -o AB

     файл A.c                файл B.c
    ----------------------------------------
    int x=12;               int x=25;
    main(){                 f(y) int *y;
      f(&x);                {
      printf("%d\n", x);       *y += x;
    }                       }

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

   static int x=...;

     файл A.c               файл B.c
    ---------------------------------------------------
    int x;                  extern int x;
    main(){ f(5); g(77); }  g(n){ f(x+n); }
    f(n)  { x=n;         }  f(m){ printf("%d\n", m); }

Хоть в одном файле должна быть определена функция main, вызываемая системой при запуске программы. Если такой функции нигде нет - компилятор выдает сообщение "_main неопределено". Функция main должна быть определена один раз! В файле она может находиться в любом месте - не требуется, чтобы она была самой первой (или последней) функцией файла^****.

^* TurboC - компилятор Си в MS DOS, разработанный фирмой Borland International.

^** Подробное описание make смотри в документации по системе UNIX.

^*** Можно задать Makefile вида

^**** Если вы пользуетесь "новым" стилем объявления функций, но не используете прототипы, то следует определять каждую функцию до первого места ее использования, чтобы компилятору в точке вызова был известен ее заголовок. Это приведет к тому, что main() окажется последней функцией в файле - ее не вызывает никто, зато она вызывает кого-то еще.

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