Содержание

Приложение A. Справочное руководство по языку C

A1. Введение

Это руководство описывает язык C для компьютеров DEC PDP-11, Honeywell 6000, IBM System/370 и Interdata 8/32. там, где есть расхождения, мы сосредотачиваемся на версии для PDP-11, стремясь в то же время указать детали, которые зависят от реализации. За малым исключением, эти расхождения непосредственно обусловлены основными свойствами используемого аппаратного оборудования; различные компиляторы обычно вполне совместимы.

A2. Лексические соглашения

Имеется шесть классов лексем: идентификаторы, ключевые слова, константы, строки, операции и другие разделители. Пробелы, табуляции, новые строки и комментарии (совместно, «пустые промежутки»), как описано ниже, игнорируются, за исключением тех случаев, когда они служат разделителями лексем. Необходим какой-то пустой промежуток для разделения идентификаторов, ключевых слов и констант, которые в противном случае сольются.

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

A2.1. Комментарии

Комментарий открывается символами /* и заканчивается символами */. Комментарии не вкладываются друг в друга.

A2.2. Идентификаторы (имена)

Идентификатор — это последовательность букв и цифр; первый символ должен быть буквой. Подчеркивание «_» считается буквой. Буквы нижнего и верхнего регистров различаются. Значащими являются не более, чем первые восемь символов, хотя можно использовать и больше. На внешние идентификаторы, которые используются различными ассемблерами и загрузчиками, накладываются более жесткие ограничения:

DEC PDP-11 7 символов, 2 регистра
Honeywell 6000 6 символов, 1 регистр
IBM 360/370 7 символов, 1 регистр
Interdata 8/32 8 символов, 2 регистра

A2.3. Ключевые слова

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

int         extern       else
char        register     for
float       typedef      do
double      static       while
struct      goto         switch
union       return       case
long        sizeof       default
short       break        entry
unsigned    continue
*auto       if

Ключевое слово entry в настоящее время не используется каким-либо компилятором; оно зарезервировано для использования в будущем. В некоторых реализациях резервируется также слова fortran и asm.

A2.4. Константы

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

A2.4.1. Целые константы

Целая константа, состоящая из последовательности цифр, считается восьмеричной, если она начинается с 0 (цифра нуль), и десятичной в противном случае. Цифры 8 и 9 имеют восьмеричные значения 10 и 11 соответственно. Последовательность цифр, которой предшествуют символы 0x (нуль, x-маленькое) или 0X (нуль X-большое), рассматривается как шестнадцатиричное целое. Шестнадцатиричные цифры включают буквы от a (маленькое) или A (большое) до f (маленькое) или F (большое) со значениями от 10 до 15. Десятичная константа, величина которой превышает наибольшее машинное целое со знаком, считается длинной; восьмеричная или шестнадцатиричная константа, которое превышает наибольшее машинное целое без знака, также считается длинной.

A2.4.2. Явные длинные константы

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

A2.4.3. Символьные константы

Символьная константа — это символ, заключенный в одиночные кавычки, как, например, 'x'. Значением символьной константы является численное значение этого символа в машинном представлении набора символов.

Некоторые неграфические символы, одиночная кавычка ' и обратная косая черта \ могут быть представлены в соответствии со следующей таблицей условных последовательностей:

новая строка NL (LF) \n
горизонтальная табуляция HT \t
символ возврата на одну позицию BS \b
возврат каретки CR \r
переход на новую страницу FF \f
обратная косая черта \ \\
одиночная кавычка ' \'
комбинация битов ddd \ddd

Условная последовательность \ddd состоит из обратной косой черты, за которой следуют 1, 2 или 3 восьмеричных цифры, которые рассматриваются как задающие значение желаемого символа. Специальным случаем этой конструкции является последовательность \0 (за нулем не следует цифра), которая определяет символ NUL. если следующий за обратной косой чертой символ не совпадает с одним из указанных, то обратная косая черта игнорируется.

A2.4.4. Плавающие константы

Плавающая константа состоит из целой части, десятичной точки, дробной части, буквы e (маленькая) или E (большая) и целой экспоненты с необязательным знаком. Как целая, так и дробная часть являются последовательностью цифр. Либо целая, либо дробная часть (но не обе) может отсутствовать; либо десятичная точка, либо e (маленькая) и экспонента (но не то и другое одновременно) может отсутствовать. Каждая плавающая константа считается имеющей двойную точность.

A2.5. Строки

Строка — это последовательность символов, заключенная в двойные кавычки, как, например, "...". Строка имеет тип «массив символов» и класс памяти static (см. Пункт 4 ниже). Строка инициализирована указанными в ней символами. Все строки, даже идентично записанные, считаются различными. Компилятор помещает в конец каждой строки нулевой байт \0, с тем чтобы просматривающая строку программа могла определить ее конец. Перед стоящим внутри строки символом двойной кавычки " должен быть поставлен символ обратной косой черты \; кроме того, могут использоваться те же условия последовательности, что и в символьных константах. И последнее, обратная косая черта \, за которой непосредственно следует символ новой строки, игнорируется.

A2.6. Характеристики аппаратных средств

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

Таблица 1

DEC PDP-11 Honeywell IBM 370 Interdata 8/32
ASCII ASCII EBCDIC ASCII
char 8 бит 9 бит 8 бит 8 бит
int 16 36 32 32
short 16 36 16 16
long 32 36 32 32
float 32 36 32 32
double 64 72 64 64
range -38/+38 -38/+38 -76/+76 -76/+76

A3. Синтаксическая нотация

В используемой в этом руководстве синтаксической нотации синтаксические категории выделяются курсивом (прим. перев.: в настоящее время синтаксические категории вместо курсива выделяются подчеркиванием, а литерные слова и символы — жирным шрифтом). Альтернативные категории перечисляются на отдельных строчках. Необязательный символ, терминальный или нетерминальный, указывается индексом «необ», так что

{ выражениенеоб }

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

A4. Что в имени тебе моем?

Язык C основывает интерпретацию идентификатора на двух признаках идентификатора: его классе памяти и его типе. Класс памяти определяет место и время хранения памяти, связанной с идентификатором; тип определяет смысл величин, находящихся в памяти, определенной под идентификатором.

Имеются четыре класса памяти: автоматическая, статическая, внешняя и регистровая. Автоматические переменные являются локальными для каждого вызова блока и исчезают при выходе из этого блока. Статические переменные являются локальными, но сохраняют свои значения для следующего входа в блок даже после того, как управление передается за пределы блока. Внешние переменные существуют и сохраняют свои значения в течение выполнения всей программы и могут использоваться для связи между функциями, в том числе и между независимо скомпилированными функциями. Регистровые переменные хранятся (ели это возможно) в быстрых регистрах машины; подобно автоматическим переменным они являются локальными для каждого блока и исчезают при выходе из этого блока.

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

Можно использовать до трех размеров целых, описываемых как short int, int и long int. Длинные целые занимают не меньше памяти, чем короткие, но в конкретной реализации может оказаться, что либо короткие целые, либо длинные целые, либо те и другие будут эквивалентны простым целым. «Простые» целые имеют естественный размер, предусматриваемый архитектурой используемой машины; другие размеры вводятся для удовлетворения специальных потребностей. Целые без знака, описываемые как unsigned, подчиняются законам арифметики по модулю 2**n, где n — число битов в их представлении. (На PDP-11 длинные величины без знака не предусмотрены). Плавающие одинарной точности (float) и плавающие двойной точности (double) в некоторых реализациях могут быть синонимами. Поскольку объекты упомянутых выше типов могут быть разумно интерпретированы как числа, эти типы будут называться арифметическими. Типы char и int всех размеров совместно будут называться целочисленными. Типы float и double совместно будут называться плавающими типами. Кроме основных арифметических типов существует концептуально бесконечный класс производных типов, которые образуются из основных типов следующим образом:

Вообще говоря, эти методы построения объектов могут применяться рекурсивно.

A5. Объекты и l-значения

Объект является доступным обработке участком памяти; l-значение — это выражение, ссылающееся на объект. Очевидным примером выражения l-значения является идентификатор. Существуют операции, результатом которых являются l-значения; если, например, E — выражение указанного типа, то *E является выражением l-значения, ссылающимся на объект E. Название «l-значение» происходит от выражения присваивания E1 = E2, в котором левая часть должна быть выражением l-значения. При последующем обсуждении каждой операции будет указываться, ожидает ли она операндов l-значения и выдает ли она l-значение.

A6. Преобразования

Ряд операций может в зависимости от своих операндов вызывать преобразование значение операнда из одного типа в другой. В этом разделе объясняются результаты, которые следует ожидать от таких преобразований. В п. A6.6 подводятся итоги преобразований, требуемые большинством обычных операций; эти сведения дополняются необходимым образом при обсуждении каждой операции.

A6.1. Символы и целые

Символ или короткое целое можно использовать всюду, где можно использовать целое. Во всех случаях значение преобразуется к целому. Преобразование более короткого целого к более длинному всегда сопровождается знаковым расширением; целые являются величинами со знаком. Осуществляется или нет знаковое расширение для символов, зависит от используемой машины, но гарантируется, что член стандартного набора символов неотрицателен. Из всех машин, рассматриваемых в этом руководстве, только PDP-11 осуществляет знаковое расширение. Область значений символьных переменных на PDP-11 меняется от -128 до 127; символы из набора ASCII имеют положительные значения. Символьная константа, заданная с помощью восьмеричной условной последовательности, подвергается знаковому расширению и может оказаться отрицательной; например, '\377' имеет значение -1.

Когда более длинное целое преобразуется в более короткое или в char, оно обрезается слева; лишние биты просто отбрасываются.

A6.2. Типы float и double

Вся плавающая арифметика в C выполняется с двойной точностью каждый раз, когда объект типа float появляется в выражении, он удлиняется до double посредством добавления нулей в его дробную часть. Когда объект типа double должен быть преобразован к типу float, например, при присваивании, перед усечением double округляется до длины float.

A6.3. Плавающие и целочисленные величины

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

A6.4. Указатели и целые

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

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

A6.5. Целое без знака

Всякий раз, когда целое без знака объединяется с простым целым, простое целое преобразуется в целое без знака и результат оказывается целым без знака. Значением является наименьшее целое без знака, соответствующее целому со знаком (по модулю 2 ** размер слова). В двоичном дополнительном представлении это преобразование является чисто умозрительным и не изменяет фактическую комбинацию битов.

Когда целое без знака преобразуется к типу long, значение результата совпадает со значением целого без знака. Таким образом, это преобразование сводится к добавлению нулей слева.

A6.6. Арифметические преобразования

Подавляющее большинство операций вызывает преобразование и определяет типы результата аналогичным образом. Приводимая ниже схема в дальнейшем будет называться «обычными арифметическими преобразованиями». Сначала любые операнды типа char или short преобразуются в int, а любые операнды типа float преобразуются в double. Затем, если какой-либо операнд имеет тип double, то другой преобразуется к типу double, и это будет типом результата. В противном случае, если какой-либо операнд имеет тип long, то другой операнд преобразуется к типу long, и это и будет типом результата. В противном случае, если какой-либо операнд имеет тип unsigned, то другой операнд преобразуется к типу unsigned, и это будет типом результата. В противном случае оба операнда будут иметь тип int, и это будет типом результата.

A7. Выражения

Старшинство операций в выражениях совпадает с порядком следования основных подразделов настоящего раздела, начиная с самого высокого уровня старшинства. Так, например, выражениями, указываемыми в качестве операндов операции + (п. A7.4), Являются выражения, определенные в п.п. A7.1-A7.3. Внутри каждого подраздела операции имеет одинаковое старшинство. В каждом подразделе для описываемых там операций указывается их ассоциативность слева или справа. Старшинство и ассоциативность всех операций в выражениях резюмируются в грамматической сводке в п. A10.

В противном случае порядок вычислений выражений не определен. В частности, компилятор считает себя в праве вычислять подвыражения в том порядке, который он находит наиболее эффективным, даже если эти подвыражения приводят к побочным эффектам. Порядок, в котором происходят побочные эффекты, не специфицируется. Выражения, включающие коммутативные и ассоциативные операции (*, +, &, !, ^), могут быть переупорядочены произвольным образом даже при наличии круглых скобок; чтобы вынудить определенный порядок вычислений, в этом случае необходимо использовать явные промежуточные переменные. При вычислении выражений обработка переполнения и проверка при делении являются машинно-зависимыми. Все существующие реализации языка C игнорируют переполнение целых; обработка ситуаций при делении на 0 и при всех особых случаях с плавающими числами меняется от машины к машине и обычно выполняется с помощью библиотечной функции.

A7.1. Первичные выражения

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

Первичное выражение:
идентификатор
константа
строка
(выражение)
первичное-выражение [выражение]
первичное-выражение (список-выражений)необ
первичное-l-значение.Идентификатор
первичное-выражение -> идентификатор
список-выражений:
выражение
список-выражений, выражение

Идентификатор является первичным выражением при условии, что он описан подходящим образом, как это обсуждается ниже. Тип идентификатора определяется его описанием. Если, однако, типом идентификатора является «массив ...», то значением выражения, состоящего из этого идентификатора, является указатель на первый объект в этом массиве, а типом выражения будет «указатель на ...». Более того, идентификатор массива не является выражением l-значения. подобным образом идентификатор, который описан как «функция, возвращающая ...», за исключением того случая, когда он используется в позиции имени функции при обращении, преобразуется в «указатель на функцию, которая возвращает ...».

Константа является первичным выражением. В зависимости от ее формы типом константы может быть int, long или double.

Строка является первичным выражением. Исходным ее типом является «массив символов»; но следуя тем же самым правилам, которые приведены выше для идентификаторов, он модифицируется в «указатель на символы», и результатом является указатель на первый символ строки. (Имеется исключение в некоторых инициализаторах; см. п. A8.6.)

Выражение в круглых скобках является первичным выражением, тип и значение которого идентичны типу и значению этого выражения без скобок. Наличие круглых скобок не влияет на то, является ли выражение l-значением или нет.

Первичное выражение, за которым следует выражение в квадратных скобках, является первичным выражением. Интуитивно ясно, что это выражение с индексом. Обычно первичное выражение имеет тип «указатель на ...», индексное выражение имеет тип int, а типом результата является «...». Выражение E1[E2] по определению идентично выражению *((E1) + (E2)). Все, что необходимо для понимания этой записи, содержится в этом разделе; вопросы, связанные с понятием идентификаторов и операций * и + рассматриваются в п.п. A7.1, A7.2 и A7.4 соответственно; выводы суммируются ниже в п. A14.3.

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

Перед обращением любые фактические аргументы типа float преобразуются к типу double, любые аргументы типа char или short преобразуются к типу int, и, как обычно, имена массивов преобразуются в указатели. Никакие другие преобразования не выполняются автоматически; в частности, не сравнивает типы фактических аргументов с типами формальных аргументов. Если преобразование необходимо, используйте явный перевод типа (cast); см. п.п. A7.2, A8.7.

При подготовке к вызову функции делается копия каждого фактического параметра; таким образом, все передачи аргументов в языке C осуществляются строго по значению. Функция может изменять значения своих формальных параметров, но эти изменения не влияют на значения фактических параметров. С другой стороны имеется возможность передавать указатель при таком условии, что функция может изменять значение объекта, на который этот указатель указывает. Порядок вычисления аргументов в языке не определен; обратите внимание на то, что различные компиляторы вычисляют по разному.

Допускаются рекурсивные обращения к любой функции. Первичное выражение, за которым следует точка и идентификатор, является выражением. Первое выражение должно быть l-значением, именующим структуру или объединение, а идентификатор должен быть именем члена структуры или объединения. Результатом является l-значение, ссылающееся на поименованный член структуры или объединения.

Первичное выражение, за которым следует стрелка (составленная из знаков '-' и '>') и идентификатор, является выражением. Первое выражение должно быть указателем на структуру или объединение, а идентификатор должен именовать член этой структуры или объединения. Результатом является l-значение, ссылающееся на поименованный член структуры или объединения, на который указывает указательное выражение.

Следовательно, выражение E1->MOS является тем же самым, что и выражение (*E1).MOS. Структуры и объединения рассматриваются в п. A8.5. Приведенные здесь правила использования структур и объединений не навязываются строго, для того чтобы иметь возможность обойти механизм типов. См. п. A14.1.

A7.2. Унарные операции

Выражение с унарными операциями группируется справа налево.

Унарное-выражение:
* выражение
& l-значение
- выражение
! Выражение
~ выражение
++ l-значение
-- l-значение
l-значение ++
l-значение --
(имя-типа) выражение
sizeof выражение
sizeof имя-типа

Унарная операция * означает косвенную адресацию: выражение должно быть указателем, а результатом является l-значение, ссылающееся на тот объект, на который указывает выражение. Если типом выражения является «указатель на ...», то типом результата будет «...».

Результатом унарной операции & является указатель на объект, к которому ссылается l-значение. Если l-значение имеет тип «...», то типом результата будет «указатель на ...».

Результатом унарной операции - (минус) является ее операнд, взятый с противоположным знаком. Для величины типа unsigned результат получается вычитанием ее значения из 2**n (два в степени n), где n — число битов в int. Унарной операции + (плюс) не существует.

Результатом операции логического отрицания ! Является 1, если значение ее операнда равно 0, и 0, если значение ее операнда отлично от нуля. Результат имеет тип int. Эта операция применима к любому арифметическому типу или указателям.

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

Объект, на который ссылается операнд l-значения префиксной операции ++, увеличивается. Значением является новое значение операнда, но это не l-значение. Выражение ++x эквивалентно x += 1. Информацию о преобразованиях смотри в разборе операции сложения (п. A7.4) и операции присваивания (п. A7.14).

Префиксная операция -- аналогична префиксной операции ++, но приводит к уменьшению своего операнда l-значения.

При применении постфиксной операции ++ к l-значению результатом является значение объекта, на который ссылается l-значение. После того, как результат принят к сведению, объект увеличивается точно таким же образом, как и в случае префиксной операции ++. Результат имеет тот же тип, что и выражение l-значения.

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

Заключенное в круглые скобки имя типа данных, стоящее перед выражением, вызывает преобразование значения этого выражения к указанному типу. Эта конструкция называется перевод (cast). Имена типов описываются в п. A8.7.

Операция sizeof выдает размер своего операнда в байтах. (Понятие байт в языке не определено, разве только как значение операции sizeof. Однако во всех существующих реализациях байтом является пространство, необходимое для хранения объекта типа char). При применении к массиву результатом является полное число байтов в массиве. Размер определяется из описаний объектов в выражении. Это выражение семантически является целой константой и может быть использовано в любом месте, где требуется константа. Основное применение эта операция находит при связях с процедурами, подобным распределителям памяти, и в системах ввода/вывода.

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

Конструкция sizeof(тип) рассматривается как целое, так что выражение sizeof(тип) - 2 эквивалентно выражению (sizeof(тип)) - 2.

A7.3. Мультипликативные операции

Мультипликативные операции *, /, и % группируются слева направо. Выполняются обычные арифметические преобразования.

Мультипликативное-выражение:
выражение * выражение
выражение / выражение
выражение % выражение

Бинарная операция * означает умножение. Операция * ассоциативна, и выражения с несколькими умножениями на одном и том же уровне могут быть перегруппированы компилятором.

Бинарная операция / означает деление. При делении положительных целых осуществляется усечение по направлению к нулю, но если один из операндов отрицателен, то форма усечения зависит от используемой машины. На всех машинах, охватываемых настоящим руководством, остаток имеет тот же знак, что и делимое. Всегда справедливо, что (a / b) * b + a % b равно a (если b не равно 0).

Бинарная операция % выдает остаток от деления первого выражения на второе. Выполняются обычные арифметические преобразования. Операнды не должны быть типа float.

A7.4. Аддитивные операции

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

Аддитивное-выражение:
выражение + выражение
выражение - выражение

Результатом операции + является сумма операндов. Можно складывать указатель на объект в массиве и значение любого целочисленного типа. Во всех случаях последнее преобразуется в адресное смещение посредством умножения его на длину объекта, на который указывает этот указатель. Результатом является указатель того же самого типа, что и исходный указатель, который указывает на другой объект в том же массиве, смещенный соответствующим образом относительно первоначального объекта. Таким образом, если p является указателем объекта в массиве, то выражение p + 1 является указателем на следующий объект в этом массиве.

Никакие другие комбинации типов для указателей не разрешаются.

Операция + ассоциативна, и выражение с несколькими сложениями на том же самом уровне могут быть переупорядочены компилятором.

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

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

A7.5. Операции сдвига

Операции сдвига << и >> группируются слева направо. Для обеих операций проводятся обычные арифметические преобразования их операндов, каждый из которых должен быть целочисленного типа. Затем правый операнд преобразуется к типу int; результат имеет тип левого операнда. Результат не определен, если правый операнд отрицателен или больше или равен, чем длина объекта в битах.

Выражение-сдвига:
выражение << выражение
выражение >> выражение

Значением выражения E1 << E2 является E1 (интерпретируемое как комбинация битов), сдвинутое влево на E2 битов; освобождающиеся биты заполняются нулем. Значением выражения E1 >> E2 является E1, сдвинутое вправо на E2 битовых позиций. Если E1 имеет тип unsigned, то сдвиг вправо гарантированно будет логическим (заполнение нулем); в противном случае сдвиг может быть (и так и есть на PDP-11) арифметическим (освобождающиеся биты заполняются копией знакового бита).

A7.6. Операции отношения

Операции отношения группируются слева направо, но этот факт не очень полезен; выражение a < b < c не означает того, что оно казалось бы должно означать.

Выражение-отношения:
выражение < выражение
выражение > выражение
выражение <= выражение
выражение >= выражение

Операции < (меньше), > (больше), <= (меньше или равно) и >= (больше или равно) все дают 0, если указанное отношение ложно, и 1, если оно истинно. Результат имеет тип int. Выполняются обычные арифметические преобразования. Могут сравниваться два указателя; результат зависит от относительного расположения указываемых объектов в адресном пространстве. Сравнение указателей переносимо только в том случае, если указатели указывают на объекты из одного и того же массива.

A7.7. Операции равенства

Выражение-равенства:
выражение == выражение
выражение != выражение

Операции == (равно) и != (не равно) в точности аналогичны операциям отношения, за исключением того, что они имеют более низкий уровень старшинства. (Поэтому значение выражения a < b == c < d равно 1 всякий раз, когда выражение a < b и c < d имеют одинаковое значение истинности).

Указатель можно сравнивать с целым, но результат будет машинно-независимым только в том случае, если целым является константа 0. Гарантируется, что указатель, которому присвоено значение 0, не указывает ни на какой объект и на самом деле оказывается равным 0; общепринято считать такой указатель нулем.

A7.8. Побитовая операция И

Выражение-И:
выражение & выражение

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

A7.9. Побитовая операция исключающего ИЛИ

Выражение-исключающего-ИЛИ:
выражение ^ выражение

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

A7.10. Побитовая операция включающего ИЛИ

Выражение-включающего-ИЛИ:
выражение | Выражение

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

A7.11. Логическая операция И

Выражение-логического-И:
выражение && выражение

Операция && группируется слева направо. Она возвращает 1, если оба ее операнда отличны от нуля, и 0 в противном случае. В отличие от & операция && гарантирует вычисление слева направо; более того, если первый операнд равен 0, то значение второго операнда вообще не вычисляется.

Операнды не обязаны быть одинакового типа, но каждый из них должен быть либо одного из основных типов, либо указателем. Результат всегда имеет тип int.

A7.12. Операция логического ИЛИ

Выражение-логического-ИЛИ:
выражение || выражение

Операция || группируется слева направо. Она возвращает 1, если один из операндов отличен от нуля, и 0 в противном случае. В отличие от операции | операция || гарантирует вычисление слева направо; более того, если первый операнд отличен от нуля, то значение второго операнда вообще не вычисляется.

Операнды не обязаны быть одинакового типа, но каждый из них должен быть либо одного из основных типов, либо указателем. Результат всегда имеет тип int.

A7.13. Условная операция

Условное-выражение:
выражение ? выражение : выражение

Условные выражения группируются слева направо. Вычисляется значение первого выражения, и если оно отлично от нуля, то результатом будет значение второго выражения; в противном случае результатом будет значение третьего выражения. Если это возможно, проводятся обычные арифметические преобразования, с тем, чтобы привести второе и третье выражения к общему типу; в противном случае, если оба выражения являются указателями одинакового типа, то результат имеет тот же тип; в противном случае одно выражение должно быть указателем, а другое — константой 0, и результат будет иметь тип указателя. Вычисляется только одно из второго и третьего выражений.

A7.14. Операция присваивания

Имеется ряд операций присваивания, каждая из которых группируется слева направо. Все операции требуют в качестве своего левого операнда l-значение, а типом выражения присваивания является тип его левого операнда. Значением выражения присваивания является значение, хранимое в левом операнде после того, как присваивание уже будет произведено. Две части составной операции присваивания являются отдельными лексемами.

Выражение-присваивания:
l-значение = выражение
l-значение += выражение
l-значение -= выражение
l-значение *= выражение
l-значение /= выражение
l-значение %= выражение
l-значение >>= выражение
l-значение <<= выражение
l-значение &= выражение
l-значение ^= выражение
l-значение |= выражение

Когда производится простое присваивание «c =», значение выражения заменяет значение объекта, на которое ссылается l-значение. Если оба операнда имеют арифметический тип, то перед присваиванием правый операнд преобразуется к типу левого операнда.

О свойствах выражения вида E1 op= E2, где op — одна из перечисленных выше операций, можно сделать вывод, если учесть, что оно эквивалентно выражению E1 = E1 op (E2); однако выражение E1 вычисляется только один раз. В случае операций += и -= левый операнд может быть указателем, причем при этом (целочисленный) правый операнд преобразуется таким образом, как объяснено в п. A7.4; все правые операнды и все отличные от указателей левые операнды должны иметь арифметический тип.

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

A7.15. Операция запятая

Выражение-с-запятой:
выражение , выражение

Пара выражений, разделенных запятой, вычисляется слева направо и значение левого выражения отбрасывается. Типом и значением результата является тип и значение правого операнда. Эта операция группируется слева направо. В контексте, где запятая имеет специальное значение, как, например, в списке фактических аргументов функций (п. A7.1) Или в списках инициализаторов (п. A8.6), Операция запятая, описываемая в этом разделе, может появляться только в круглых скобках; например, функция

f(a, (t=3, t+2), c)

имеет три аргумента, второй из которых имеет значение 5.

A8. Описания

Описания используются для указания интерпретации, которую язык C будет давать каждому идентификатору; они не обязательно резервируют память, соответствующую идентификатору. Описания имеют форму

Описание:
[спецификаторы-описания] список-описателей;

Описатели в списке описателей содержат описываемые идентификаторы. Спецификаторы описания представляют собой последовательность спецификаторов типа и спецификаторов класса памяти.

Спецификаторы-описания:
[спецификатор-типа] спецификаторы-описания
[спецификатор-класса-памяти] спецификатор-описания

список должен быть самосогласованным в смысле, описываемом ниже.

A8.1. Спецификаторы класса памяти

Ниже перечисляются спецификаторы класса памяти:

Спецификатор-класса-памяти:
auto
static
extern
register
typedef

Спецификатор typedef не реализует памяти и называется «спецификатором класса памяти» только по синтаксическим соображениям; это обсуждается в п. A8.8. Смысл различных классов памяти был обсужден в п. 12.

Описания auto, static и register служат также в качестве определений в том смысле, что они вызывают резервирование нужного количества памяти. В случае extern должно присутствовать внешнее определение (п. 18) Указываемых идентификаторов где-то вне функции, в которой они описаны.

Описание register лучше всего представлять себе как описание auto вместе с намеком компилятору, что описанные таким образом переменные будут часто использоваться. Эффективны только несколько первых таких описаний. Кроме того, в регистрах могут храниться только переменные определенных типов; на PDP-11 это int, char или указатель. Существует и другое ограничение на использование регистровых переменных: к ним нельзя применять операцию взятия адреса &. При разумном использовании регистровых описаний можно ожидать получения меньших по размеру и более быстрых программ, но улучшение в будущем генерирования кодов может сделать их ненужными.

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

A8.2. Спецификаторы типа

Ниже перечисляются спецификаторы типа.

Спецификатор-типа:
char
short
int
long
unsigned
float
double
спецификатор-структуры-или-объединения
определяющее-тип-имя

Слова long, short и unsigned можно рассматривать как прилагательные; допустимы следующие комбинации:

short int
long int
unsigned int
long float

Последняя комбинация означает то же, что и double. В остальном описание может содержать не более одного спецификатора типа. Если описание не содержит спецификатора типа, то считается, что он имеет значение int.

Спецификаторы структур и объединений обсуждаются в п. A8.5; Описания с определяющими тип именами typedef обсуждаются в п. A8.8.

A8.3. Описатели

Входящий в описание список описателей представляет собой последовательность разделенных запятыми описателей, каждый из которых может иметь инициализатор.

Список-описателей:
инициализируемый-описатель
инициализируемый-описатель, список-описателей
инициализируемый-описатель:
[описатель-инициализатор]

Инициализаторы описываются в п. A8.6. Спецификаторы и описания указывают тип и класс памяти объектов, на которые ссылаются описатели. Описатели имеют следующий синтаксис:

описатель:
идентификатор
(описатель)
* описатель
описатель ()
описатель [[константное-выражение]]

Группирование такое же как и в выражениях.

A8.4. Смысл описателей

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

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

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

Представим себе описание

t  di;

где t — спецификатор типа (подобный int и т.д.), а di — описатель. Предположим, что это описание приводит к тому, что соответствующий идентификатор имеет тип «... t», где «...» пусто, если di просто отдельный идентификатор (так что тип x в «int x» просто int). Тогда, если di имеет форму

*d

то содержащийся идентификатор будет иметь тип «... указатель на t».

Если di имеет форму

d()

то содержащийся идентификатор имеет тип «... функция, возвращающая t».

Если di имеет форму

d[константное-выражение]

или

d[]

то содержащийся идентификатор имеет тип «... массив t».

В первом случае константным выражением является выражение, значение которого можно определить во время компиляции и которое имеет тип int. (Точное определение константного выражения дано в п. 23). Когда несколько спецификаций вида «массив из» оказываются примыкающими, то создается многомерный массив; константное выражение, задающее границы массивов, может отсутствовать только у первого члена этой последовательности. Такое опускание полезно, когда массив является внешним и его фактическое определение, которое выделяет память, приводится в другом месте. Первое константное выражение может быть опущено также тогда, когда за описателем следует инициализация. В этом случае размер определяется по числу приведенных инициализируемых элементов.

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

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

В качестве примера рассмотрим описание

int i, *ip, f(), *fip(), (*pfi)();

в котором описывается целое i, указатель ip на целое, функция f, возвращающая целое, функция fip, возвращающая указатель на целое, и указатель pfi на функцию, которая возвращает целое. Особенно полезно сравнить два последних описателя. Связь в *fip() можно представить в виде *(fip()), так что описанием предполагается, а такой же конструкцией в выражении требуется обращение к функции fip и последующее использование косвенной адресации для выдачи с помощью полученного результата (указателя) целого. В описателе (*pfi)() дополнительные скобки необходимы, поскольку они точно так же, как и в выражении, указывают, что косвенная адресация через указатель на функцию выдает функцию, которая затем вызывается; эта вызванная функция возвращает целое.

В качестве другого примера приведем описание

float fa[17], *afp[17];

в котором описывается массив чисел типа float и массив указателей на числа типа float. Наконец,

static int x3d[3][5][7];

описывает статический трехмерный массив целых размером 3*5*7. Более подробно, x3d является массивом из трех элементов; каждый элемент является массивом пяти массивов; каждый последний массив является массивом из семи целых. Каждое из выражений x3d, x3d[i], x3d[i][j] и x3d[i][j][k] может разумным образом появляться в выражениях. Первые три имеют тип «массив», последнее имеет тип int.

A8.5. Описание структур и объединений

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

Спецификатор-структуры-или-объединения
структура-или-объединение { список-описаний-структуры }
идентификатор структуры-или-объединения
{список-описаний-структуры}
идентификатор структуры-или-объединения
Структура-или-объединение:
struct
union

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

Список-описаний-структуры:
описание-структуры
описание-структуры список-описаний-структуры
описание-структуры:
спецификатор-типа список-описателей-структуры
список-описателей-структуры:
описатель-структуры
описатель-структуры, список-описателей-структуры

В обычном случае описатель структуры является просто описателем члена структуры или объединения. Член структуры может также состоять из специфицированного числа битов. Такой член называется также полем; его длина отделяется от имени поля двоеточием.

Описатель-структуры:
описатель
описатель: константное выражение
: константное выражение

Внутри структуры описанные в ней объекты имеют адреса, которые увеличиваются в соответствии с чтением их описаний слева направо. Каждый член структуры, который не является полем, начинается с адресной границы, соответствующей его типу; следовательно в структуре могут оказаться неименованные дыры. Члены, являющиеся полями, помещаются в машинные целые; они не перекрывают границы слова. Поле, которое не умещается в оставшемся в данном слове пространстве, помещается в следующее слово. Поля выделяются справа налево на PDP-11 и слева направо на других машинах.

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

Сам язык не накладывает ограничений на типы объектов, описанных как поля, но от реализаций не требуется обеспечивать что-либо отличное от целых полей. Более того, даже поля типа int могут рассматриваться как не имеющие знака. На PDP-11 поля не имеют знака и могут принимать только целые значения. Во всех реализациях отсутствуют массивы полей и к полям не применима операция взятия адреса &, так что не существует и указателей на поля.

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

Спецификатор структуры или объединения во второй форме, т.е. один из

struct идентификатор {список-описаний-структуры}

union идентификатор {список-описаний-структуры}

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

struct идентификатор

union идентификатор

Ярлыки структур дают возможность определения структур, которые ссылаются на самих себя; они также позволяют неоднократно использовать приведенную только один раз длинную часть описания. Запрещается описывать структуру или объединение, которые содержат образец самого себя, но структура или объединение могут содержать указатель на структуру или объединение такого же вида, как они сами.

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

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

Вот простой пример описания структуры:

struct tnode {
    char tword[20];
    int count;
    struct tnode *left;
    struct tnode *right;
};

Такая структура содержит массив из 20 символов, целое и два указателя на подобные структуры. Как только приведено такое описание, описание

struct tnode s, *sp;

говорит о том, что s является структурой указанного вида, а sp является указателем на структуру указанного вида. При наличии этих описаний выражение

sp->count

ссылается к полю count структуры, на которую указывает sp; выражение

s.left

ссылается на указатель левого поддерева в структуре s, а выражение

s.right->tword[0]

ссылается на первый символ члена tword правого поддерева из s.

A8.6. Инициализация

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

Инициализатор:
= выражение
= {список-инициализатора}
= {список-инициализатора,}
список-инициализатора:
выражение
список-инициализатора, список-инициализатора
{список-инициализатора}

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

Гарантируется, что неинициализированные статические и внешние переменные получают в качестве начальных значений 0; неинициализированные автоматические и регистровые переменные в качестве начальных значений содержат мусор.

Когда инициализатор применяется к скаляру (указателю или объекту арифметического типа), то он состоит из одного выражения, возможно заключенного в фигурные скобки. Начальное значение объекта находится из выражения; выполняются те же самые преобразования, что и при присваивании.

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

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

Последнее сокращение допускает возможность инициализации массива типа char с помощью строки. В этом случае члены массива последовательно инициализируются символами строки. Например,

int x[] = {1, 3, 5};

описывает и инициализирует x как одномерный массив; поскольку размер массива не специфицирован, а список инициализатора содержит три элемента, считается, что массив состоит из трех членов.

Вот пример инициализации с полным использованием фигурных скобок:

float *y[4][3] = {
    { 1, 3, 5 },
    { 2, 4, 6 },
    { 3, 5, 7 },
};

Здесь 1, 3 и 5 инициализируют первую строку массива y[0], а именно y[0][0], y[0][1] и y[0][2]. Аналогичным образом следующие две строчки инициализируют y[1] и y[2]. Инициализатор заканчивается преждевременно, и, следовательно массив y[3] инициализируется нулями. В точности такого же эффекта можно было бы достичь, написав

float y[4][3] = { 1, 3, 5, 2, 4, 6, 3, 5, 7};

Инициализатор для y начинается с левой фигурной скобки, но инициализатора для y[0] нет. Поэтому используется 3 элемента из списка. Аналогично следующие три элемента используются последовательно для y[1] и y[2]. Следующее описание

float y[4][3] = { {1}, {2}, {3}, {4} };

инициализирует первый столбец y (если его рассматривать как двумерный массив), а остальные элементы заполняются нулями.

И наконец, описание

char msg[] = "Syntax error on line %s\n";

демонстрирует инициализацию элементов символьного массива с помощью строки.

A8.7. Имена типов

В двух случаях (для явного указания типа преобразования в конструкции перевода и для аргументов операции sizeof) желательно иметь возможность задавать имя типа данных. Это осуществляется с помощью «имени типа», которое по существу является описанием объекта такого типа, в котором опущено имя самого объекта.

Имя типа:
спецификатор-типа абстрактный-описатель
абстрактный-описатель:
пусто
(абстрактный-описатель)
* абстрактный-описатель
абстрактный-описатель ()
абстрактный-описатель [[константное выражение]]

Во избежании двусмысленности в конструкции

(абстрактный-описатель)

требуется, чтобы абстрактный-описатель был непуст. При этом ограничении возможно однозначено определить то место в абстрактном-описателе, где бы появился идентификатор, если бы эта конструкция была описателем в описании. Именованный тип совпадает тогда с типом гипотетического идентификатора. Например, имена типов

int
int *
int *[3]
int (*)[3]
int *()
int (*)()

именуют соответственно типы «целый», «указатель на целое», «массив из трех указателей на целое», «указатель на массив из трех целых», «функция, возвращающая указатель на целое» и «указатель на функцию, возвращающую целое».

A8.8. typedef

Описания, в которых «класс памяти» специфицирован как typedef, не вызывают выделения памяти. Вместо этого они определяют идентификаторы, которые позднее можно использовать так, словно они являются ключевыми словами, имеющими основные или производные типы.

Определяющее-тип-имя
идентификатор

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

typedef int miles, >klicksp;
typedef struct (double re, im;) complex;

конструкции

miles distance;
extern klicksp metricp;
complex z, *zp;

становятся законными описаниями; при этом типом distance является int, типом metricp — «указатель на int», типом z — специфицированная структура и типом zp — указатель на такую структуру.

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

A9. Операторы

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

A9.1. Операторное выражение

Большинство операторов являются операторными выражениями, которые имеют форму

выражение;

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

A9.2. Составной оператор (или блок)

С тем чтобы допустить возможность использования нескольких операторов там, где ожидается присутствие только одного, предусматривается составной оператор (который также и эквивалентно называют «блоком»):

составной оператор:
{[список-описаний] [список-операторов]}
список-описаний:
описание
описание список-описаний
список-операторов:
оператор
оператор список-операторов

Если какой-либо идентификатор из списка-описаний был описан ранее, то во время выполнения блока внешнее описание подавляется и снова вступает в силу после выхода из блока.

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

Находящиеся внутри блока внешние описания не резервируют памяти, так что их инициализация не разрешается.

A9.3. Условные операторы

Имеются две формы условных операторов:

if(выражение) оператор
if(выражение) оператор else оператор

В обоих случаях вычисляется выражение и, если оно отлично от нуля, то выполняется первый подоператор. Во втором случае, если выражение равно нулю, выполняется второй подоператор. Как обычно, двусмысленность «else» разрешается связыванием else с последним встречающимся if, у которого нет else.

A9.4. Оператор while

Оператор while имеет форму

while(выражение) оператор

Подоператор выполняется повторно до тех пор, пока значение выражения остается отличным от нуля. Проверка производится перед каждым выполнением оператора.

A9.5. Оператор do

Оператор do имеет форму

do оператор while(выражение);

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

A9.6. Оператор for

Оператор for имеет форму

for([выражение-1] ; [выражение-2] ; [выражение-3]) оператор

Оператор for эквивалентен следующему:

выражение-1;
while(выражение-2) {
    оператор
    выражение-3
}

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

Любое выражение или даже все они могут быть опущены. Если отсутствует второе выражение, то предложение с while считается эквивалентным while(1); другие отсутствующие выражения просто опускаются из приведенного выше расширения.

A9.7. Оператор switch

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

switch(выражение) оператор

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

case константное выражение:

где константное выражение должно иметь тип int. Никакие две вариантные константы в одном и том же переключателе не могут иметь одинаковое значение. Точное определение константного выражения приводится в п. A15.

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

default:

При выполнении оператора switch вычисляется входящее в него выражение и сравнивается с каждой вариантной константой. Если одна из вариантных констант оказывается равной значению этого выражения, то управление передается оператору, который следует за совпадающим вариантным префиксом. Если ни одна из вариантных констант не совпадает со значением выражения и если при этом присутствует префикс default, то управление передается оператору, помеченному этим префиксом. Если ни один из вариантов не подходит и префикс default отсутствует, то ни один из операторов в переключателе не выполняется.

Сами по себе префиксы case и default не изменяют поток управления, которое беспрепятственно проходит через такие префиксы. Для выхода из переключателя смотрите оператор break, п. A9.8.

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

A9.8. Оператор break

Оператор

break;

вызывает завершение выполнения наименьшего охватывающего этот оператор оператора while, do, for или switch; управление передается оператору, следующему за завершенным оператором.

A9.9. Оператор continue

Оператор

continue;

приводит к передаче управления на продолжающую цикл часть наименьшего охватывающего этот оператор оператора while, do или for; то есть на конец цикла. Более точно, в каждом из операторов

while(...) {              do {                for(...) {
    ...                       ...                 ...
contin: ;                 contin: ;           contin: ;
}                }        while(...);         }

Оператор continue эквивалентен оператору goto contin. (За contin: следует пустой оператор; см. п. A9.13.).

A9.10. Оператор возврата

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

return;
return выражение;

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

A9.11. Оператор goto

Управление можно передавать безусловно с помощью оператора

goto идентификатор1

идентификатор должен быть меткой (п. A9.12), Локализованной в данной функции.

A9.12. Помеченный оператор

Перед любым оператором может стоять помеченный префикс вида

идентификатор:

который служит для описания идентификатора в качестве метки. Метки используются только для указания места, куда передается управление оператором goto. Областью действия метки является данная функция, за исключением любых подблоков, в которых тот же идентификатор описан снова. Смотри п. A11.

A9.13. Пустой оператор

Пустой оператор имеет форму:

;

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

A10. Внешние определения

C-программа представляет собой последовательность внешних определений. Внешнее определение описывает идентификатор как имеющий класс памяти extern (по умолчанию), или возможно static, и специфицированный тип. Спецификатор типа (п. A8.2) Также может быть пустым; в этом случае считается, что тип является типом int. Область действия внешних определений распространяется до конца файла, в котором они приведены, точно так же, как влияние описаний простирается до конца блока. Синтаксис внешних определений не отличается от синтаксиса описаний, за исключением того, что только на этом уровне можно приводить текст функций.

A10.1. Внешнее определение функции

Определение функции имеет форму

определение-функции:
спецификаторы-описания описатель-функции
[тело-функции]

Единственными спецификаторами класса памяти, допускаемыми в качестве спецификаторов-описания, являются extern или static; о различии между ними смотри п. A11.2. Описатель функции подобен описателю для «функции, возвращающей...», за исключением того, что он перечисляет формальные параметры определяемой функции.

Описатель-функции:
описатель ([список-параметров])
список параметров:
идентификатор
идентификатор, список-параметров

тело-функции имеет форму

тело-функции:
список-описаний составной-оператор

Идентификаторы из списка параметров и только они могут быть описаны в списке описаний. Любой идентификатор, тип которого не указан, считается имеющим тип int. Единственным допустимым здесь спецификатором класса памяти является register; если такой класс памяти специфицирован, то в начале выполнения функции соответствующий фактический параметр копируется, если это возможно, в регистр.

Вот простой пример полного определения функции:

int max(a, b, c)
int a, b, c;
{
    int m;

    m = (a > b) ? a : b;
    return (m > c) ? m : c;
}

Здесь int — спецификатор-типа, max(a, b, c) — описатель-функции, int a, b, c; — список-описаний формальных параметров, {...} — блок, содержащий текст оператора.

В языке C все фактические параметры типа float преобразуются к типу double, так что описания формальных параметров, объявленных как float, приспособлены прочесть параметры типа double. Аналогично, поскольку ссылка на массив в любом контексте (в частности в фактическом параметре) рассматривается как указатель на первый элемент массива, описания формальных параметров вида «массив ...» приспособлены прочесть: «указатель на ...». И наконец, поскольку структуры, объединения и функции не могут быть переданы функции, бессмысленно описывать формальный параметр как структуру, объединение или функцию (указатели на такие объекты, конечно, допускаются).

A10.2. Внешние определения данных

Внешнее определение данных имеет форму

определение-данных:
описание

Классом памяти таких данных может быть extern (в частности, по умолчанию) или static, но не auto или register.

A11. Правила, определяющие область действия

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

Поэтому следует рассмотреть два вида областей действия: во-первых, ту, которая может быть названа лексической областью действия идентификатора и которая по существу является той областью в программе, где этот идентификатор можно использовать, не вызывая диагностического сообщения «неопределенный идентификатор»; и во-вторых, область действия, которая связана с внешними идентификаторами и которая характеризуется правилом, что ссылки на один и тот же внешний идентификатор являются ссылками на один и тот же объект.

A11.1. Лексическая область действия

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

Поскольку все обращения на один и тот же внешний идентификатор обращаются к одному и тому же объекту (см. п. A11.2), компилятор проверяет все описания одного и того же внешнего идентификатора на совместимость; в действительности их область действия распространяется на весь файл, в котором они находятся.

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

Напомним также (п. A8.5), что идентификаторы, соответствующие обычным переменным, с одной стороны, и идентификаторы, соответствующие членам и ярлыкам структур и объединений, с другой стороны, формируют два непересекающихся класса, которые не вступают в противоречие. Члены и ярлыки подчиняются тем же самым правилам определения областей действия, как и другие идентификаторы. Имена, специфицируемые с помощью typedef, входят в тот же класс, что и обычные идентификаторы. Они могут быть переопределены во внутренних блоках, но во внутреннем описании тип должен быть указан явно:

typedef float distance;
...
{
    auto int distance;
    ...
}

Во втором описании спецификатор типа int должен присутствовать, так как в противном случае это описание будет принято за описание без описателей с типом distance (прим. автора: согласитесь, что лед здесь тонок.)

A11.2. Область действия внешних идентификаторов

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

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

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

A12. Строки управления компилятором

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

A12.1. Замена лексем

Управляющая компилятором строка вида

#define идентификатор строка-лексем

(Обратите внимание на отсутствие в конце точки с запятой) приводит к тому, что препроцессор заменяет последующие вхождения этого идентификатора на указанную строку лексем. Строка вида

#define идентификатор(идентификатор, ..., идентификатор) строка лексем

где между первым идентификатором и открывающейся скобкой (нет пробела, представляет собой макроопределение с аргументами. Последующее вхождение первого идентификатора, за которым следует открывающая скобка '(', последовательность разделенных запятыми лексем и закрывающая скобка ')', заменяются строкой лексем из определения. Каждое вхождение идентификатора, упомянутого в списке формальных параметров в определении, заменяется соответствующей строкой лексем из обращения. Фактическими аргументами в обращении являются строки лексем, разделенные запятыми; однако запятые, входящие в закавыченные строки или заключенные в круглые скобки, не разделяют аргументов. Количество формальных и фактических параметров должно совпадать. Текст внутри строки или символьной константы не подлежит замене.

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

Описываемая возможность особенно полезна для определения «объявляемых констант», как, например,

#define TABSIZE 100
int table[TABSIZE];

Управляющая строка вида

#undef идентификатор
приводит к отмене препроцессорного определения данного идентификатора.

A12.2. Включение файлов

Строка управления компилятором вида

#include "filename"

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

#include <filename>

ищет файл только в стандартных местах и не просматривает справочник исходного файла.

Строки #include могут быть вложенными.

A12.3. Условная компиляция

Строка управления компилятором вида

#if константное выражение

проверяет, отлично ли от нуля значение константного выражения (см.п.15). Управляющая строка вида

#ifdef идентификатор

проверяет, определен ли этот идентификатор в настоящий момент в препроцессоре, т.е. определен ли этот идентификатор с помощью управляющей строки #define.

A13. Неявные описания

Не всегда является необходимым специфицировать и класс памяти и тип идентификатора в описании. Во внешних определениях и описаниях формальных параметров и членов структур класс памяти определяется по контексту. Если в находящемся внутри функции описании не указан тип, а только класс памяти, то предполагается, что идентификатор имеет тип int; если не указан класс памяти, а только тип, то идентификатор предполагается описанным как auto. Исключение из последнего правила дается для функций, потому что спецификатор auto для функций является бессмысленным (язык C не в состоянии компилировать программу в стек); если идентификатор имеет тип «функция, возвращающая ...», то он предполагается неявно описанным как extern.

Входящий в выражение и неописанный ранее идентификатор, за которым следует скобка (, считается описанным по контексту как «функция, возвращающая int».

A14. Снова о типах

В этом разделе обобщаются сведения об операциях, которые можно применять только к объектам определенных типов.

A14.1. Структуры и объединения

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

В п. A7.1 говорится, что при прямой или косвенной ссылке на структуру (с помощью . или ->) имя справа должно быть членом структуры, названной или указанной выражением слева. Это ограничение не навязывается строго компилятором, чтобы дать возможность обойти правила типов. В действительности перед '.' допускается любое l-значение и затем предполагается, что это l-значение имеет форму структуры, для которой стоящее справа имя является членом. Таким же образом, от выражения, стоящего перед '->', требуется только быть указателем или целым. В случае указателя предполагается, что он указывает на структуру, для которой стоящее справа имя является членом. В случае целого оно рассматривается как абсолютный адрес соответствующей структуры, заданный в единицах машинной памяти.

Такие структуры не являются переносимыми.

A14.2. Функции

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

int f();
    ...

g(f);

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

g(funcp)
int(*funcp)();
{
    ...
    (*funcp)();
    ...
}

Обратите внимание, что в вызывающей процедуре функция f должна быть описана явно, потому что за ее появлением в g(f) не следует скобка (.

A14.3. Массивы, указатели и индексация

Каждый раз, когда идентификатор, имеющий тип массива, появляется в выражении, он преобразуется в указатель на первый член этого массива. Из-за этого преобразования массивы не являются l-значениями. По определению операция индексация [] интерпретируется таким образом, что E1[E2] считается идентичным выражению *((E1)+(E2)). Согласно правилам преобразований, применяемым при операции +, если E1 — массив, а E2 — целое, то E1[E2] ссылается на E2-й член массива E1. Поэтому несмотря на несимметричный вид операция индексации является коммутативной.

В случае многомерных массивов применяется последовательное правило. Если E является n-мерным массивом размера i * j * ... * k, то при появлении в выражении E преобразуется в указатель на (n-1)-мерный массив размера j * ... * k. Если операция * либо явно, либо неявно, как результат индексации, применяется к этому указателю, то результатом операции будет указанный (n-1)-мерный массив, который сам немедленно преобразуется в указатель.

Рассмотрим, например, описание

int x[3][5];

Здесь x массив целых размера 3 * 5. При появлении в выражении x преобразуется в указатель на первый из трех массивов из 5 целых. В выражении x[i], которое эквивалентно *(x+i), сначала x преобразуется в указатель так, как описано выше; затем i преобразуется к типу x, что вызывает умножение i на длину объекта, на который указывает указатель, а именно на 5 целых объектов. Результаты складываются, и применение косвенной адресации дает массив (из 5 целых), который в свою очередь преобразуется в указатель на первое из этих целых. Если в выражение входит и другой индекс, то та же самая аргументация применяется снова; результатом на этот раз будет целое.

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

A14.4. Явные преобразования указателей

Разрешаются определенные преобразования, с использованием указателей, но они имеют некоторые зависящие от конкретной реализации аспекты. Все эти преобразования задаются с помощью операции явного преобразования типа; см. п. A7.2 и A8.7.

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

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

Указатель на один тип может быть преобразован в указатель на другой тип. Если преобразуемый указатель не указывает на объекты, которые подходящим образом выровнены в памяти, то результирующий указатель может при использовании вызывать ошибки адресации. Гарантируется, что указатель на объект заданного размера может быть преобразован в указатель на объект меньшего размера и снова обратно, не претерпев при этом изменения.

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

extern char *alloc();
double *DP;
DP=(double*) alloc(sizeof(double));
*DP=22.0/7.0;

Функция alloc должна обеспечивать (машинно-зависимым способом, что возвращаемое ею значение будет подходящим для преобразования в указатель на double; в таком случае использование этой функции будет переносимым.

Представление указателя на PDP-11 соответствует 16-битовому целому и измеряется в байтах. Объекты типа char не имеют никаких ограничений на выравнивание; все остальные объекты должны иметь четные адреса.

На Honeywell 6000 указатель соответствует 36-битовому целому; слову соответствует 18 левых битов и два непосредственно примыкающих к ним справа бита, которые выделяют символ в слове. Таким образом, указатели на символы измеряются в единицах 2 в степени 16 байтов; все остальное измеряется в единицах 2 в степени 18 машинных слов. Величины типа double и содержащие их агрегаты должны выравниваться по четным адресам слов (0 по модулю 2 в степени 19).

ЭВМ IBM 370 и Interdata 8/32 сходны между собой. На обеих машинах адреса измеряются в байтах; элементарные объекты должны быть выровнены по границе, равной их длине, так что указатели на short должны быть кратны двум, на int и float - четырем и на double — восьми. Агрегаты выравниваются по самой строгой границе, требуемой каким-либо из их элементов.

A15. Константные выражения

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

+ - * / . % & | ^ << >> == 1= <> <= >=

либо унарными операциями

- ~

либо тернарной операцией ?:

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

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

A16. Соображения о переносимости

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

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

Число переменных типа register, которое фактически может быть помещено в регистры, меняется от машины к машине, также как и набор допустимых для них типов. Тем не менее все компиляторы на своих машинах работают надлежащим образом; лишние или недопустимые регистровые описания игнорируются.

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

Языком не указывается порядок вычисления аргументов функций; они вычисляются справа налево на PDP-11 и VAX-11 и слева направо на остальных машинах. Порядок, в котором происходят побочные эффекты, также не специфицируется.

Так как символьные константы в действительности являются объектами типа int, допускается использование символьных констант, состоящих из нескольких символов. Однако, поскольку порядок, в котором символы приписываются к слову, меняется от машины к машине, конкретная реализация оказывается весьма машинно-зависимой.

Присваивание полей к словам и символов к целым осуществляется справа налево на PDP-11 и VAX-11 и слева направо на других машинах. Эти различия незаметны для изолированных программ, в которых не разрешено смешивать типы (преобразуя, например, указатель на int в указатель на char и затем проверяя указываемую память), но должны учитываться при согласовании с накладываемыми извне схемами памяти.

Язык, принятый на различных компиляторах, отличается только незначительными деталями. Самое заметное отличие состоит в том, что используемый в настоящее время компилятор на PDP-11 не инициализирует структуры, которые содержат поля битов, и не допускает некоторые операции присваивания в определенных контекстах, связанных с использованием значения присваивания.

A17. Анахронизмы

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

В ранних версиях C для проблем присваивания использовалась форма =op, а не op=, приводя к двусмысленностям, типичным примером которых является

x =-1

где x фактически уменьшается, поскольку операции = и - примыкают друг к другу, но что вполне могло рассматриваться и как присваивание -1 к x.

Синтаксис инициализаторов изменился: раньше знак равенства, с которого начинается инициализатор, отсутствовал, так что вместо

int x = 1;

использовалось

int x 1;

изменение было внесено из-за инициализации

int f (1+2)

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

A18. Сводка синтаксических правил

Эта сводка синтаксиса языка C предназначена скорее для облегчения понимания и не является точной формулировкой языка.

A18.1. Выражения

Основными выражениями являются следующие:

выражение:
первичное-выражение
* выражение
& выражение
- выражение
! Выражение
~ выражение
++ l-значение
-- l-значение
l-значение ++
l-значение --
sizeof выражение
(имя типа) выражение
выражение бинарная-операция выражение
выражение ? Выражение : выражение
l-значение операция-присваивания выражение
выражение, выражение
первичное выражение:
идентификатор
константа
строка
(выражение)
первичное-выражение [[список выражений]]
первичное-выражение [выражение]
l-значение . идентификатор
первичное выражение -> идентификатор
l-значение:
идентификатор
первичное-выражение [выражение]
l-значение . идентификатор
первичное выражение -> идентификатор
* выражение
(l-значение)

Операции первичных выражений

() []  . ->

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

Унарные операции

*  &  -  !  ~  ++  --  sizeof(имя типа)

имеют более низкий приоритет, чем операции первичных выражений, но более высокий, чем приоритет любой бинарной операции. Эти операции группируются справа налево. Все бинарные операции и условная операция (прим. перевод.: условная операция группируется справа налево; это изменение внесено в язык в 1978 г.) группируются слева направо и их приоритет убывает в следующем порядке:

Бинарные операции:

*   /   %
+   -
>>  <<
<   >  <=   >=
==  !=
&
~
|
&&
||
?:

Все операции присваивания имеют одинаковый приоритет и группируются справа налево.

Операции присваивания:

=  +=  -=  *=  ?=  %=  >>=  <<=  &=  ~=  |=

Операция запятая имеет самый низкий приоритет и группируется слева направо.

A18.2. Описания

Описание:
[спецификаторы-описания] список-инициализируемых-описателей
спецификаторы-описания:
[спецификатор-типа] спецификаторы-описания
[спецификатор-класса-памяти] спецификаторы-описания
спецификатор-класса-памяти:
auto
static
extern
register
typedef
спецификатор-типа:
char
short
int
long
unsigned
float
double
спецификатор-структуры-или-объединения
определяющее-тип-имя
список-инициализируемых-описателей:
инициализируемый-описатель
инициализируемый-описатель,
список-инициализируемых-описателей
инициализируемый-описатель
[описатель-инициализатор]
описатель:
идентификатор
(описатель)
* описатель
описатель ()
описатель [[константное выражение]]
спецификатор-структуры-или-объединения:
struct список-описателей-структуры
struct идентификатор {список-описаний-структуры}
struct идентификатор
union {список-описаний-структуры}
union идентификатор {список-описаний-структуры}
union идентификатор
список-описаний-структуры:
описание-структуры
описание-структуры список-описаний-структуры
описание структуры:
спецификатор-типа список-описателей-структуры:
список-описателей-структуры
описатель-структуры
описатель-структуры, список-описателей-структуры
описатель-структуры:
описатель
описатель:
константное выражение
: константное-выражение
инициализатор:
= выражение
= {список-инициализатора}
= {список-инициализатора}
список инициализатора:
выражение
список-инициализатора, список-инициализатора
{список-инициализатора}
имя-типа:
спецификатор-типа абстрактный-описатель
абстрактный-описатель:
пусто
{абстрактный-описатель}
* абстрактный-описатель
абстрактный-описатель ()
абстрактный-описатель [[константное-выражение]]
определяющее-тип-имя:
идентификатор

A18.3. Операторы

составной-оператор:
{[список-описаний] [список-операторов]}
список-описаний:
описание
описание список-описаний
список-операторов:
оператор
оператор список-операторов
оператор:
составной оператор
выражение;
if(выражение) оператор
if(выражение) оператор else оператор
while(выражение) оператор
do оператор while(выражение);
for([выражение-1] ; [выражение-2] ; [выражение-3]) оператор
switch (выражение) оператор
    case константное-выражение : оператор
default: оператор
break;
continue;
return;
return выражение;
goto идентификатор;
идентификатор : оператор
;

A18.4. Внешние определения

Программа:
внешнее-определение
внешнее-определение программа
внешнее-определение:
определение-функции
определение-данных
определение-функции:
[спецификатор-типа] описатель-функции тело-функции
описатель-функции:
[описатель (список-параметров)]
список-параметров:
идентификатор
идентификатор, список-параметров
тело-функции:
список-описаний-типа оператор-функции
оператор-функции:
{[список описаний] список-операторов}
определение данных:
[extern][спецификатор типа][список инициализируемых описателей];
[static][спецификатор типа][список инициализируемых описателей];

A18.5. Препроцессор

#define идентификатор строка-лексем
#define
#define идентификатор(идентификатор, ..., идентификатор) стр
#undef идентификатор
#include "имя-файла"
#include <имя-файла>
#if константное-выражение
#ifdef идентификатор
#ifndef идентификатор
#else
#endif
#line константа идентификатор

A19. Присваивание структуры

Последние изменения языка C (15 ноября 1978 г.)

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

В реализации возвращения структур функциями на PDP-11 имеется коварный дефект: если во время возврата происходит прерывание и та же самая функция реентерабельно вызывается во время этого прерывания, то значение возвращаемое из первого вызова, может быть испорчено. Эта трудность может возникнуть только при наличии истинного прерывания, как из операционной системы, так и из программы пользователя, прерывания, которое существенно для использования сигналов; обычные рекурсивные вызовы совершенно безопасны.

A20. Тип перечисления

Введен новый тип данных, аналогичный скалярным типам языка Паскаль. К спецификатору-типа в его синтаксическом описании в разделе 8.2. приложения A следует добавить

спецификатор-перечисления

с синтаксисом

спецификатор-перечисления:
enum список-перечисления
enum идентификатор список-перечисления
enum идентификатор
список-перечисления:
перечисляемое
список-перечисления, перечисляемое
перечисляемое:
идентификатор
идентификатор = константное выражение

Роль идентификатора в спецификаторе-перечисления полностью аналогична роли ярлыка структуры в спецификаторе-структуры; идентификатор обозначает определенное перечисление. Например, описание

enum color {red, white, black, blue };
. . .
enum color *cp, col;

объявляет идентификатор color ярлыком перечисления типа, описывающего различные цвета и затем объявляет cp указателем на объект этого типа, а col — объектом этого типа.

Идентификаторы в списке-перечисления описываются как константы и могут появиться там, где требуются (по контексту) константы. Если не используется вторая форма перечисляемого (с равенством =), то величины констант начинаются с 0 и возрастают на 1 в соответствии с прочтением их описания слева на право. Перечисляемое с присвоением = придает соответствующему идентификатору указанную величину; последующие идентификаторы продолжают прогрессию от приписанной величины.

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

Объекты данного типа перечисления рассматриваются как объекты, имеющие тип, отличный от любых типов и контролирующая программа lint сообщает об ошибках несоответствия типов. В реализации на PDP-11 со всеми перечисляемыми переменными оперируют так, как если бы они имели тип int.

A21. Таблица изображений непечатных символов языка C

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

Значение Изображение
в тексте**
Фигурная открывающаяся скобка \(
Фигурная закрывающаяся скобка \)
Вертикальная черта \!
Апостроф \'
Волнистая черта \^

Примечание:

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