Язык С

{

(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)

};


  • 113 -


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, 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. Так как за экономию памяти у нас пока не награждают, такой способ проще, чем подгонка индек-сов.

Если двумерный массив передается функции, то описание

соответствующего аргумента функции должно содержать количес-

тво столбцов; количество строк несущественно, поскольку, как

и прежде, фактически передается указатель. В нашем конкрет-

ном случае это указатель объектов, являющихся массивами из


  • 114 -


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.


  • 115 -


Если две расположенные в неправильном порядке строки должны

быть переставлены, то фактически переставляются указатели в

массиве указателей, а не сами тексты строк. Этим исключаются

сразу две связанные проблемы: сложного управления памятью и

больших дополнительных затрат на фактическую перестановку

строк.

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

чтение всех строк ввода

их сортировка

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


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

соответствии с естественным делением задачи и выделить веду-

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

Давайте отложим на некоторое время рассмотрение шага сорти-

ровки и сосредоточимся на структуре данных и вводе-выводе.

Функция, осуществляющая ввод, должна извлечь символы каждой

строки, запомнить их и построить массив указателей строк.

Она должна также подсчитать число строк во вводе, так как

эта информация необходима при сортировке и выводе. так как

функция ввода в состоянии справиться только с конечным чис-

лом вводимых строк, в случае слишком большого их числа она

может возвращать некоторое число, отличное от возможного

числа строк, например -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 SORTN”);

)


#DEFINE MAXLEN 1000


  • 116 -


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] = ''; /* 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(“%SN”, LINEPTR[I]);

)


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

CHAR *LINEPTR[LINES];

которое сообщает, что LINEPTR является массивом из LINES

элементов, каждый из которых - указатель на переменные типа

CHAR. Это означает, что LINEPTR[I] - указатель на символы, а

*LINEPTR[I] извлекает символ.

Так как сам LINEPTR является массивом, который передает-

ся функции WRITELINES, с ним можно обращаться как с указате-

лем точно таким же образом, как в наших более ранних приме-


  • 117 -


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

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

INT NLINES;

(

INT I;

WHILE (--NLINES >= 0)

PRINTF(“%SN”, *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 < 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, а затем в скрытое место с помощью фун-


  • 118 -


кции 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 < 1 !! N > 12) ? NAME[0] : NAME[N]);

)


  • 119 -


Описание массива указателей на символы 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, используя

вместо индексации указатели.


  • 120 -


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 < ARGC; I++)

PRINTF(“%S%C”, ARGV[I], (I

)


Поскольку ARGV является указателем на массив указателей, то

существует несколько способов написания этой программы, ис-

пользующих работу с указателем, а не с индексацией массива.

Мы продемонстрируем два варианта.


MAIN(ARGC, ARGV) /* ECHO ARGUMENTS; 2ND VERSION */

INT ARGC;

CHAR *ARGV[];

(

WHILE (--ARGC > 0)

PRINTF(“%S%C”,*++ARGV, (ARGC > 1) ? ' ' : 'N');

)


  • 121 -


Так как 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” : “%SN”, *++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 PATTERNN”);

ELSE

WHILE (GETLINE(LINE, MAXLINE) > 0)

IF (INDEX(LINE, ARGV[1] >= 0)

PRINTF(“%S”, LINE);

)


Теперь может быть развита основная модель, иллюстрирую-

щая дальнейшее использование указателей. Предположим, что

нам надо предусмотреть два необязательных аргумента. Один

утверждает: “напечатать все строки за исключением тех, кото-

рые содержат данную комбинацию”, второй гласит: “перед каж-

дой выводимой строкой должен печататься ее номер”.


  • 122 -


Общепринятым соглашением в “с”-программах является то,

что аргумент, начинающийся со знака минус, вводит необяза-

тельный признак или параметр. Если мы, для того, чтобы сооб-

щить об инверсии, выберем -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 != ''; S++)

SWITCH (*S) (

CASE 'X':

EXCEPT = 1;

BREAK;


  • 123 -


CASE 'N':

NUMBER = 1;

BREAK;

DEFAULT:

PRINTF(“FIND: ILLEGAL OPTION %CN”, *S);

ARGC = 0;

BREAK;

)

IF (ARGC != 1)

PRINTF(“USAGE: FIND -X -N PATTERNN”);

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


  • 124 -


означающую табуляционные остановки через каждые N столбцов,

начиная со столбца M. Выберите удобное (для пользователя)

поведение функции по умолчанию.

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

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

ние N строк из своего файла ввода. Пусть по умолчанию N рав-

но 10, но это число может быть изменено с помощью необяза-

тельного аргумента, так что


TAIL -N

печатает последние N строк. программа должна действовать ра-

ционально, какими бы неразумными ни были бы ввод или значе-

ние N. Составьте программу так, чтобы она оптимальным обра-

зом использовала доступную память: строки должны храниться,

как в функции SORT, а не в двумерном массиве фиксированного

размера.


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

В языке “с” сами функции не являются переменными, но

имеется возможность определить указатель на функцию, который

можно обрабатывать, передавать другим функциям, помещать в

массивы и т.д. Мы проиллюстрируем это, проведя модификацию

написанной ранее программы сортировки так, чтобы при задании

необязательного аргумента -N она бы сортировала строки ввода

численно, а не лексикографически.

Сортировка часто состоит из трех частей - сравнения, ко-

торое определяет упорядочивание любой пары объектов, перес-

тановки, изменяющей их порядок, и алгоритма сортировки, осу-

ществляющего сравнения и перестановки до тех пор, пока

объекты не расположатся в нужном порядке. Алгоритм сортиров-

ки не зависит от операций сравнения и перестановки, так что,

передавая в него различные функции сравнения и перестановки,

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

Именно такой подход используется в нашей новой программе

сортировки.

Как и прежде, лексикографическое сравнение двух строк

осуществляется функцией STRCMP, а перестановка функцией

SWAP; нам нужна еще функция NUMCMP, сравнивающая две строки

на основе численного значения и возвращающая условное указа-

ние того же вида, что и STRCMP. Эти три функции описываются

в MAIN и указатели на них передаются в SORT. В свою очередь

функция SORT обращается к этим функциям через их указатели.

мы урезали обработку ошибок в аргументах с тем, чтобы сосре-

доточиться на главных вопросах.


  • 125 -


#DEFINE LINES 100 /* MAX NUMBER OF LINES

TO BE SORTED */

MAIN(ARGC, ARGV) /* SORT INPUT LINES */ INT ARGC;

CHAR *ARGV[];

(

CHAR LINEPTR[LINES]; / POINTERS 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 SORTN”);

)


Здесь STRCMP, NIMCMP и 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]);

)

)


  • 126 -


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

ния. Описание

INT (*COMP)()

говорит, что COMP является указателем на функцию, которая

возвращает значение типа INT. Первые круглые скобки здесь

необходимы; без них описание


INT *COMP()

говорило бы, что COMP является функцией, возвращающей указа-

тель на целые, что, конечно, совершенно другая вещь.

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

IF (*COMP)(V[J], V[J+GAP]) <= 0)

полностью согласуется с описанием: COMP - указатель на функ-

цию, *COMP - сама функция, а


(*COMP)(V[J], V[J+GAP])

  • обращение к ней. Круглые скобки необходимы для правильного

объединения компонентов.

Мы уже приводили функцию STRCMP, сравнивающую две строки

по первому численному значению:

NUMCMP(S1, S2) /* COMPARE S1

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: