В начало

СПИСОК ЛИТЕРАТУРЫ

3. ОБЪЯВЛЕНИЯ

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

Объявления в языке Си имеют следующий синтаксис:

<спецификация КП>

<спецификация типа>

<описатель>[=<инициализатор>]

[,<описатель>[=<инициализатор>...]];

где:

<спецификация КП> — спецификация класса памяти;

<спецификация типа> — имя типа, присваиваемого объекту;

<описатель> — идентификатор простой переменной либо более сложная конструкция при объявлении переменной составного типа;

<инициализатор> — значение или последовательность значений, присваиваемых переменной при объявлении.

В некоторых случаях спецификация класса памяти и/или спецификация типа может быть опущена.

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

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

В языке Си определен набор базовых типов данных. Новые типы данных можно добавлять к этому набору посредством их объявления на основе уже определенных типов данных. Спецификация типа позволяет задавать для объекта либо базовый тип данных (см. раздел 3.1), либо структурный тип (см. раздел 3.4.3), либо тип объединение (см. раздел 3.4.4).

Не считается ошибкой объявление внешнего уровня, в котором отсутствует и спецификация класса памяти, и спецификация типа. В этом случае предполагается тип int. Однако объявление, состоящее только из идентификатора, например

n;

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

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

Определения функций описаны в разделе 6.2, инициализаторы — в разделе 3.7.

3.1. Базовые типы данных

В языке Си реализован набор типов данных, называемых "базовыми" типами. Спецификации этих типов перечислены в таблице 3.1.

Таблица 3.1.

Тип long float реализован только в версии 4.0 СП MSC и эквивалентен типу double. В версии 5.0 СП MSC и в СП ТС реализован тип long double, причем в версии 5.0 СП MSC и версии 1.5 СП ТС он эквивалентен типу double, а в версии 2.0 СП ТС является самостоятельным типом размером 80 битов.

Типы char, int, short и long имеют две формы — знаковую (signed) и беззнаковую (unsigned). В совокупности они образуют целый тип. Перечислимый тип также служит для представления целых значений, однако переменная перечислимого типа может принимать значения только из набора, заданного в ее объявлении. Спецификации типов float и double относятся к плавающему типу.

Целый тип (включая перечислимый тип) и плавающий тип в совокупности образуют арифметический тип.

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

При записи спецификаций целого и плавающего типа допустимы сокращения, приведенные в таблице 3.2. Например, в целых типах ключевое слово signed может быть опущено. Если ключевое слово unsigned отсутствует в записи спецификации типа short, int или long, то тип целого будет знаковым, даже если опущено ключевое слово signed.

По умолчанию тип char всегда имеет знак. Однако существует опция компилятора языка Си, позволяющая изменить умолчание для char со знакового типа на беззнаковый. Если эта опция задана, то сокращение char имеет тот же смысл, что и unsigned char, и, следовательно, для объявления символьной переменной со знаком должно быть записано ключевое слово signed.

Таблица 3.2.

Спецификации типов и их сокращения

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

3.2. Области значений

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

Таблица 3.3.

Размер памяти и область значений типов

Тип char может использоваться для хранения буквы, цифры или другого символа из множества представимых символов. Значением объекта типа char является код, соответствующий данному символу. Тип char интерпретируется как однобайтовое целое с областью значений от -128 до 127. Тип unsigned char может содержать значения в интервале от 0 до 255. В частности, буквы русского алфавита имеют коды, соответствующие типу unsigned char.

Следует отметить, что представление в памяти и область значений для типов int и unsigned int не определены в языке Си. В большинстве систем программирования размер типа int (со знаком или без знака) соответствует реальному размеру целого машинного слова. Например, на 16-разрядном компьютере тип int занимает 16 разрядов, или 2 байта. На 32-разрядном компьютере тип int занимает 32 разряда, или 4 байта. Таким образом, тип int эквивалентен либо типу short int (короткое целое), либо типу long int (длинное целое), в зависимости от компьютера. Аналогично, тип unsigned int эквивалентен либо типу unsigned short int, либо типу unsigned long int. Однако рассматриваемые в данной книге компиляторы языка Си, разработанные для моделей IBM PC с 16-разрядным машинным словом, при работе на IBM PC/AT с процессором Intel 80386 (имеющим 32-разрядное машинное слово) отводят для типа int и unsigned int только 16 разрядов.

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

Порядок размещения байтов в памяти для базовых целых типов следующий (по возрастанию адресов):

для типа short — b0, b1;

для типа long — b0, b1, b2, b3,

где b0 — младший байт.

Архитектура процессора Intel 8086/88 позволяет размещать переменные различного размера в памяти как с четного, так и с нечетного адреса. Однако в последнем случае обращение к переменным будет более медленным. В СП ТС существует опция компиляции, задающая выравнивание всех объектов, занимающих более одного байта, на границу четного адреса. Память при этом будет использоваться менее эффективно, но скорость обращения к переменным возрастет. В СП MSC по умолчанию производится выравнивание на границу четного адреса. В версии 5.0 СП MSC существует опция компиляции, обеспечивающая выравнивание на границу, заданную программистом. Вопросы выравнивания структур рассматриваются в разделе 3.4.3.

Согласно правилам преобразования типов в языке Си (см. раздел 5 "Выражения"), не всегда возможно использовать в выражении максимальное или минимальное значение для константы данного типа.

Допустим, требуется использовать в выражении значение -32768 типа short. Константное выражение -32768 состоит из арифметической операции отрицания (-), предшествующей значению константы 32768. Поскольку значение 32768 слишком велико для типа short, компилятор языка Си представляет его типом long и, следовательно, константа -32768 будет иметь тип long. Значение -32768 может быть представлено типом short только путем явного приведения его к типу short с помощью выражения (short) (-32768). Информация при этом не будет потеряна, поскольку значение -32768 может быть представлено двумя байтами памяти.

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

СП ТС позволяет явно присваивать константам беззнаковый тип с помощью суффикса u.

Для представления значений с плавающей точкой используется стандартный формат IEEE (Institute of Electrical and Electronics Engineers, Inc.). Значения типа float занимают 4 байта, состоящих из бита знака, 7-битовой двоичной экспоненты и 24-битовой мантиссы. Мантисса представляет число в интервале от 1.0 до 2.0. Поскольку старший бит мантиссы всегда равен единице, он не хранится в памяти. Это представление дает область значений приблизительно от 3.4Е-38 до 3.4Е+38.

Значения типа double занимают 8 байтов. Их формат аналогичен формату float, за исключением того, что экспонента занимает 11 битов, а мантисса 52 бита плюс неявный старший бит, единичный. Это дает область значений приблизительно от 1.7Е-308 до 1.7Е+308.

Значения типа long double занимают 80 битов; их область значений — от 3.4Е-4932 до 1.1E+4932. Формат их аналогичен формату double, однако мантисса длиннее на 16 битов.

3.3. Описатели

3.3.1. Синтаксис описателей

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

<идентификатор>

<описатель>[]

<описатель>[<константное-выражение>]

*<описатель>

<описатель>()

<описатель>(<список типов аргументов>)

(<описатель>)

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

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

Следующие примеры иллюстрируют простейшие формы описателей:

int list[20] — массив list значений целого типа;

char *ср — указатель ср на значение типа char;

double func() — функция func, возвращающая значение типа double.

3.3.2. Интерпретация составных описателей

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

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

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

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

Правило интерпретации составных описателей может быть названо чтением "изнутри—наружу". Начать интерпретацию нужно с идентификатора и проверить, есть ли справа от него открывающие квадратные или круглые скобки. Если они есть, то проинтерпретировать правую часть описателя. Затем следует проверить, есть ли слева от идентификатора звездочки, и, если они есть, проинтерпретировать левую часть. Если на какой-либо стадии интерпретации справа встретится закрывающая круглая скобка (которая используется для изменения порядка интерпретации описателя), то необходимо сначала полностью провести интерпретацию внутри данной пары круглых скобок, а затем продолжить интерпретацию справа от закрывающей круглой скобки.

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

Следующий пример иллюстрирует применение правила интерпретации составных описателей. Последовательность шагов интерпретации пронумерована.

char⁷*⁶(*⁴(*²var¹)()³)[10]⁵;

1. Идентификатор var объявлен как

2. Указатель на

3. Функцию, возвращающую

4. Указатель на

5. Массив из 10 элементов, которые являются

6. Указателями на

7. Значения типа char.

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

1. int *var[5]; — массив var указателей на значения типа int.

2. int (*var)[5]; — указатель var на массив значений типа int.

3. long *var(); — функция var, возвращающая указатель на значение типа long.

4. long (*var)(); — указатель var на функцию, возвращающую значение типа long.

5. struct both

{

int a;

char b;

}(*var[5])();

массив var указателей на функции, возвращающие структуры типа both.

6. double (*var())[3]; — функция var, возвращающая указатель на массив из трех значений типа double.

7. union sign

{

int x;

unsigned y;

} **var[5][5]; — массив var, элементы которого являются массивами указателей на указатели на объединения типа sign.

8. union sign *(*var[5])[5]; — массив var, элементы которого являются указателями на массив указателей на объединения типа sign.

Пояснения к примерам:

В первом примере var объявляется как массив, поскольку признак типа массив имеет более высокий приоритет, чем признак типа указатель. Элементами массива являются указатели на значения типа int.

Во втором примере скобки меняют смысл объявления из первого примера. Теперь признак типа указатель применяется раньше, чем признак типа массив, и переменная var объявляется как указатель на массив из пяти значений типа int.

В третьем примере, поскольку признак типа функция имеет более высокий приоритет, чем признак типа указатель, var объявляется как функция, возвращающая указатель на значение типа long.

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

Элементы массива не могут быть функциями. Однако в пятом примере показано, как объявить массив указателей на функции. В этом примере переменная var объявлена как массив из пяти указателей на функции, возвращающие структуры типа both. Заметьте, что круглые скобки, в которые заключено выражение *var[5], обязательны. Без них объявление становится недопустимым, поскольку объявляется массив функций:

struct both *var [5] (struct both, struct both);

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

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

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

3.3.3. Описатели с модификаторами

В разделе 1.4 "Ключевые слова" приведен перечень специальных ключевых слов, реализованных в СП MSC и СП ТС. Использование специальных ключевых слов (называемых в дальнейшем модификаторами) в составе описателей позволяет придавать объявлениям специальный смысл. Информация, которую несут модификаторы, используется компилятором языка Си в процессе генерации кода.

Рассмотрим правила интерпретации объявлений, содержащих модификаторы const, volatile, cdecl, pascal, near, far, huge, interrupt.

3.3.3.1. Интерпретация описателей с модификаторами

Модификаторы cdecl, pascal, interrupt воздействуют на идентификатор и должны быть записаны непосредственно перед ним.

Модификаторы const, volatile, near, far, huge воздействуют либо на идентификатор, либо на звездочку, расположенную непосредственно справа от модификатора. Если справа расположен идентификатор, то модифицируется тип объекта, именуемого этим идентификатором. Если же справа расположена звездочка, то модифицируется тип объекта, на который указывает эта звездочка, т.е. эта звездочка представляет собой указатель на модифицированный тип. Таким образом, конструкция <модификатор>* читается как "указатель на модифицированный тип". Например,

int const *p; - это указатель на const int, a

int * const p; - это const указатель на int. Модификаторы const и volatile могут также записываться и перед спецификацией типа.

В СП ТС использование модификаторов near, far, huge ограничено: они могут быть записаны только перед идентификатором функции или перед признаком указателя (звездочкой).

Допускается более одного модификатора для одного объекта (или элемента описателя). В следующем примере тип функции func модифицируется одновременно специальными ключевыми словами far и pascal. Порядок специальных ключевых слов неважен, т.е. комбинации far pascal и pascal far имеют один и тот же смысл.

int far * pascal far func();

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

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

Пример:

char⁷ far⁶ *(far⁶ *getint¹)³(int⁵ far⁴ *);

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

1. Идентификатор getint объявляется как

2. Указатель на far

3. Функцию, требующую

4. Один аргумент, который является указателем на far

5. Значение типа int

6. И возвращающую указатель на far

7. Значение типа char

3.3.3.2. Модификаторы const и volatile

Модификатор const не допускает явного присваивания значения переменной либо других косвенных действий по изменению ее значения, таких как выполнение операций инкремента и декремента. Значение указателя, объявленного с модификатором const, не может быть изменено, в отличие от значения объекта, на который он указывает. В СП MSC, в отличие от СП ТС, недопустима также инициализация const объектов, имеющих класс памяти auto (поскольку их инициализация должна выполняться каждый раз при входе в блок, содержащий их объявления).

Применение модификатора const помогает выявить нежелательные присваивания значений переменным. Переменные, объявленные с модификатором const, могут быть загружены в ячейки постоянной памяти (ПЗУ).

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

Возможно одновременное использование в объявлении модификаторов const и volatile. Это означает, что значение объявляемой переменной не может модифицироваться программой, но подвержено внешним воздействиям.

Если с модификатором const или volatile объявляется переменная составного типа, то действие модификатора распространяется на все ее составляющие элементы. Возможно применение модификаторов const и volatile в составе объявлен typedef.

Примечание. При отсутствии в объявлении спецификации типа и наличии модификатора const или volatile подразумевается спецификация типа int.

Примеры:

float const pi=3.1415926;

const maxint=32767;

/*указатель с неизменяемым значением*/

char *const str="Здравствуй, мир!";

/*указатель на неизменяемую строку*/

char const *str2="Здравствуй, мир!";

С учетом приведенных объявлений следующие операторы недопустимы:

pi=3.0; /*Присвоение значения константе*/

i=maxint--; /*Уменьшение константы*/

str="Привет!"; /*Переназначение указателя*/

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

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

Пример:

volatile int ticks;

void interrupt timer()

{

ticks++;

}

wait(int interval)

{

ticks=0;

while (ticks<interval)

;

}

Функция wait будет "ждать" в течение времени, заданного параметром interval при условии, что функция timer корректно связана с аппаратным прерыванием от таймера. Значение переменной ticks изменяется в функции timer каждый раз при наступлении прерывания от таймера. Модификатор interrupt описан в разделе 3.3.3.5.

Если бы переменная ticks была объявлена без модификатора volatile, то компилятор языка Си с высоким уровнем оптимизации вынес бы за пределы цикла while сравнение переменных ticks и interval, поскольку в теле цикла их значения не изменяются. Это привело бы к зацикливанию программы.

3.3.3.3. Модификаторы cdecl и pascal

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

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

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

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

Модификатор pascal

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

Если модификатор pascal применяется к идентификатору функции, то он оказывает влияние также и на передачу аргументов. Засылка аргументов в стек производится в этом случае не в обратном порядке, как принято в компиляторах языка Си в СП MSC и СП ТС, а в прямом — первым засылается в стек первый аргумент.

Функции типа pascal не могут иметь переменное число аргументов, как, например, функция printf. Поэтому нельзя использовать завершающее многоточие в списке параметров функции типа pascal.

Пример: см. пример 4 в разделе 3.3.3.4.

Модификатор cdecl

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

Примечание. Все функции в стандартных включаемых файлах (например, stdio.h) объявлены с модификатором cdecl. Это позволяет использовать библиотеки стандартных функций даже в тех программах, которые компилируются с упомянутой выше опцией компиляции.

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

Пример: см. пример 3 в разделе 3.3.3.4.

3.3.3.4. Модификаторы near, far, huge

Эти модификаторы оказывают воздействие на работу с адресами объектов.

Компилятор языка Си позволяет использовать при компиляции одну из нескольких моделей памяти. Виды моделей памяти и методы их применения рассмотрены в разделе 8 "Модели памяти".

Модель, которую вы используете, определяет размещение в оперативной памяти вашей программы и данных, а также внутренний формат указателей. Однако при использовании какой-либо модели памяти можно объявить указатель с форматом, отличным от действующего по умолчанию. Это делается с помощью модификаторов near, far и huge.

Указатель типа near — 16-битовый; для определения адреса объекта он использует смещение относительно текущего содержимого сегментного регистра. Для указателя типа near доступная память ограничена размером текущего 64-килобайтного сегмента данных.

Указатель типа far — 32-битовый; он содержит как адрес сегмента, так и смещение. При использовании указателей типа far допустимы обращения к памяти в пределах 1-мегабайтного адресного пространства процессора Intel 8086/8088, однако значение указателя типа far циклически изменяется в пределах одного 64-килобайтного сегмента.

Указатель типа huge — 32-битовый; он также содержит адрес сегмента и смещение. Значение указателя типа huge может быть изменено в пределах всего 1-мегабайтного адресного пространства. В СП ТС указатель типа huge всегда хранится в нормализованном формате. Это имеет следующие следствия:

— операции отношения ==, !=, <, >, <=, >= выполняются корректно и предсказуемо над указателями типа huge, но не над указателями типа far;

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

В СП MSC модификатор huge применяется только к массивам, размер которых превышает 64 К. В СП ТС недопустимы массивы больше 64 К, а модификатор huge применяется к функциям и указателям для спецификации того, что адрес функции или указуемого объекта имеет тип huge.

Для вызова функции типа near используются машинные инструкции ближнего вызова, для типов far и huge — дальнего.

Примеры:

/*пример 1*/

int huge database[65000];

/*пример 2*/

char *far *x;

/*пример 3*/

double near cdecl calc(double, double);

double cdecl near calc(double, double);

/*пример 4*/

char far pascal initlist[INITSIZE];

char far *nextchar, far *prevchar, far *currentchar;

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

Во втором примере специальное ключевое слово far модифицирует расположенную справа от него звездочку, делая x указателем на far указатель на значение типа char. Это объявление можно для ясности записать и так:

char *(far *x);

В примере 3 показано два эквивалентных объявления. В них объявляется calc как функция с модификаторами near и cdecl.

В примере 4 также представлены два объявления. Первое объявляет массив типа char с именем initlist и модификаторами far и pascal. Модификатор pascal указывает на то, что имя данного массива используется не только в программе на языке Си, но и в программе на языке Паскаль (или другом языке программирования с подобными правилами написания имен внешних переменных). Модификатор far указывает на то, что для доступа к элементам массива должны использоваться 32-битовые адреса.

Второе объявление объявляет три указателя на far значения типа char с именами nextchar, prevchar и currentchar. Эти указатели могут быть, в частности, использованы для хранения адресов элементов массива initlist. Обратите внимание на то, что специальное ключевое слово far должно быть повторено перед каждым описателем.

3.3.3.5. Модификатор interrupt

Модификатор interrupt предназначен для объявления функций, работающих с векторами прерываний процессора 8086/8088. Для функции типа interrupt при компиляции генерируется дополнительный код в точке входа и выхода из функции, для сохранения и восстановления регистров микропроцессора АХ, ВХ, СХ, DX, SI, DI, ES и DS. Остальные регистры — ВР, SP, SS, CS и IP сохраняются всегда как часть вызывающей последовательности языка Си или часть самой системы обработки прерывания.

См. пример в разделе 3.3.3.1.

Функции прерываний следует объявлять с типом возвращаемого значения void.

Функции прерываний поддерживаются для всех моделей памяти. В СП MSC, в малой и средней модели в регистр DS заносится при входе в функцию адрес сегмента данных всей программы, а в компактной, большой и максимальной модели в регистр DS заносится адрес сегмента данных программного модуля. В СП ТС только в максимальной модели в регистр DS заносится адрес сегмента данных программного модуля, а в остальных моделях — адрес сегмента данных всей программы.

Модификатор interrupt не может использоваться совместно с модификаторами near, far, huge.

3.4. Объявление переменных

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

Таблица 3.4.

Общая синтаксическая форма объявления переменных описана в начале раздела 3. В данном разделе для простоты изложения объявления описываются без спецификаций класса памяти и инициализаторов. Спецификации класса памяти описаны в разделе 3.6, инициализаторы — в разделе 3.7.

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

3.4.1. Объявление простой переменной

Синтаксис:

<спецификация типа><идентификатор>[,<идентификатор>...];

Объявление простой переменной определяет имя переменной и ее тип. Имя переменной задается <идентификатором>. <Спецификация типа> задает тип переменной. Тип может быть базовым типом, либо типом структура, либо типом объединение. Если спецификация типа опущена, предполагается тип int.

Можно объявить несколько переменных в одном объявлении, задавая список <идентификаторов>, разделенных запятыми. Каждый <идентификатор> в списке именует отдельную переменную. Все переменные, заданные в таком объявлении, имеют одинаковый тип.

Примеры:

int х; /*пример 1*/

unsigned long reply, flag; /*пример 2*/

double order; /*пример 3*/

В первом примере объявляется простая переменная х. Эта переменная может принимать любое значение из области значений типа int.

Во втором примере объявлены две переменные: reply и flag. Обе переменные имеют тип unsigned long.

В третьем примере объявлена переменная order, которая имеет тип double. Этой переменной могут быть присвоены значения с плавающей точкой.

3.4.2. Объявление переменной перечислимого типа

Синтаксис:

enum[<тег>]{<список-перечисления>}<описатель>[,<описатель>...];

enum<тег><идентификатор>[,<идентификатор>...];

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

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

Объявление переменной перечислимого типа начинается с ключевого слова enum и имеет две формы представления.

В первой форме задается список перечисления, содержащий именованные константы. Необязательный <тег> — это идентификатор, который именует перечислимый тип, специфицированный данным списком перечисления. <Идентификатор> — это имя переменной перечислимого типа. В одном объявлении может быть описано более одной переменной данного перечислимого типа.

Во второй форме объявления список перечисления отсутствует, однако используется <тег>, который ссылается на перечислимый тип, объявленный в другом месте программы. Если заданный тег ссылается на неизвестный перечислимый тип либо область действия определения этого перечислимого типа не распространяется на текущий блок, то компилятор языка Си сообщает об ошибке. Допускаются объявление указателя на перечислимый тип и объявление typedef для перечислимого типа, использующие тег ранее не определенного перечислимого типа. Однако этот тип должен быть определен к моменту использования этого тега или типа, объявленного посредством typedef.

<Список-перечисления> содержит одну или более конструкций вида:

<идентификатор>[=<константное-выражение>]

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

Каждый <идентификатор> именует элемент списка перечисления. По умолчанию, если не задано <константное-выражение>, первому элементу присваивается значение 0, следующему элементу — значение 1 и т.д. Элемент списка перечисления является константой.

Запись =<константное-выражение> изменяет умалчиваемую последовательность значений. Элемент, идентификатор которого предшествует записи =<константное-выражение>, принимает значение, задаваемое этим константным выражением. Константное выражение должно иметь тип int и может быть как положительным, так и отрицательным. Следующий элемент списка получает значение, равное <константное-выражение>+1, если только его значение не задается явно другим константным выражением.

В списке перечисления могут содержаться элементы, которым сопоставлены одинаковые значения, однако каждый идентификатор в списке должен быть уникальным. Например, двум различным идентификаторам null и zero может быть задано значение 0 в одном и том же списке перечисления. Кроме того, идентификатор элемента списка перечисления должен быть отличным от идентификаторов элементов всех остальных списков перечислений с той же областью действия, а также от других идентификаторов с той же областью действия (см. раздел 2.5). Тег перечислимого типа должен быть отличным от тегов других перечислимых типов, структур и объединений с той же самой областью действия.

Примеры:

/*пример 1*/

enum day

{

SATURDAY,

SUNDAY=0,

MONDAY,

TUESDAY,

WEDNESDAY,

THURSDAY,

FRIDAY

} workday;

/*пример 2*/

enum day today=WEDNESDAY;

В первом примере перечислимый тип определяется списком. Перечислимый тип именуется тегом day, и объявляется переменная workday этого перечислимого типа. С элементом SATURDAY по умолчанию ассоциируется значение 0. Элементу SUNDAY явно присваивается значение ноль. Остальные идентификаторы по умолчанию принимают значение от 1 до 5.

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

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

3.4.3. Объявление структуры

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

Синтаксис:

struct[<тег>]{<список-объявлений-элементов>}<описатель>[,<описатель>...];

struct<тег><описатель>[,<описатель>...];

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

Объявление структуры начинается с ключевого слова struct и имеет две формы записи, как показано выше. В первой форме типы и имена элементов структуры специфицируются в списке объявлений элементов. Необязательный в данном случае <тег> — это идентификатор, который именует структурный тип, определенный данным списком объявлений элементов.

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

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

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

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

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

Элементы структуры запоминаются в памяти последовательно в том порядке, в котором они объявляются: первому элементу соответствует меньший адрес памяти, а последнему — больший. Однако в СП ТС, если в одном объявлении содержатся описатели нескольких элементов, порядок их размещения в памяти будет обратным. Каждый элемент в памяти выравнен на границу, соответствующую его типу. Для микропроцессора Intel 8086/8088 это означает, что любой элемент, отличный от типа char или unsigned char, выравнивается на четную границу. Поэтому внутри структур могут появляться неименованные, пустые участки памяти между соседними элементами.

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

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

— структура будет начинаться на границе машинного слова (иметь четный адрес);

— любой элемент, имеющий тип, отличный от char или unsigned char, будет иметь четное смещение от начала структуры;

— чтобы структура содержала четное число байтов, в конец структуры будет при необходимости добавлен лишний байт.

Битовые поля

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

Объявление битового поля имеет следующий синтаксис:

<спецификация типа>

[<идентификатор>]:<константное выражение>;

Битовое поле состоит из некоторого числа разрядов машинного слова. Число разрядов, т. е. размер битового поля, задается <константным выражением>. Константное выражение должно иметь неотрицательное целое значение. Это значение не может превышать числа разрядов, требуемого для представления значения специфицированного типа. Для битового поля в версии 4.0 СП MSC спецификация типа должна задавать беззнаковый целый тип (unsigned int). Для версии 5.0 СП MSC спецификация типа может задавать как знаковый, так и беззнаковый целый тип, причем любого размера — char, int, long. Однако знаковый целый тип для битовых полей реализован лишь синтаксически, а в выражениях битовые поля участвуют как беззнаковые значения. Недопустимы массивы битовых полей, указатели на битовые поля и функции, возвращающие битовые поля. Нельзя применять к битовым полям операцию адресации (&).

<Идентификатор> именует битовое поле. Его наличие, однако, необязательно. Неименованное битовое поле означает пропуск соответствующего числа битов перед размещением следующего элемента структуры. Неименованное битовое поле, для которого указан нулевой размер, имеет специальное назначение: оно гарантирует, что память для следующей переменной в этой структуре (в том числе и для следующего битового поля) будет начинаться на границе машинного слова (int). В версии 5.0 СП MSC выравнивание будет производиться на границу того типа, который задан для неименованного битового поля (char, int или long).

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

В СП ТС битовое поле может иметь либо тип unsigned int, либо тип signed int. Поля целого типа хранятся в дополнительном коде; крайний левый бит — знаковый. Например, битовое поле типа signed int размером 1 бит может только хранить значение -1 и 0, т. к. любое ненулевое значение будет интерпретироваться как -1.

Примеры:

/*пример 1*/

struct

{

float х, у;

} complex;

/*пример 2*/

struct employee

{

char name[20];

int id;

long class;

} temp;

/*пример 3*/

struct employee student, faculty, staff;

/*пример 4*/

struct sample

{

char h;

float *pf;

struct sample *next;

} x;

/*пример 5*/

struct

{

unsigned icon : 8;

unsigned color : 4;

unsigned underline : 1;

unsigned blink : 1;

} screen [25][80];

В первом примере объявляется переменная с именем complex, имеющая тип структура. Эта структура состоит из двух элементов x и y типа float. Тип структуры не поименован, поскольку тег в объявлении отсутствует.

Во втором примере объявляется переменная с именем temp, имеющая тип структура. Структура состоит из трех элементов с именами name, id и class. Элемент с именем name — это массив из 20 элементов типа char. Элементы с именами id и class — это простые переменные типа int и long соответственно. Структурный тип поименован тегом employee.

В третьем примере объявлены три переменные типа структура с именами student, faculty и staff. Объявление каждой из этих структур ссылается на структурный тип employee, определенный в предыдущем примере.

В четвертом примере объявляется переменная с именем x типа структура. Тип структуры поименован тегом sample. Первые два элемента структуры — переменная h типа char и указатель pf на значения типа float. Третий элемент с именем next объявлен как указатель на структуру того же самого типа sample.

В пятом примере объявляется двумерный массив с именем screen, элементы которого имеют структурный тип. Массив состоит из 2000 элементов. Каждый элемент — это отдельная структура, состоящая из четырех элементов — битовых полей с именами icon, color, underline и blink.

3.4.4. Объявление объединения

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

Синтаксис:

union[<тег>]{<список-объявлений-элементов>}<описатель>[,<описатель>...];

union<тег><описатель>[,<описатель>...];

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

Объявление объединения имеет тот же синтаксис, что и объявление структуры, за исключением того, что оно начинается с ключевого слова union, а не с ключевого слова struct. Кроме того, СП MSC (в отличие от СП ТС) не допускает в объединении битовые поля.

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

Примеры:

/*пример 1*/

union sign

{

int svar;

unsigned uvar;

} number;

/*пример 2*/

union

{

char *a, b;

float f[20];

} jack;

В первом примере объявляется переменная типа объединение с именем number. Список объявлений элементов объединения содержит две переменных: svar типа int и uvar типа unsigned. Это объединение позволяет запоминать целое значение в знаковом или беззнаковом виде. Тип объединения поименован тегом sign.

Во втором примере объявляется переменная типа объединение с именем jack. Список объявлений элементов содержит три объявления: указателя а на значение типа char, переменной b типа char и массива f из 20 элементов типа float. Тип объединения не поименован тегом. Память, выделяемая переменной jack, равна памяти, необходимой для хранения массива f, поскольку это самый длинный элемент объединения.

3.4.5. Объявление массива

Синтаксис:

[<спецификация типа]><описатель>[<константное выражение>];

[<спецификация типа]><описатель>[];

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

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

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

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

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

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

<спецификация типа><описатель>[<константное выражение>][<константное выражение>]...;

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

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

char a[2][3]

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

Примеры:

/*пример 1*/

int scores[10], game;

/*пример 2*/

float matrix[10][15];

/*пример 3*/

struct

{

float x, у;

} complex[100];

/*пример 4*/

char *name[20];

В первом примере объявляется переменная типа массив с именем scores из 10 элементов типа int. Переменная с именем game объявлена как простая переменная целого типа.

Во втором примере объявляется двумерный массив с именем matrix. Строго говоря, matrix представляет собой массив, состоящий из 10 элементов, каждый из которых является массивом из 15 элементов типа float.

В третьем примере объявляется массив структур типа complex. Он состоит из 100 элементов. Каждый элемент массива представляет собой структуру, содержащую два элемента типа float.

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

3.4.6. Объявление указателя

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

Синтаксис:

[<спецификация типа]> *<описатель>;

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

Если <описатель> представляет собой идентификатор (имя указателя), то объявляется указатель на значение специфицированного типа. Если же <описатель> представляет собой более сложную конструкцию (см. раздел 3.3.1), то тип объекта, на который указывает указатель, определяется совокупностью оставшейся части описателя и спецификации типа. Указатель может указывать на значения базового, перечислимого типа, структуры, объединения, массивы, функции, указатели.

Специальное применение имеют указатели на тип void. Указатель на void может указывать на значения любого типа. Однако для выполнения операций над указателем на void либо над указуемым объектом, необходимо явно привести тип указателя к типу, отличному от void. Например, если объявлена переменная i типа int и указатель р на тип void

int i;

void *p;

то можно присвоить указателю р адрес переменной i

р=&i;

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

р++; /*недопустимо*/

(int *)р++; /*допустимо*/

j=*р; /*недопустимо в СП ТС*/

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

Переменная, объявленная как указатель, хранит адрес памяти. Размер памяти, требуемый для адреса, и формат этого адреса зависит от компьютера и реализации компилятора языка Си. Указатели на один и тот же тип данных не обязательно имеют одинаковый размер и формат, поскольку эти параметры зависят от выбранной модели памяти. Кроме того, существуют модификаторы near, far, huge, специфицирующие формат указателя. Объявления, использующие эти модификаторы, рассмотрены в разделе 3.3.3.4.

Указатель на структуру, объединение или перечислимый тип может быть объявлен до того, как этот тип определен, однако указатель не должен использоваться до определения этого типа. Указатель при этом объявляется посредством использования тега структуры, объединения или перечислимого, типа (см. ниже пример 4). Такие объявления допускаются, поскольку компилятору языка Си не требуется знать размер структуры или объединения, чтобы распределить память под указатель.

В стандартном включаемом файле stdio.h определена константа с именем NULL. Она предназначена для инициализации указателей. Гарантируется, что никакой программный объект никогда не будет иметь адрес NULL.

Примеры:

char *message; /*пример 1*/

int *arrayl[10]; /*пример 2*/

int (*pointerl)[10]; /*пример 3*/

struct list *next, "previous; /*пример 4*/

struct list /*пример 5*/

{

char *token;

int *count;

struct list *next;

} line;

struct id /*пример 6*/

{

unsigned int id_no;

struct name *pname;

} record;

В первом примере объявляется указатель с именем message. Он указывает на значения типа char.

Во втором примере объявлен массив указателей с именем array1. Массив состоит из 10 элементов. Каждый элемент представляет собой указатель на значения типа int.

В третьем примере объявлен указатель с именем pointer1. Он указывает на массив из 10 элементов. Каждый элемент этого массива имеет тип int.

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

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

В шестом примере объявляется структура с именем record, тип которой поименован тегом id. Обратите внимание на то, что элемент с именем pname объявлен как указатель на другой структурный тип с тегом name. Не считается ошибкой появление этого объявления в программе раньше, чем будет объявлен тег name (но тип name должен быть объявлен до первого использования указателя pname в выражении).

3.5. Объявление функции (прототип)

Метод объявления функции, описанный в данном разделе, используется только в версии 4.0 СП MSC. В версии 5.0 СП MSC, а также в СП ТС реализован более современный метод — объявление прототипа функции, а старый метод поддерживается в этих версиях лишь для совместимости программ. В конце данного раздела приведены основные отличия метода объявления прототипа.

Синтаксис:

[<спецификация класса памяти>][<спецификация типа>]<описатель>([<список типов аргументов>]);

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

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

Если спецификация типа в объявлении функции опущена, то предполагается тип int. На внешнем уровне может быть также опущена спецификация класса памяти, а на внутреннем уровне хотя бы одна из спецификаций — класса памяти или типа — должна присутствовать.

В объявлении функции можно задать спецификацию класса памяти extern или static. Классы памяти рассматриваются в разделе 3.6.

Список типов аргументов

Список типов аргументов определяет типы аргументов функции и их число.

Список типов — это список из одного или более имен типов. Каждое имя типа отделяется от другого запятой. Список ограничивается круглыми скобками.

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

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

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

Имя типа для базового, перечислимого типа, структуры или объединения представляет собой спецификацию этого типа (например, int). Имена типов для указателей и массивов формируются путем комбинации спецификации типа с "абстрактным описателем". Абстрактный описатель — это описатель, в котором опущен идентификатор. В разделе 3.8.3 "Имена типов" объясняется, каким образом формировать и интерпретировать абстрактные описатели.

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

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

Список типов аргументов может быть пуст, однако скобки после идентификатора функции все же обязательны. В этом случае в объявлении функции не специфицированы ни типы, ни число аргументов функции. Следовательно, компилятор языка Си не может проверить соответствие типов аргументов при вызове функции. Несоответствие типов аргументов может привести к трудно выявляемым ошибкам во время выполнения программы. Более подробная информация о правилах соответствия типов аргументов приведена в разделе 6.4 "Вызов функции".

Примеры:

int add(int, int); /*пример 1*/

double calc(); /*пример 2*/

char *strfind(char *, ...); /*пример 3*/

void draw(void); /*пример 4*/

double (*sum(double, double))[3]; /*пример 5*/

int (*select(void))(int); /*пример 6*/

char *p; short *q; int prt(void *); /*пример 7*/

fff(int); /*пример 8*/

В первом примере объявляется функция с именем add, которая принимает два аргумента типа int и возвращает значение типа int.

Во втором примере объявляется функция с именем calc, которая возвращает значение типа double. Список типов аргументов пуст.

В третьем примере объявляется функция с именем strfind, которая возвращает указатель на значение типа char. Функция требует по крайней мере один аргумент — указатель на значение типа char. Список типов аргументов заканчивается запятой и многоточием. Это значит, что функция может принять и большее число аргументов.

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

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

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

В седьмом примере объявлена функция prt, которая принимает в качестве аргумента указатель на любой тип и возвращает значение типа int. Любой из указателей p и q мог бы быть вполне корректно использован в качестве аргумента функции.

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

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

char *strcpy(char *result, char *ishod);

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

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

Еще одно отличие метода объявления прототипов состоит в том, что объявление аргумента в прототипе может содержать спецификацию класса памяти register.

3.6. Классы памяти

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

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

В языке Си имеется четыре спецификации класса памяти:

auto

register

static

extern

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

Переменные классов памяти auto и register имеют локальное время жизни. Спецификации static и extern определяют объекты с глобальным временем жизни.

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

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

Функции могут быть объявлены со спецификацией класса памяти static или extern либо вообще без спецификации класса памяти. Функции всегда имеют глобальное время жизни.

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

Если в объявлении функции специфицирован класс памяти static, то и в ее определении должен быть также указан класс памяти static (это требование не является обязательным для СП ТС).

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

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

3.6.1. Объявление переменной на внешнем уровне

Объявления переменной на внешнем уровне используют спецификации класса памяти static и extern или вообще опускают их. Спецификации класса памяти auto и register не допускаются на внешнем уровне.

Объявления переменных на внешнем уровне — это либо определения переменных, либо объявления, т. е. ссылки на определения, сделанные в другом месте.

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

1) Переменная может быть определена путем ее объявления со спецификацией класса памяти static. Такая переменная может быть явно инициализирована константным выражением. Если инициализатор отсутствует, то переменная автоматически инициализируется нулевым значением во время компиляции. Таким образом, каждое из объявлений:

static int k=16;

и

static int k;

рассматривается как определение.

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

int j=3;

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

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

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

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

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

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

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

2) Если же такого определения переменной в программе нет, то данное объявление само считается определением переменной. На этапе компоновки программы переменной выделяется память, которая инициализируется нулевым значением. Если в программе имеется более одного объявления переменной с одним и тем же именем, то размер выделяемой памяти будет равен размеру наиболее длинного типа среди всех объявлений этой переменной. Например, если программа содержит два неинициализированных объявления переменной i на внешнем уровне int i; и char i;, то память будет выделена под переменную i типа int.

Примечание. В описании языка Си, данном его разработчиками в [1], отсутствовала ясная трактовка понятий объявления и определения глобальной переменной. Это привело к тому, что различные компиляторы языка Си используют различные схемы разбора подобных ситуаций. Схема разбора, описанная в данном разделе, рассматривает глобальную переменную как общий блок, разделяемый несколькими исходными файлами. Глобальная переменная фактически представляет собой единую область памяти, которая разделяется несколькими исходными файлами, причем в каждом из них переменная может иметь различный тип.

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

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

Пример:

/*ИСХОДНЫЙ ФАЙЛ 1*/

/*объявление i, ссылающееся на данное ниже определение i*/

extern int i;

main()

{

i=i+1;

printf("%d\n", i); /*значение i равно 4*/

next();

}

int i=3; /*определение i*/

next()

{

i=i+l;

printf("%d\n", i); /*значение i равно 5*/

other();

}

/*ИСХОДНЫЙ ФАЙЛ 2*/

/*объявление i, ссылающееся на определение i в первом исходном файле*/

extern int i;

other()

{

i=i+1;

printf("%d\n", i); /*значение i равно 6*/

}

Два исходных файла в совокупности содержат три внешних объявления i. Только в одном объявлении содержится инициализация:

int i=3; — глобальная переменная i определена с начальным значением 3.

Самое первое объявление extern в первом исходном файле делает глобальную переменную i доступной прежде ее определения в файле. Без этого объявления функция main не могла бы использовать глобальную переменную i. Объявление переменной i во втором исходном файле делает глобальную переменную i доступной во втором исходном файле.

Все три функции выполняют одно и то же действие: увеличивают i на 1 и печатают полученное значение. Значения распечатываются с помощью стандартной библиотечной функции printf. Печатаются значения 4, 5 и 6.

Если бы переменная i не была инициализирована ни в одном из объявлений, она была бы неявно инициализирована нулевым значением при компоновке. В этом случае программа напечатала бы значения 1, 2 и 3.

3.6.2. Объявление переменной на внутреннем уровне

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

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

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

Число регистров, которое может быть использовано для хранения переменных, зависит от компьютера и от реализации компилятора языка Си. Если компилятор языка Си обнаруживает спецификацию класса памяти register в объявлении переменной, а свободного регистра не имеется, или переменная данного типа не может быть размещена в регистре, то переменной выделяется память класса auto. В СП MSC регистровая память всегда выделяется переменным в том порядке, в котором они объявляются в исходном файле. В СП ТС, при наличии нескольких переменных класса памяти register в одном объявлении, регистровая память будет выделяться переменным в обратном порядке. Так, по объявлению register i, j; первой получит регистровую память переменная j.

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

Для каждого рекурсивного входа в блок порождается новый набор переменных класса памяти auto и register. При этом каждый раз производится инициализация переменных, в объявлении которых заданы инициализаторы.

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

Переменная, объявленная со спецификацией класса памяти extern, является ссылкой на переменную с тем же самым именем, определенную на внешнем уровне в любом исходном файле программы. Цель внутреннего объявления extern состоит в том, чтобы сделать определение переменной внешнего уровня (как правило, данное в другом исходном файле) доступным именно внутри данного блока. Внутреннее объявление extern не влияет на область действия объявляемой глобальной переменной в любой другой части программы.

Пример:

int i=1; /*определение i*/

main()

{

/*объявление i, ссылающееся на данное выше определение*/

extern int i;

/*

начальное значение а равно нулю;

область действия а — функция main

*/

static int a;

/*b будет (по возможности) помещено в регистр*/

register int b=0;

/*по умолчанию с будет иметь класс памяти auto*/

int с=0;

/*печатаются значения 1, 0, 0, 0*/

printf("%d, %d, %d, %d\n", i, a, b, с);

other();

}

other()

{

/*локальное переопределение переменной i*/

int i=16;

/*область действия переменной а — функция other*/

static int а=2;

а+=2;

/*печатаются значения 16, 4*/

printf("%d, %d\n", i, a);

}

Переменная i определяется на внешнем уровне с начальным значением 1. В функции main объявление i является ссылкой на определение переменной i внешнего уровня. Эта ссылка необязательна, поскольку и без нее внешняя переменная i доступна во всех функциях данного исходного файла. Переменная а класса памяти static автоматически инициализируется нулевым значением, так как явная инициализация опущена. Определяется переменная b регистрового класса памяти и переменная с класса памяти auto. Вызывается стандартная функция printf, которая печатает значения 1, 0, 0, 0.

В функции other переменная i переопределяется как локальная переменная с начальным значением 16. Это не влияет на значение внешней переменной i, поскольку эти переменные никак не связаны между собой. Переменная а объявляется со спецификацией класса памяти static и начальным значением 2. Она никак не связана с переменной а, объявленной в функции main, так как область действия переменных класса памяти static на внутреннем уровне ограничена блоком, в котором они объявлены. Значение переменной а увеличивается на 2 и становится равным 4. Если бы функция other была вызвана еще раз в той же функции main, то значение а при входе было бы равно 4, а при выходе — 6. Внутренние переменные класса памяти static сохраняют свои значения при входе в блок и выходе из блока, в котором они объявлены. Значение переменной а в функции main при этом не изменилось бы.

3.7. Инициализация

Переменной в объявлении может быть присвоено начальное значение посредством инициализатора. Записи инициализатора в объявлении предшествует знак равенства

=<инициализатор>

Можно инициализировать переменные любого типа. Функции не инициализируются. Объявления, которые используют спецификацию класса памяти extern, не могут содержать инициализатор.

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

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

Инициализация переменных класса памяти auto и register выполняется каждый раз при входе в блок (за исключением входа в блок по оператору goto), в котором они объявлены. Если инициализатор опущен в объявлении переменной класса памяти auto или register, то ее начальное значение не определено. Инициализация переменных составных типов (массив, структура, объединение), имеющих класс памяти auto, запрещена в СП MSC, но допускается в СП ТС даже для переменных, объявленных с модификатором const. Переменные составного типа, имеющие класс памяти static, могут быть инициализированы на внутреннем уровне.

Инициализирующими значениями для переменных внешнего уровня, а также переменных класса памяти static внутреннего уровня должно быть константное выражение (см. раздел 4.2.9). Переменные классов памяти auto и register могут быть инициализированы не только константными выражениями, но и выражениями, содержащими переменные и вызовы функций.

3.7.1. Базовые типы и указатели

Синтаксис:

=<выражение>

Значение выражения присваивается переменной. При необходимости выполняются правила преобразования типов.

Примеры:

int х=10, y=20; /*пример 1*/

register int *px=0; /*пример 2*/

int с=(3 * 1024); /*пример 3*/

int *b=&х; /*пример 4*/

В первом примере переменная х инициализируется константным выражением 10, переменная y инициализируется константным выражением 20. Во втором примере указатель рх инициализирован нулевым значением. В третьем примере используется константное выражение для инициализации переменной с. В четвертом примере указатель b инициализируется адресом переменной х.

3.7.2. Составные типы

Элементы объектов составных типов инициализируются только константными выражениями.

Инициализация объектов составных типов имеет следующий синтаксис:

={<список инициализаторов>}

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

Для инициализации объединения список инициализаторов должен содержать единственное константное выражение. Значение этого константного выражения присваивается первому элементу объединения. В СП ТС не обязательно заключать это константное выражение в фигурные скобки.

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

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

Пример 1:

int p[4][3]=

{

{1, 1, 1},

{2, 2, 2},

{3, 3, 3,},

{4, 4, 4,},

};

В примере объявляется двумерный массив р, размером 4 строки на 3 столбца. Элементы первой строки инициализируются единицами, второй строки — двойками и т. д. Обратите внимание на то, что списки инициализаторов двух последних строк содержат в конце запятую. За последним списком инициализаторов {4, 4, 4,} также стоит запятая. Эти дополнительные запятые не требуются, но допускаются. Требуются только те запятые, которые разделяют константные выражения и списки инициализаторов. Если список инициализаторов не имеет вложенной структуры, аналогичной структуре объекта составного типа, то элементы списка присваиваются элементам объекта в порядке следования. Поэтому вышеприведенная инициализация эквивалентна следующей:

int p[4][3]=

{

1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4

};

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

Пример 2.

struct

{

int n1, n2, n3;

}nlist[2][3]=

{

{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, /*строка 1*/

{{10, 11, 12}, {13, 14, 15}, {15, 16, 17}} /*строка 2*/

};

В примере переменная nlist объявляется как двумерный массив структур, состоящий из двух строк и трех столбцов. Каждая структура содержит три элемента. В строке 1 значения присваиваются первой строке массива nlist следующим образом:

1) Первая левая фигурная скобка строки 1 информирует компилятор языка Си о том, что начинается инициализация первой строки массива nlist (т. е. nlist[0]).

2) Вторая левая фигурная скобка означает, что начинается инициализация первого элемента первой строки массива (т. е. nlist[0][0]).

3) Первая правая фигурная скобка сообщает об окончании инициализации структуры nlist[0][0]. Следующая левая фигурная скобка сообщает о начале инициализации второго элемента первой строки nlist[0][1].

4) Процесс инициализации элементов подмассива nlist[0] продолжается до конца строки 1 и заканчивается по последней правой фигурной скобке.

Аналогично, в строке 2 присваиваются значения второй строке массива nlist, т. е. nlist[l].

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

struct

{

int n1, n2, n3;

} nlist[2][3]=

{

{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, /*строка 1*/

{10, 11, 12}, {13, 14, 15}, {16, 17, 18} /*строка 2*/

};

В этом примере по первой левой фигурной скобке в строке 1 начинается инициализация подмассива nlist[0], который является массивом из трех структур. Значения 1, 2, 3 назначаются трем элементам первой структуры (nlist[0][0]). Когда встретится правая фигурная скобка (после значения 3), инициализация подмассива nlist[0] закончится и две оставшиеся структуры — nlist[0][1] и nlist[0][2] — будут по умолчанию инициализированы нулевыми значениями. Аналогично, список {4, 5, 6} инициализирует первую структуру во второй строке nlist (т.е. nlist[1][0]), а оставшиеся две структуры — nlist[l][1] и nlist[l][2] — по умолчанию инициализируются нулевыми значениями. Когда компилятор языка Си обнаружит следующий список инициализаторов {7, 8, 9 }, он попытается инициализировать подмассив nlist[2]. Однако, поскольку nlist содержит только две строки и элемента nlist[2] в нем не существует, будет выдано сообщение об ошибке.

Пример 3.

union

{

char m[2][3];

int i, j, k;

}y=

{

{'1'},

{'4'}

};

В третьем примере инициализируется переменная y типа объединение, первым элементом объединения является массив; он и будет инициализироваться. Список инициализаторов {'1'} задает значения для первой строки массива (m[0]). Поскольку в списке всего одно значение, то только первый элемент строки массива — m[0][0] — инициализируется символом '1', а оставшиеся два элемента в строке инициализируются по умолчанию нулевыми значениями (символом '\0'). Аналогично, первый элемент второй строки массива m инициализируется значением '4', а остальные элементы инициализируются по умолчанию нулевыми значениями.

3.7.3. Строковые инициализаторы

Существует специальная форма инициализации массива типа char — с помощью символьной строки. Например, объявление

char code[ ] = "abc";

инициализирует массив code четырьмя символами — 'а', 'b', 'с' и символом '\0', который завершает символьную строку.

Если в объявлении размер массива указан, а длина инициализирующей строки превышает указанный размер, то лишние символы отбрасываются. Следующее объявление инициализирует трехэлементный массив code типа char:

charcode[3]="abcd";

В примере только три первые символа инициализатора заносятся в массив code. Символ d и символ '\0' отбрасываются. Если инициализирующая строка короче, чем специфицированный размер массива, то оставшиеся элементы массива инициализируются нулевым значением (символом '\0').

Символьной строкой можно инициализировать не только массив типа char, но и указатель на тип char. Например, в объявлении

char *ptr="abcd";

указатель ptr будет инициализирован адресом массива типа char, содержащего символы 'а', 'b', 'с', 'd', '\0'.

3.8. Объявление типа

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

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

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

3.8.1. Объявление тега

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

Примеры:

/*пример 1*/

enum status

{

loss=-1,

bye,

tie=0,

win

};

/*пример 2*/

struct student

{

char name[20];

int id, class;

};

В первом примере объявляется перечислимый тип с именем status. Имя типа может быть использовано в объявлениях переменных этого перечислимого типа. Идентификатору loss явно присваивается значение -1. Идентификаторы bye и tie ассоциируются со значением 0, a win - со значением 1.

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

3.8.2. Объявление typedef

Синтаксис:

typedef<спецификация типа><описатель>[,<описатель>...];

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

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

Принято записывать идентификаторы типов, объявленные посредством typedef, прописными буквами, однако это не является требованием языка.

Примеры:

/*пример 1*/

typedef int WHOLE;

/*пример 2*/

typedef struct club

{

char name[30];

int size, year;

} GROUP;

/*пример 3*/

typedef GROUP *PG;

/*пример 4*/

typedef void DRAWF(int, int);

В первом примере объявляется тип WHOLE как синоним для типа int.

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

В третьем примере используется имя типа GROUP для объявления типа указатель. Тип PG объявляется как указатель на тип GROUP, который определен ранее как структурный тип. Например, объявление PG ptr; эквивалентно объявлению struct club *ptr.

В последнем примере объявлен тип DRAWF для функции, не возвращающей значения и требующей два аргумента типа int. Например, объявление DRAWF box; эквивалентно объявлению void box(int, int);.

3.8.3. Абстрактные имена типов

В разделах 3.8.1 и 3.8.2 рассматривались объявления, в которых типам присваиваются идентификаторы для последующего использования. Однако иногда возникает необходимость специфицировать некоторый тип данных без присвоения ему идентификатора и без объявления какого-либо объекта. Такая конструкция, определяющая тип без имени, называется абстрактным именем типа. Абстрактные имена типов используются в трех контекстах: в списках типов аргументов при объявлении функций, в операции приведения типа и в операции sizeof. Списки типов аргументов рассматривались в разделе 3.5 "Объявление функции". Операция приведения типа и операция sizeof обсуждаются в разделах 4.7.2 и 4.3.2, соответственно.

Абстрактными именами для базовых, перечислимых, структурных типов и объединений являются просто соответствующие им спецификации типа. Если в абстрактном имени типа задано определение тега (см. раздел 3.8.1), то область действия этого тега распространяется в СП MSC на остаток блока, а в СП ТС — на остаток тела функции. Абстрактные имена для типов указатель, массив и функция задаются следующей синтаксической конструкцией:

<спецификация типа><абстрактный описатель>

Абстрактный описатель отличается от обычного описателя только тем, что он не содержит идентификатора. Как и обычный описатель, он может содержать один или более признаков указателя, массива и функции. Для интерпретации абстрактного описателя следует прежде всего определить в нем место подразумеваемого идентификатора. После этого интерпретация проводится так же, как описано в разделе 3.3.2. Абстрактный описатель, состоящий только из пары пустых круглых скобок, недопустим, поскольку он не позволяет однозначно определить, где подразумевается идентификатор: если внутри скобок, то описан простой тип (заданный только спецификацией типа), а если перед скобками, то тип функция.

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

Примеры:

long * /*пример 1*/

int (*)[5] /*пример 2*/

int (*)(void) /*пример 3*/

PG /*пример 4*/

В первом примере задано абстрактное имя типа для указателя на тип long.

Во втором примере задано абстрактное имя типа для указателя на массив из пяти элементов типа int.

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

В четвертом примере с помощью идентификатора PG, объявленного посредством typedef в разделе 3.8.2, задано абстрактное имя типа "указатель на структуру с тегом club".