Автоматический пропуск пробелов перед %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 с указателем: Указуемый объект - константа

         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() окажется последней функцией в файле - ее не вызывает никто, зато она вызывает кого-то еще.

[Назад][Содержание][Вперед]