Так как указатель содержит адрес объекта, это дает возможность "косвенного" доступа к этому объекту через указатель. Предположим, что х - переменная, например, типа int, а рх - указатель, созданный неким еще не указанным способом. Унарная операция & выдает адрес объекта, так что оператор

 
  рх = &х;

Унарная операция * рассматривает свой операнд как адрес конечной цели и обращается по этому адресу, чтобы извлечь содержимое. Следовательно, если y тоже имеет тип int, то

 
  y = *рх;

 
  рх = &х;
  y = *рх;

 
 y = x;

 
 int x, y;
 int *px;

Описание указателя

 
 int *px;

 
 double atof(), *dp;

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

Указатели могут входить в выражения. Например, если px указывает на целое x, то *px может появляться в любом контексте, где может встретиться x. Так оператор

 
 y = *px + 1

 
 printf("%d\n", *px)

 
 d = sqrt((double) *px)

В выражениях вида

 
 y = *px + 1

 
  y = *(px + 1)

Ссылки на указатели могут появляться и в левой части присваиваний. Если px указывает на x, то

  *px = 0

 
  *px += 1

 
  (*px)++

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

И наконец, так как указатели являются переменными, то с ними можно обращаться, как и с остальными переменными. Если py - другой указатель на переменную типа int, то

 
  py = px

5.2. Указатели и аргументы функций

Так как в C передача аргументов функциям осуществляется "по значению", вызванная процедура не имеет непосредственной возможности изменить переменную из вызывающей программы. Что же делать, если вам действительно надо изменить аргумент? например, программа сортировки захотела бы поменять два нарушающих порядок элемента с помощью функции с именем swap. Для этого недостаточно написать

 
  swap(a, b);

 
  swap(x, y)      /* wrong */
  int x, y;
  {
     int temp;
 
     temp = x;
     x = y;
     y = temp;
  }

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

 
 swap(&a, &b);

 
 swap(px, py)    /* interchange *px and *py */
 int *px, *py;
 {
    int temp;
 
    temp = *px;
    *px = *py;
    *py = temp;
 }

Указатели в качестве аргументов обычно используются в функциях, которые должны возвращать более одного значения. (Можно сказать, что swap возвращает два значения, новые значения ее аргументов). В качестве примера рассмотрим функцию getint, которая осуществляет преобразование поступающих в свободном формате данных, разделяя поток символов на целые значения, по одному целому за одно обращение. Функция getint должна возвращать либо найденное значение, либо признак конца файла, если входные данные полностью исчерпаны. Эти значения должны возвращаться как отдельные объекты, какое бы значение ни использовалось для EOF, даже если это значение вводимого целого.

Одно из решений, основывающееся на описываемой в главе 7 функции ввода scanf, состоит в том, чтобы при выходе на конец файла getint возвращала EOF в качестве значения функции; любое другое возвращенное значение говорит о нахождении нормального целого. Численное же значение найденного целого возвращается через аргумент, который должен быть указателем целого. Эта организация разделяет статус конца файла и численные значения.

Следующий цикл заполняет массив целыми с помощью обращений к функции getint:

 
 int n, v, array[size];
 
 for (n = 0; n < size && getint(&v) != EOF; n++)
    array[n] = v;

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

Сама getint является очевидной модификацией написанной нами ранее функции atoi:

 
   getint(pn)    /* get next integer from input */
   int *pn;
   {
     int c,sign;
    
     while ((c = getch()) == ' ' || c == '\n'
     || c == '\t'); /* skip white space */
     sign = 1;
         (c == '+' || c == '-') { /* record
         sign */
        sign = (c == '+') ? 1 : -1;
        c = getch();
     }
     for (*pn = 0; c >= '0' && c <= '9'; c = getch())
        *pn = 10 * *pn + c - '0';
     *pn *= sign;
     if (c != EOF)
        ungetch(c);
     return(c);
   }

Выражение *pn используется всюду в getint как обычная переменная типа int. Мы также использовали функции getch и ungetch (описанные в главе 4) , так что один лишний символ, кототрый приходится считывать, может быть помещен обратно во ввод.

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

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

 
 int a[10]

     
    int *pa

 
    pa = &a[0]

 
    x = *pa

Если pa указывает на некоторый определенный элемент массива a, то по определению pa+1 указывает на следующий элемент, и вообще pa-i указывает на элемент, стоящий на i позиций до элемента, указываемого pa, а pa+i на элемент, стоящий на i позиций после. Таким образом, если pa указывает на a[0], то

 
    *(pa+1)

Эти замечания справедливы независимо от типа переменных в массиве a. Суть определения "добавления 1 к указателю", а также его распространения на всю арифметику указателей, состоит в том, что приращение масштабируется размером памяти, занимаемой объектом, на который указывает указатель. Таким образом, i в pa+i перед прибавлением умножается на размер объектов, на которые указывает pa.

Очевидно существует очень тесное соответствие между индексацией и арифметикой указателей. в действительности компилятор преобразует ссылку на массив в указатель на начало массива. В результате этого имя массива является указательным выражением. Отсюда вытекает несколько весьма полезных следствий. Так как имя массива является синонимом местоположения его нулевого элемента, то присваивание pa=&a[0] можно записать как

     
               pa = a

Еще более удивительным, по крайней мере на первый взгляд, кажется тот факт, что ссылку на a[i] можно записать в виде *(a+i). При анализе выражения a[i] в языке C оно немедленно преобразуется к виду *(a+i); эти две формы совершенно эквивалентны. Если применить операцию & к обеим частям такого соотношения эквивалентности, то мы получим, что &a[i] и a+i тоже идентичны: a+i - адрес i-го элемента от начала a. С другой стороны, если pa является указателем, то в выражениях его можно использовать с индексом: pa[i] идентично *(pa+i). Короче, любое выражение, включающее массивы и индексы, может быть записано через указатели и смещения и наоборот, причем даже в одном и том же утверждении.

Имеется одно различие между именем массива и указателем, которое необходимо иметь в виду. указатель является переменной, так что операции pa=a и pa++ имеют смысл. Но имя массива является константой, а не переменной: конструкции типа a=pa или a++,или pa=&a будут незаконными.

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

 
  strlen(s)       /* return length of string s */
  char *s;
  {
     int n;
 
     for (n = 0; *s != '\0'; s++)
             n++;
     return(n);
  }

Операция увеличения s совершенно законна, поскольку эта переменная является указателем; s++ никак не влияет на символьную строку в обратившейся к strlen функции, а только увеличивает локальную для функции strlen копию адреса. Описания формальных параметров в определении функции в виде

 
 char s[];
 char *s;

Можно передать функции часть массива, если задать в качестве аргумента указатель начала подмассива. Например, если a - массив, то как

 
 f(&a[2])

      
 f(a+2)

 
 f(arr)
 int arr[];
 {
    ...
 }

 
 f(arr)
 int *arr;
 {
    ...
 }

Если p является указателем, то каков бы ни был сорт объекта, на который он указывает, операция p++ увеличивает p так, что он указывает на следующий элемент набора этих объектов, а операция p +=i увеличивает p так, чтобы он указывал на элемент, отстоящий на i элементов от текущего элемента. Эти и аналогичные конструкции представляют собой самые простые и самые распространенные формы арифметики указателей или адресной арифметики.

Язык C последователен и постоянен в своем подходе к адресной арифметике; объединение в одно целое указателей, массивов и адресной арифметики является одной из наиболее сильных сторон языка. Давайте проиллюстрируем некоторые из соответствующих возможностей языка на примере элементарной (но полезной, несмотря на свою простоту) программы распределения памяти. Имеются две функции: функция alloc(n) возвращает в качестве своего значения указатель p, который указывает на первую из n последовательных символьных позиций, которые могут быть использованы вызывающей функцию alloc программой для хранения символов; функция free(p) освобождает приобретенную таким образом память, так что ее в дальнейшем можно снова использовать. программа является "элементарной", потому что обращения к free должны производиться в порядке, обратном тому, в котором производились обращения к alloc. Таким образом, управляемая функциями alloc и free память является стеком или списком, в котором последний вводимый элемент извлекается первым. Стандартная библиотека языка C содержит аналогичные функции, не имеющие таких ограничений, и, кроме того, в главе 8 мы приведем улучшенные варианты. Между тем, однако, для многих приложений нужна только тривиальная функция alloc для распределения небольших участков памяти неизвестных заранее размеров в непредсказуемые моменты времени.

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

Другой необходимой информацией является то, какая часть массива allocbuf уже использована. Мы пользуемся указателем первого свободного элемента, названным allocp. Когда к функции alloc обращаются за выделением n символов, то она проверяет, достаточно ли осталось для этого места в allocbuf. Если достаточно, то alloc возвращает текущее значение allocp (т.е. Начало свободного блока), затем увеличивает его на n, с тем чтобы он указывал на следующую свободную область. Функция free(p) просто полагает allocp равным p при условии, что p указывает на позицию внутри allocbuf.

 
 #define NULL 0  /* pointer value for error report */
 #define ALLOCSIZE 1000  /* size of available space */
 
 static char allocbuf[ALLOCSIZE];/* storage for alloc */
 static char *allocp = allocbuf; /* next free position */
 
 char *alloc(n)  /* return pointer to n characters */
 int n;
 (
  if (allocp + n <= allocbuf + ALLOCSIZE) {
    allocp += n;
    return(allocp - n); /* OLD p */
 } else         /* not enough room */
    return(NULL);
 )
 
 free(p)    /* free storage pionted by p */
 char *p;
 (
  if (p >= allocbuf && p < allocbuf + ALLOCSIZE)
     allocp = p;
 )

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

 
  static char *allocp = allocbuf;

 
     static char *allocp = &allocbuf[0];

 
   if (allocp + n <= allocbuf + ALLOCSIZE)

Проверки вида

 
  if (allocp + n <= allocbuf + ALOOCSIZE)

  if (p >= allocbuf && p < allocbuf + ALLOCSIZE)

 
  p < q      

Во-вторых, как мы уже видели, указатель и целое можно складывать и вычитать. Конструкция

 
  p + n

Вычитание указателей тоже возможно: если p и q указывают на элементы одного и того же массива, то p-q - количество элементов между p и q. Этот факт можно использовать для написания еще одного варианта функции

 
  strlen:
   strlen(s)       /* return length of string s */
   char *s;
   {
      char *p = s;
   
      while (*p != '\0')
              p++;
      return(p-s);
   }

При описании указатель p в этой функции инициализирован посредством строки s, в результате чего он указывает на первый символ строки. В цикле while по очереди проверяется каждый символ до тех пор, пока не появится символ конца строки \0. Так как значение \0 равно нулю, а while только выясняет, имеет ли выражение в нем значение 0, то в данном случае явную проверку можно опустить. Такие циклы часто записывают в виде

 
 while (*p)
    p++;

Так как p указывает на символы, то оператор p++ передвигает p каждый раз так, чтобы он указывал на следующий символ. В результате p-s дает число просмотренных символов, т.е. Длину строки. Арифметика указателей последовательна: если бы мы имели дело с переменными типа float, которые занимают больше памяти, чем переменные типа char, и если бы p был указателем на float, то оператор p++ передвинул бы p на следующее float. Таким образом, мы могли бы написать другой вариант функции alloc, распределяющей память для float, вместо char, просто заменив всюду в alloc и free описатель char на float. Все действия с указателями автоматически учитывают размер объектов, на которые они указывают, так что больше ничего менять не надо.

Строчная константа, как, например,

 
  "i am a string"

По-видимому чаще всего строчные константы появляются в качестве аргументов функций, как, например, в

 
  printf ("hello, world\n");

Конечно, символьные массивы не обязаны быть только аргументами функций. Если описать message как

 
  char *message;

 
  message = "now is the time";

Мы проиллюстрируем другие аспекты указателей и массивов, разбирая две полезные функции из стандартной библиотеки ввода-вывода, которая будет рассмотрена в главе 7.

Первая функция - это strcpy(s,t), которая копирует строку т в строку s. Аргументы написаны именно в этом порядке по аналогии с операцией присваивания, когда для того, чтобы присвоить t к s обычно пишут

 
   s = t

 
   strcpy(s, t)    /* copy t to s */
   char s[], t[];
   {
      int i;
      i = 0;
      while ((s[i] = t[i]) != '\0')
              i++;
   }

Для сопоставления ниже дается вариант strcpy с указателями.

 
 strcpy(s, t)  /* copy t to s; pointer version 1 */
 char *s, *t;
 {
    while ((*s = *t) != '\0') {
            s++;
            t++;
    }
 }

Так как аргументы передаются по значению, функция strcpy может использовать s и t так, как она пожелает. Здесь они с удобством полагаются указателями, которые передвигаются вдоль массивов, по одному символу за шаг, пока не будет скопирован в s завершающий в t символ \0.

На практике функция strcpy была бы записана не так, как мы показали выше. Вот вторая возможность:

 
 strcpy(s, t)  /* copy t to s; pointer version 2 */
 char *s, *t;
 {
    while ((*s++ = *t++) != '\0')
            ;
 }

Здесь увеличение s и t внесено в проверочную часть. Значением *t++ является символ, на который указывал t до увеличения; постфиксная операция ++ не изменяет t, пока этот символ не будет извлечен. Точно так же этот символ помещается в старую позицию s, до того как s будет увеличено. Конечный результат заключается в том, что все символы, включая завершающий \0, копируются из t в s.

И как последнее сокращение мы опять отметим, что сравнение с \0 является излишним, так что функцию можно записать в виде

 
 strcpy(s, t)  /* copy t to s; pointer version 3 */
 char *s, *t;
 {
    while (*s++ = *t++)
            ;
 }

Вторая функция - strcmp(s, t), которая сравнивает символьные строки s и т, возвращая отрицательное, нулевое или положительное значение в соответствии с тем, меньше, равно или больше лексикографически s, чем t. Возвращаемое значение получается в результате вычитания символов из первой позиции, в которой s и t не совпадают.

 
 strcmp(s, t) /* return <0 if s<t, 0 if s==t, >0 if s>t */
 char s[], t[];
 {
  int i;
 
  i = 0;
  while (s[i] == t[i])
     if (s[i++] == '\0')
             return(0);
  return(s[i]-t[i]);
 }

Вот версия strcmp с указателями:

 
 strcmp(s, t) /* return <0 if s<t, 0 if s==t, >0 if s>t */
 char *s, *t;
 {
  for ( ; *s == *t; s++, t++)
     if (*s == '\0')
             return(0);
  return(*s-*t);
 }

Так как ++ и -- могут быть как постфиксными, так и префиксными операциями, встречаются другие комбинации * и ++ и --, хотя и менее часто.

Например

 
  *++p

 
  *--p

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

Напишите вариант с указателями функции strcat из главы 2: strcat(s, t) копирует строку t в конец s.

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

Напишите макрос для strcpy.

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

Вы, возможно, обратили внимание в предыдущих C-программах на довольно непринужденное отношение к копированию указателей. В общем это верно, что на большинстве машин указатель можно присвоить целому и передать его обратно, не изменив его; при этом не происходит никакого масштабирования или преобразования и ни один бит не теряется. К сожалению, это ведет к вольному обращению с функциями, возвращающими указатели, которые затем просто передаются другим функциям, - необходимые описания указателей часто опускаются. Рассмотрим, например, функцию strsave(s), которая копирует строку s в некоторое место для хранения, выделяемое посредством обращения к функции alloc, и возвращает указатель на это место. Правильно она должна быть записана так:

 
     char *strsave(s) /* save string s somewhere */
     char *s;
     {
    char *p, *alloc();
 
    if ((p = alloc(strlen(s)+1)) != NULL)
            strcpy(p, s);
    return(p);
     }

     
     *strsave(s) /* save string s somewhere */
     {
    char *p;
 
    if ((p = alloc(strlen(s)+1)) != NULL)
            strcpy(p, s);
    return(p);
     }

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

Рассмотрим задачу преобразования дня месяца в день года и наоборот. Например, 1-ое марта является 60-м днем невисокосного года и 61-м днем високосного года. Давайте введем две функции для выполнения этих преобразований: day_of_year преобразует месяц и день в день года, а month_day преобразует день года в месяц и день. Так как эта последняя функция возвращает два значения, то аргументы месяца и дня должны быть указателями:

 
  month_day(1977, 60, &m, &d)

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

 
 static int day_tab[2][13] = {
      (0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31),
      (0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
 };         
 day_of_year(year, month, day)      /* set day of year */
 int year, month, day;        /* from month & day */
 {
     int i, leap;
   leap = year%4 == 0 && year%100 != 0 || year%400 == 0;
     for (i = 1; i < month; i++)
  day += day_tab[leap][i];
     return(day);
{
 
month_day(year, yearday, pmomth, pday) /*set month,day */
int year, yearday, *pmomth, *pday; /* from day of year */
{
  leap = year%4 == 0 && year%100 != 0 || year%400 == 0;
    for (i = 1; yearday > day_tab[leap][i]; i++)
 yearday -= day_tab[leap][i];
    *pmomth = i;
    *pday = yearday;
}

Массив day_tab должен быть внешним как для day_of_year, так и для month_day, поскольку он используется обеими этими функциями.

Массив day_tab является первым двумерным массивом, с которым мы имеем дело. По определению в C двумерный массив по существу является одномерным массивом, каждый элемент которого является массивом. Поэтому индексы записываются как

 
 day_tab[i][j]

 day_tab [i, j]

Массив инициализируется с помощью списка начальных значений, заключенных в фигурные скобки; каждая строка двумерного массива инициализируется соответствующим подсписком. Мы поместили в начало массива day_tab столбец из нулей для того, чтобы номера месяцев изменялись естественным образом от 1 до 12, а не от 0 до 11. Так как за экономию памяти у нас пока не награждают, такой способ проще, чем подгонка индексов.

Если двумерный массив передается функции, то описание соответствующего аргумента функции должно содержать количество столбцов; количество строк несущественно, поскольку, как и прежде, фактически передается указатель. В нашем конкретном случае это указатель объектов, являющихся массивами из 13 чисел типа int. Таким образом, если бы требовалось передать массив day_tab функции f, то описание в f имело бы вид:

 
 f(day_tab)
 int day_tab[2][13];
 {
    ...
 }

 
  int day_tab[][13];

 
  int (*day_tab)[13];

      
  int *day_tab[13];

5.8. Массивы указателей; указатели указателей

Так как указатели сами являются переменными, то вы вполне могли бы ожидать использования массива указателей. Это действительно так. Мы проиллюстрируем это написанием программы сортировки в алфавитном порядке набора текстовых строк, предельно упрощенного варианта утилиты sort операционной систем UNIX.

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

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

Процесс сортировки включает три шага:

• чтение всех строк ввода
• их сортировка
• вывод их в правильном порядке

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

Давайте отложим на некоторое время рассмотрение шага сортировки и сосредоточимся на структуре данных и вводе-выводе. Функция, осуществляющая ввод, должна извлечь символы каждой строки, запомнить их и построить массив указателей строк. Она должна также подсчитать число строк во вводе, так как эта информация необходима при сортировке и выводе. Так как функция ввода в состоянии справиться только с конечным числом вводимых строк, в случае слишком большого их числа она может возвращать некоторое число, отличное от возможного числа строк, например -1. Функция осуществляющая вывод, должна печатать строки в том порядке, в каком они появляются в массиве указателей.

 
  #define NULL 0
  #define LINES 100 /* max lines to be sorted */
   
  main()    /* sort input lines */
  {
   char *lineptr[LINES]; /*pionters to text lines */
   int nlines;     /* number of input lines read */
   
   if ((nlines = readlines(lineptr, LINES)) >= 0) {
      sort(lineptr, nlines);
      writelines(lineptr, nlines);
   }
   else
      printf("input TOO BIG to sort\n");
  }
   
  #define MAXLEN 1000
  readlines(lineptr, maxlines) /* read input lines */
  char *lineptr[];       /* for sorting */
  int maxlines;
  {
   int len, nlines;
   char *p, *alloc(), line[MAXLEN];
   
   nlines = 0;
   while ((len = getline(line, MAXLEN)) > 0)
      if (nlines >= maxlines)
              return(-1);
      else if ((p = alloc(len)) == NULL)
              return (-1);
      else {
           line[len-1] = '\0'; /* zap newline */
           strcpy(p,line);
           lineptr[nlines++] = p;
       }
    return(nlines);
   }

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

 
 writelines(lineptr, nlines) /* write output lines */
 char *lineptr[];
 int nlines;
 {
  int i;
 
  for (i = 0; i < nlines; i++)
     printf("%s\n", lineptr[i]);
 }

Существенно новым в этой программе является описание

 
  char *lineptr[LINES];

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

 
 writelines(lineptr, nlines) /* write output lines */
 char *lineptr[];
 int nlines;
 {
  int i;
 
  while (--nlines >= 0)
     printf("%s\n", *lineptr++);
 }

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

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

Так как каждый отдельный элемент массива v (имя формального параметра, соответствующего lineptr) является указателем на символы, то и temp должен быть указателем на символы, чтобы их было можно копировать друг в друга.

Мы написали эту программу по возможности более просто с тем, чтобы побыстрее получить работающую программу. Она могла бы работать быстрее, если, например, вводить строки непосредственно в массив, управляемый функцией readlines, а не копировать их в line, а затем в скрытое место с помощью функции alloc. но мы считаем, что будет разумнее первоначальный вариант сделать более простым для понимания, а об "эффективности" позаботиться позднее. Все же, по-видимому, способ, позволяющий добиться заметного ускорения работы программы, состоит не в исключении лишнего копирования вводимых строк. Более вероятно, что существенной разницы можно достичь за счет замены сортировки по Шеллу на нечто лучшее, например, на метод быстрой сортировки.

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

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

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

 
 char *month_name(n) /* return name of n-th month */
 int n;
 {
  static char *name[] = {
     "illegal month",
     "JANUARY",
     "FEBRUARY",
     "MARCH",
     "APRIL",
     "MAY",
     "JUN",
     "JULY",
     "AUGUST",
     "SEPTEMBER",
     "OCTOBER",
     "NOVEMBER",
     "DECEMBER"
  };
      return ((n < 1 || n > 12) ? name[0] : name[n]);
 }         

Начинающие изучать язык C иногда становятся в тупик перед вопросом о различии между двумерным массивом и массивом указателей, таким как name в риведенном выше примере. Если имеются описания

 
 int a[10][10];
 int *b[10];

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

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

Системные средства, на которые опирается реализация языка C, позволяют передавать командную строку аргументов или параметров начинающей выполняться программе. Когда функция main вызывается к исполнению, она вызывается с двумя аргументами. Первый аргумент (условно называемый argc) указывает число аргументов в командной строке, с которыми происходит обращение к программе; второй аргумент (argv) является указателем на массив символьных строк, содержащих эти аргументы, по одному в строке. Работа с такими строками - это обычное использование многоуровневых указателей.

Самую простую иллюстрацию этой возможности и необходимых при этом описаний дает программа echo, которая просто печатает в одну строку аргументы командной строки, разделяя их пробелами. Таким образом, если дана команда

 
  echo hello, world

 
  hello, world

 
 main(argc, argv) /* echo arguments; 1-st version */
 int argc;
 char *argv[];
 {
    int i;
 
    for (i = 1; i < argc; i++)
  printf("%s%c", argv[i], (i<argc-1) ? ' ' : '\n');
 }

Поскольку argv является указателем на массив указателей, то существует несколько способов написания этой программы, использующих работу с указателем, а не с индексацией массива. Мы продемонстрируем два варианта.

 
 main(argc, argv) /* echo arguments; 2-nd version */
 int argc;
 char *argv[];
 {
    while (--argc > 0)
  printf("%s%c",*++argv, (argc > 1) ? ' ' : '\n');
 }         

Так как argv является указателем на начало массива строк-аргументов, то, увеличив его на 1 (++argv), мы вынуждаем его указывать на подлинный аргумент argv[1], а не на argv[0]. Каждое последующее увеличение передвигает его на следующий аргумент; при этом *argv становится указателем на этот аргумент. одновременно величина argc уменьшается; когда она обратится в нуль, все аргументы будут уже напечатаны.

Другой вариант:

 
  main(argc, argv) /* echo arguments; 3-rd version */
  int argc;
  char *argv[];
  {
     while (--argc > 0)
   printf((argc > 1) ? "%s" : "%s\n", *++argv);
  }

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

Как второй пример, давайте внесем некоторые усовершенствования в программу отыскания заданной комбинации символов из главы 4. Если вы помните, мы поместили искомую комбинацию глубоко внутрь программы, что очевидно является совершенно неудовлетворительным. Следуя утилите GREP системы UNIX, давайте изменим программу так, чтобы эта комбинация указывалась в качестве первого аргумента строки.

 
  #define MAXLINE 1000
   
  main(argc, argv) /* find pattern from 1-st argument */
  int argc;
  char *argv[];
  {
   char line[MAXLINE];
   
   if (argc != 2)
      printf ("usage: find pattern\n");
   else
    while (getline(line, MAXLINE) > 0)
          if (index(line, argv[1] >= 0)
              printf("%s", line);
  }

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

Общепринятым соглашением в C-программах является то, что аргумент, начинающийся со знака минус, вводит необязательный признак или параметр. Если мы, для того, чтобы сообщить об инверсии, выберем -x, а для указания о нумерации нужных строк выберем -n("номер"), то команда

 
  find -x -n the

 
  now is the time
  for all good men
  to come to the aid
  of their party.

 
  2:for all good men

Нужно, чтобы необязательные аргументы могли располагаться в произвольном порядке, и чтобы остальная часть программы не зависела от количества фактически присутствующих аргументов. в частности, вызов функции index не должен содержать ссылку на argv[2], когда присутствует один необязательный аргумент, и на argv[1], когда его нет. Более того, для пользователей удобно, чтобы необязательные аргументы можно было объединить в виде:

 
  find -nx the

 
 #define MAXLINE 1000
 
 main(argc, argv) /* find pattern from 1-st argument */
 int argc;
 char *argv[];
 {
  char line[MAXLINE], *s;
  long lineno = 0;
  int except = 0, number = 0;
  while (--argc > 0 && (*++argv)[0] == '-')
     for (s = argv[0]+1; *s != '\0'; s++)
             switch (*s) {
             case 'x':
      except = 1;
      break;
             case 'n':
      number = 1;
      break;
            default:
    printf("find: illegal option %c\n", *s);
    argc = 0;
    break;
            }
 if (argc != 1)
     printf("usage: find -x -n pattern\n");
 else
     while (getlinе(line, MAXLINE) > 0) {
    lineno++;
    if ((index(line, *argv) >= 0) != except) \
        if (number)
            printf("%LD: ", lineno);
        printf("%s", line);
    }
     }
}

Аргумент argv увеличивается перед каждым необязательным аргументом, в то время как аргумент argc уменьшается. если нет ошибок, то в конце цикла величина argc должна равняться 1, а *argv должно указывать на заданную комбинацию. Обратите внимание на то, что *++argv является указателем аргументной строки; (*++argv)[0] - ее первый символ. Круглые скобки здесь необходимы, потому что без них выражение бы приняло совершенно отличный (и неправильный) вид *++(argv[0]). Другой правильной формой была бы **++argv.

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

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

 
 add 2 3 4 + *

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

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

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

Расширьте entab и detab таким образом, чтобы они воспринимали сокращенную нотацию

     
  entab m +n

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

 
  tail -n

5.12. Указатели на функции

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

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

Как и прежде, лексикографическое сравнение двух строк осуществляется функцией strcmp, а перестановка функцией swap; нам нужна еще функция numcmp, сравнивающая две строки на основе численного значения и возвращающая условное указание того же вида, что и strcmp. Эти три функции описываются в main и указатели на них передаются в sort. В свою очередь функция sort обращается к этим функциям через их указатели. Мы урезали обработку ошибок в аргументах с тем, чтобы сосредоточиться на главных вопросах.

     
  #define LINES 100 /* max number of lines
         to be sorted */
   
  main(argc, argv) /* sort input lines */
  int argc;
  char *argv[];
  {
   char *lineptr[LINES]; /* pionters to text lines */
   int nlines; /* number of input lines read */
   int strcmp(), numcmp(); /* comparsion functions */
   int swap(); /* exchange function */
   int numeric = 0; /* 1 if numeric sort */
   
   if(argc>1 && argv[1][0] == '-' && argv[1][1]=='n')
      numeric = 1;
   if(nlines = readlines(lineptr, LINES)) >= 0) {
      if (numeric)
            sort(lineptr, nlines, numcmp, swap);
      else
            sort(lineptr, nlines, strcmp, swap);
      writelines(lineptr, nlines);
   } else
      printf("input TOO BIG to sort\n");
  }

Здесь strcmp, numcmp и swap - адреса функций; так как известно, что это функции, операция & здесь не нужна совершенно аналогично тому, как она не нужна и перед именем массива. Передача адресов функций организуется компилятором. Второй шаг состоит в модификации sort:

 
  sort(v, n, comp, exch) /* sort strings v[0] ... v[n-1] */
  char *v[];           /* into increasing order */
  int n;
  int (*comp)(), (*exch)();
  {
   int gap, i, j;
   
   for(gap = n/2; gap > 0; gap /= 2)
       for(i = gap; i < n; i++)
      for(j = i-gap; j >= 0; j -= gap) {
          if((*comp)(v[j], v[j+gap]) <= 0)
              break;
          (*exch)(&v[j], &v[j+gap]);
      }
  }        

Здесь следует обратить определенное внимание на описания. Описание

 
  int (*comp)()

 
  int *comp()

Использование comp в строке

 
  if (*comp)(v[j], v[j+gap]) <= 0)

 
   (*comp)(v[j], v[j+gap])

Мы уже приводили функцию strcmp, сравнивающую две строки по первому численному значению:

 
 numcmp(s1, s2) /* compare s1 and s2 numerically */
 char *s1, *s2;
 {
  double atof(), v1, v2;
 
  v1 = atof(s1);
  v2 = atof(s2);
  if(v1 < v2)
     return(-1);
  else if(v1 > v2)
     return(1);
  else
     return (0);
 }

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

     
 swap(px, py) /* interchange *px and *py */
 char *px[], *py[];
 {
  char *temp;
 
  temp = *px;
  *px = *py;
  *py = temp;
 }

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

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

Модифицируйте sort таким образом, чтобы она работала с меткой -r, указывающей на сортировку в обратном (убывающем) порядке. Конечно, -r должна работать с -n.

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

Добавьте необязательный аргумент -f, объединяющий вместе прописные и строчные буквы, так чтобы различие регистров не учитывалось во время сортировки: данные из верхнего и нижнего регистров сортируются вместе, так что буква 'A' прописное и 'а' строчное оказываются соседними , а не разделенными целым алфавитом.

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

Добавьте необязательный аргумент -d ("словарное упорядочивание"), при наличии которого сравниваются только буквы, числа и пробелы. Позаботьтесь о том, чтобы эта функция работала и вместе с -f.

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

Добавьте возможность обработки полей, так чтобы можно было сортировать поля внутри строк. Каждое поле должно сортироваться в соответствии с независимым набором необязательных аргументов. (предметный указатель этой книги сортировался с помощью аргументов -df для категории указателя и с -n для номеров страниц).