м,  если  PA  указывает  на
A[0], то

   *(PA+1)

ссылаетсЯ на содержимое A[1], PA+I - адрес A[I], а *(PA+I) -
содержимое A[I].
    ќти замечаниЯ справедливы независимо от типа переменных
в массиве 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++,или P=&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 адрес элемента A[2], потому что и &A[2],
и A+2 ЯвлЯютсЯ указательными  выражениЯми,  ссылающимисЯ  на
третий элемент A. внутри функции F описаниЯ аргументов могут
присутствовать в виде:

F(ARR)
INT ARR[];
{
   ...
}

или

F(ARR)
INT *ARR;
{
   ...
}

—то касаетсЯ функции F, то тот факт, что ее аргумент в дейс-
твительности ссылаетсЯ к части большего массива,не имеет длЯ
нее никаких последствий.


        5.4. ЂдреснаЯ арифметика


    …сли 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 */

TATIC CHAR ALLOCBUF[ALLOCSIZE];/* STORAGE FOR ALLOC */
TATIC CHAR *ALLOCP = ALLOCBUF; /* NEXT FREE POSITION */

HAR *ALLOC(N)  /* RETURN POINTER TO N CHARACTERS */
INT N;
(
 IF (ALLOCP + N &lt;= ALLOCBUF + ALLOCSIZE) {
   ALLOCP += N;
   RETURN(ALLOCP - N); /* OLD P */
} ELSE         /* NOT ENOUGH ROOM */
   RETURN(NULL);
)

REE(P)    /* FREE STORAGE POINTED BY P */
HAR *P;
(
 IF (P >= ALLOCBUF && P &lt; ALLOCBUF + ALLOCSIZE)
    ALLOCP = P;
)


    „адим некоторые поЯснениЯ. ‚ообще говорЯ, указатель мо-
жет быть инициализирован точно так же, как и любаЯ другаЯ
переменнаЯ, хотЯ обычно единственными осмысленными значениЯ-
ми ЯвлЯютсЯ NULL (это обсуждаетсЯ ниже) или выражение, вклю-
чающее адреса ранее определенных данных соответствующего ти-
па. Ћписание

 STATIC CHAR *ALLOCP = ALLOCBUF;

определЯет ALLOCP как указатель на символы и инициализирует
его так, чтобы он указывал на ALLOCBUF, т.е. Ќа первую сво-
бодную позицию при начале работы программы. ’ак как имЯ мас-
сива ЯвлЯетсЯ адресом его нулевого элемента, то это можно
было бы записать в виде

    STATIC CHAR *ALLOCP = &ALLOCBUF[0];

используйте  ту запись, котораЯ вам кажетсЯ более естествен-
ной. ‘ помощью проверки

  IF (ALLOCP + N &lt;= ALLOCBUF + ALLOCSIZE)

выЯснЯетсЯ, осталось ли достаточно места, чтобы удовлетво-
рить запрос на N символов. …сли достаточно, то новое значе-
ние ALLOCP не будет указывать дальше, чем на последнюю пози-
цию ALLOCBUF. …сли запрос может быть удовлетворен, то ALLOC
возвращает обычный указатель (обратите внимание на описание
самой функции). …сли же нет, то ALLOC должна вернуть некото-
рый признак, говорЯщий о том, что больше места не осталось.
‚ Языке "C" гарантируетсЯ, что ни один правильный указатель
данных не может иметь значение нуль, так что возвращение ну-
лЯ может служить в качестве сигнала о ненормальном событии,
в данном случае об отсутствии места. Њы, однако, вместо нулЯ
пишем NULL, с тем чтобы более Ясно показать, что это специ-
альное значение указателЯ. ‚ообще говорЯ, целые не могут ос-
мысленно присваиватьсЯ указателЯм, а нуль - это особый слу-
чай.
    Џроверки вида

 IF (ALLOCP + N &lt;= ALLOCBUF + ALOOCSIZE)
и
 IF (P >= ALLOCBUF && P &lt; ALLOCBUF + ALLOCSIZE)

демонстрируют несколько важных аспектов арифметики указате-
лей. ‚о-первых , при определенных условиЯх указатели можно
сравнивать. …сли P и Q указывают на элементы одного и того
же массива, то такие отношениЯ, как &lt;, >= и т.д., работают
надлежащим образом. Ќапример,

 P &lt; Q


истинно, если P указывает на более ранний элемент массива,
чем Q. ЋтношениЯ == и != тоже работают. ‹юбой указатель мож-
но осмысленным образом сравнить на равенство или неравенство
с NULL. Ќо ни за что нельзЯ ручатьсЯ, если вы используете
сравнениЯ при работе с указателЯми, указывающими на разные
массивы. …сли вам повезет, то на всех машинах вы получите
очевидную бессмыслицу. …сли же нет, то ваша программа будет
правильно работать на одной машине и давать непостижимые ре-
зультаты на другой.
     ‚о-вторых, как мы уже видели, указатель и  целое  можно
складывать и вычитать. ЉонструкциЯ

 P + N

подразумевает N-ый объект за тем, на который P указывает в
настоЯщий момент. ќто справедливо независимо от того, на ка-
кой вид объектов P должен указывать; компилЯтор сам масшта-
бирует N в соответствии с определЯемым из описаниЯ P разме-
ром объектов, указываемых с помощью P. например, на PDP-11
масштабирующий множитель равен 1 длЯ CHAR, 2 длЯ INT и
SHORT, 4 длЯ LONG и FLOAT и 8 длЯ DOUBLE.
    ‚ычитание указателей тоже возможно: если 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. ‚се действиЯ с указателЯми автоматически учи-
тывают размер объектов, на которые они  указывают,  так  что
больше ничего менЯть не надо.
    ‡а исключением упомЯнутых выше операций (сложение и вы-
читание указателЯ и целого, вычитание и сравнение двух ука-
зателей), всЯ остальнаЯ арифметика указателей ЯвлЯетсЯ неза-
конной. ‡апрещено складывать два указателЯ, умножать, де-
лить, сдвигать или маскировать их, а также прибавлЯть к ним
переменные типа FLOAT или DOUBLE.


        5.5. “казатели символов и функции


    ‘трочнаЯ константа, как, например,

 "I AM A STRING"

ЯвлЯетсЯ массивом символов. ЉомпилЯтор завершает внутреннее
представление такого массива символом \0, так что программы
могут находить его конец. ’аким образом, длина массива в па-
мЯти оказываетсЯ на единицу больше числа символов между
двойными кавычками.
    Џо-видимому чаще всего строчные константы  поЯвлЯютсЯ  в
качестве аргументов функций, как, например, в

 PRINTF ("HELLO, WORLD\N");

когда символьнаЯ строка, подобнаЯ этой, поЯвлЯетсЯ в прог-
рамме, то доступ к ней осуществлЯетсЯ с помощью указателЯ
символов; функциЯ PRINTF фактически получает указатель сим-
вольного массива.
    Љонечно, символьные массивы не обЯзаны быть только аргу-
ментами функций. …сли описать MESSAGE как

 CHAR *MESSAGE;

то в результате оператора

 MESSAGE = "NOW IS THE TIME";

переменнаЯ MESSAGE станет указателем на фактический массив
символов. ќто не копирование строки; здесь участвуют только
указатели. в Языке "C" не предусмотрены какие-либо операции
длЯ обработки всей строки символов как целого.
    Њы проиллюстрируем другие аспекты указателей и массивов,
разбираЯ две полезные функции из стандартной библиотеки вво-
да-вывода, котораЯ будет рассмотрена в главе 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++)
           ;
}

хотЯ  с первого взглЯда эта запись может показатьсЯ загадоч-
ной, она дает значительное удобство.  ќтой  идиомой  следует
овладеть  уже хотЯ бы потому, что вы с ней будете часто вст-
речатьсЯ в "C"-программах.
    ‚тораЯ функциЯ - STRCMP(S, T), котораЯ сравнивает сим-
вольные строки S и т, возвращаЯ отрицательное, нулевое или
положительное значение в соответствии с тем, меньше, равно
или больше лексикографически S, чем T. ‚озвращаемое значение
получаетсЯ в результате вычитаниЯ символов из первой пози-
ции, в которой S и T не совпадают.

STRCMP(S, T) /* RETURN &lt;0 IF S&lt;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 &lt;0 IF S&lt;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 до извлечениЯ символа, на который указывает

P, а

 *--P

сначала уменьшает P.

    “пражнение 5-2
     ---------------
    Ќапишите  вариант  с указателЯми функции STRCAT из главы
2: STRCAT(S, T) копирует строку T в конец S.

    “пражнение 5-3
    ---------------
    Ќапишите макрос длЯ STRCPY.

    “пражнение 5-4
    --------------
    Џерепишите подходЯщие программы из предыдущих глав и уп-
ражнений,  используЯ  указатели  вместо индексации массивов.
•орошие возможности длЯ этого предоставлЯют функции  GETLINE
/главы  1  и  4/, ATOI, ITOA и их варианты /главы 2, 3 и 4/,
REVERSE /глава 3/, INDEX и GETOP /глава 4/.


        5.6. “казатели - не целые


    ‚ы, возможно, обратили внимание в предыдущих "с"-прог-
раммах на довольно непринужденное отношение к копированию
указателей. ‚ общем это верно, что на большинстве машин ука-
затель можно присвоить целому и передать его обратно, не из-
менив его; при этом не происходит никакого масштабированиЯ
или преобразованиЯ и ни один бит не терЯетсЯ. к сожалению,
это ведет к вольному обращению с функциЯми, возвращающими
указатели, которые затем просто передаютсЯ другим функциЯм,
- необходимые описаниЯ указателей часто опускаютсЯ. ђассмот-
рим, например, функцию 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);
    }

    ќта программа будет правильно работать на многих маши-
нах, потому что по умолчанию функции и аргументы имеют тип
INT, а указатель и целое обычно можно безопасно пересылать
туда и обратно. Ћднако такой стиль программированиЯ в своем
существе ЯвлЯетсЯ рискованным, поскольку зависит от деталей
реализации и архитектуры машины и может привести к непра-
вильным результатам на конкретном используемом вами компилЯ-
торе. ђазумнее всюду использовать полные описаниЯ. (Ћтладоч-
наЯ программа LINT предупредит о таких конструкциЯх, если
они по неосторожности все же поЯвЯтсЯ).


        5.7. Њногомерные массивы


    ‚ Языке "C" предусмотрены прЯмоугольные многомерные мас-
сивы, хотЯ на практике существует тенденциЯ к их значительно
более  редкому использованию по сравнению с массивами указа-
телей. ‚ этом разделе мы рассмотрим некоторые их свойства.
    ђассмотрим задачу преобразованиЯ днЯ месЯца в день  года
и  наоборот. Ќапример, 1-ое марта ЯвлЯетсЯ 60-м днем невисо-
косного года и 61-м днем високосного  года.  „авайте  введем
две  функции длЯ выполнениЯ этих преобразований: DAY_OF_YEAR
преобразует месЯц и день в день года, а MONTH_DAY преобразу-
ет  день  года в месЯц и день. ’ак как эта последнЯЯ функциЯ
возвращает два значениЯ, то аргументы месЯца  и  днЯ  должны
быть указателЯми:

 MONTH_DAY(1977, 60, &M, &D)

Џолагает M равным 3 и D равным 1 (1-ое марта).
    Ћбе эти функции нуждаютсЯ в одной и той же информацион-
ной таблице, указывающей число дней в каждом месЯце. ’ак как
число дней в месЯце в високосном и в невисокосном году отли-
чаетсЯ, то проще представить их в виде двух строк двумерного
массива, чем пытатьсЯ прослеживать во времЯ вычислений, что
именно происходит в феврале. ‚от этот массив и выполнЯющие
эти преобразованиЯ функции:

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 &lt; MONTH; I++)
 DAY += DAY_TAB[LEAP][I];
    RETURN(DAY);
{

MONTH_DAY(YEAR, YEARDAY, PMONTH, PDAY) /*SET MONTH,DAY */
INT YEAR, YEARDAY, *PMONTH, *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];
   *PMONTH = 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];
{
   ...
}

’ак  как количество строк ЯвлЯетсЯ несущественным, то описа-
ние аргумента в F могло бы быть таким:

 INT DAY_TAB[][13];

или таким

 INT (*DAY_TAB)[13];

в которм говоритсЯ, что аргумент ЯвлЯетсЯ указателем массива
из  13  целых.  Љруглые  скобки здесь необходимы, потому что
квадратные скобки [] имеют более высокий уровень  старшинст-
ва,  чем  *;  как мы увидим в следующем разделе, без круглых
скобок

 INT *DAY_TAB[13];

ЯвлЯетсЯ описанием массива из 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]; /*POINTERS 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 &lt; NLINES; I++)
    PRINTF("%S\N", LINEPTR[I]);
\)

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

 CHAR *LINEPTR[LINES];

которое сообщает, что LINEPTR ЯвлЯетсЯ массивом из LINES
элементов, каждый из которых - указатель на переменные типа
CHAR. ќто означает, что LINEPTR[I] - указатель на символы, а
*LINEPTR[I] извлекает символ.
    ’ак как сам LINEPTR ЯвлЯетсЯ массивом, который передает-
сЯ функции WRITELINES, с ним можно обращатьсЯ как с указате-
лем точно таким же образом, как в наших более ранних приме-


рах. ’огда последнюю функцию можно переписать в виде:

WRITELINES(LINEPTR, NLINES) /* WRITE OUTPUT LINES */
CHAR *LINEPTR[];
INT NLINES;
\(
 INT I;

 WHILE (--NLINES >= 0)
    PRINTF("%S\N", *LINEPTR++);
\)


здесь *LINEPTR сначала указывает на первую строку; каждое
увеличение передвигает указатель на следующую строку, в то
времЯ как NLINES убывает до нулЯ.
    ‘правившись с вводом и выводом, мы можем перейти к сор-
тировке. программа сортировки по шеллу из главы 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 &lt; N; I++)
     FOR (J = I - GAP; J >= 0; J -= GAP) \(
         IF (STRCMP(V[J], V[J+GAP]) &lt;= 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
    --------------
    Џерепишите функцию READLINES таким образом, чтобы она
помещала строки в массив, предоставлЯемый функцией MAIN, а
не в памЯть, управлЯемую обращениЯми к функции ALLOC. Ќа-
сколько быстрее стала программа?


        5.9. €нициализациЯ массивов указателей

    ђассмотрим задачу написаниЯ функции 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 &lt; 1 \!\! N > 12) ? NAME[0] : NAME[N]);
\)


Ћписание массива указателей на символы NAME точно такое же,
как аналогичное описание LINEPTR в примере с сортировкой.
€нициализатором ЯвлЯетсЯ просто список символьных строк;
каждаЯ строка присваиваетсЯ соответствующей позиции в масси-
ве. Ѓолее точно, символы I-ой строки помещаютсЯ в какое-то
иное место, а ее указатель хранитсЯ в NAME[I]. Џоскольку
размер массива NAME не указан, компилЯтор сам подсчитывает
количество инициализаторов и соответственно устанавливает
правильное число.


        5.10. “казатели и многомерные массивы

    Ќачинающие изучать Язык "с" иногда становЯтсЯ в тупик
перед вопросом о различии между двумерным массивом и масси-
вом указателей, таким как NAME в приведенном выше примере.
…сли имеютсЯ описаниЯ

INT A[10][10];
INT *B[10];

то A и B можно использовать сходным образом в том смысле,
что как A[5][5], так и B[5][5] ЯвлЯютсЯ законными ссылками
на отдельное число типа INT. Ќо A - настоЯщий массив: под
него отводитсЯ 100 Ячеек памЯти и длЯ нахождениЯ любого ука-
занного элемента проводЯтсЯ обычные вычислениЯ с прЯмоуголь-
ными индексами. „лЯ B, однако, описание выделЯет только 10
указателей; каждый указатель должен быть установлен так,
чтобы он указывал на массив целых. если предположить, что
каждый из них указывает на массив из 10 элементов, то тогда
где-то будет отведено 100 Ячеек памЯти плюс еще десЯть Ячеек
длЯ указателей. ’аким образом, массив указателей использует
несколько больший объем памЯти и может требовать наличие Яв-
ного шага инициализации. Ќо при этом возникают два преиму-
щества: доступ к элементу осуществлЯетсЯ косвенно через ука-
затель, а не посредством умножениЯ и сложениЯ, и строки мас-
сива могут иметь различные длины. ќто означает, что каждый
элемент B не должен обЯзательно указывать на вектор из 10
элементов; некоторые могут указывать на вектор из двух эле-
ментов, другие - из двадцати, а третьи могут вообще ни на
что не указывать.
    •отЯ мы вели это обсуждение в терминах целых, несомнен-
но, чаще всего массивы указателей используютсЯ так, как мы
продемонстрировали на функции MONTH_NAME, - длЯ хранениЯ
символьных строк различной длины.

    “пражнение 5-6
    --------------
    Џерепишите функции DAY_OF_YEAR и MONTH_DAY, используЯ
вместо индексации указатели.


        5.11. ЉоманднаЯ строка аргументов


    ‘истемные средства, на которые опираетсЯ реализациЯ Язы-
ка "с", позволЯют передавать командную строку аргументов или
параметров начинающей выполнЯтьсЯ программе. Љогда функциЯ
MAIN вызываетсЯ к исполнению, она вызываетсЯ с двумЯ аргу-
ментами. Џервый аргумент (условно называемый ARGC) указывает
число аргументов в командной строке, с которыми происходит
обращение к программе; второй аргумент (ARGV) ЯвлЯетсЯ ука-
зателем на массив символьных строк, содержащих эти аргумен-
ты, по одному в строке. ђабота с такими строками - это обыч-
ное использование многоуровневых указателей.
    ‘амую простую иллюстрацию этой возможности и необходимых
при этом описаний дает программа ECHO, котораЯ просто печа-
тает в одну строку аргументы командной строки, разделЯЯ их
пробелами. ’аким образом, если дана команда

 ECHO HELLO, WORLD

то выходом будет

 HELLO, WORLD

по соглашению ARGV[0] ЯвлЯетсЯ именем, по которому вызывает-
сЯ программа, так что ARGC по меньшей мере равен 1. ‚ приве-
денном выше примере ARGC равен 3, а ARGV[0], ARGV[1] и
ARGV[2] равны соответственно "ECHO", "HELLO," и "WORLD".
Џервым фактическим агументом ЯвлЯетсЯ ARGV[1], а последним -
ARGV[ARGC-1]. …сли ARGC равен 1, то за именем программы не
следует никакой командной строки аргументов. ‚се это показа-
но в ECHO:

MAIN(ARGC, ARGV) /* ECHO ARGUMENTS; 1ST VERSION */
INT ARGC;
CHAR *ARGV[];
\(
   INT I;

   FOR (I = 1; I &lt; ARGC; I++)
 PRINTF("%S%C", ARGV[I], (I&lt;ARGC-1) ? ' ' : '\N');
\)

Џоскольку ARGV ЯвлЯетсЯ указателем на массив указателей, то
существует несколько способов написаниЯ этой программы, ис-
пользующих работу с указателем, а не с индексацией массива.
Њы продемонстрируем два варианта.

MAIN(ARGC, ARGV) /* ECHO ARGUMENTS; 2ND 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; 3RD 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 FIRST 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);
 \)

    ’еперь может быть развита основнаЯ модель, иллюстрирую-
щаЯ дальнейшее использование указателей. Џредположим, что
нам надо предусмотреть два необЯзательных аргумента. Ћдин
утверждает: "напечатать все строки за исключением тех, кото-
рые содержат данную комбинацию", второй гласит: "перед каж-
дой выводимой строкой должен печататьсЯ ее номер".


    ЋбщепринЯтым соглашением в "с"-программах ЯвлЯетсЯ то,
что аргумент, начинающийсЯ со знака минус, вводит необЯза-
тельный признак или параметр. …сли мы, длЯ того, чтобы сооб-
щить об инверсии, выберем -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 FIRST 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 + *

вычислЯет 2*(3+4).


    “пражнение 5-8
    --------------
    Њодифицируйте программы ENTAB и DETAB (указанные в ка-
честве упражнений в главе 1) так, чтобы они получали список
табулЯционных остановок в качестве аргументов. …сли аргумен-
ты отсутствуют, используйте стандартную установку табулЯций.

    “пражнение 5-9
    --------------
    ђасширьте ENTAB и DETAB таким образом, чтобы они воспри-
нимали сокращенную нотацию

 ENTAB M +N


означающую табулЯционные остановки через каждые N столбцов,
начинаЯ со столбца M. ‚ыберите удобное (длЯ пользователЯ)
поведение функции по умолчанию.

    “пражнение 5-10
    ---------------
    Ќапишите программу длЯ функции TAIL, печатающей послед-
ние N строк из своего файла ввода. Џусть по умолчанию N рав-
но 10, но это число может быть изменено с помощью необЯза-
тельного аргумента, так что

 TAIL -N

печатает последние N строк. программа должна действовать ра-
ционально, какими бы неразумными ни были бы ввод или значе-
ние N. ‘оставьте программу так, чтобы она оптимальным обра-
зом использовала доступную памЯть: строки должны хранитьсЯ,
как в функции SORT, а не в двумерном массиве фиксированного
размера.


        5.12. “казатели на функции

    ‚ Языке "с" сами функции не ЯвлЯютсЯ переменными, но
имеетсЯ возможность определить указатель на функцию, который
можно обрабатывать, передавать другим функциЯм, помещать в
массивы и т.д. Њы проиллюстрируем это, проведЯ модификацию
написанной ранее программы сортировки так, чтобы при задании
необЯзательного аргумента -N она бы сортировала строки ввода
численно, а не лексикографически.
    ‘ортировка часто состоит из трех частей - сравнениЯ, ко-
торое определЯет упорЯдочивание любой пары объектов, перес-
тановки, изменЯющей их порЯдок, и алгоритма сортировки, осу-
ществлЯющего сравнениЯ и перестановки до тех пор, пока
объекты не расположатсЯ в нужном порЯдке. Ђлгоритм сортиров-
ки не зависит от операций сравнениЯ и перестановки, так что,
передаваЯ в него различные фу