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

В разделах 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".

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

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

Сложение (+)

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

складывается с указателем, то i

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

Вычитание (-)

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

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

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

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

Тип, который имеет разность указателей, зависит от компьютера, поэтому он определен посредством typedef в стандартном включаемом файле stddef.h. Имя этого типа — ptrdiff.t. Если разность указателей не может быть представлена этим типом, следует явно приводить ее к типу long.

Адресная арифметика

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

На компьютерах с сегментной архитектурой памяти (в частности, с микропроцессором типа 8086/8088) аддитивные операции над адресным и целым значениями могут не всегда выполняться правильно. Это вызвано тем, что указатели, используемые в программе, могут иметь различные размеры в зависимости от используемой модели памяти. Например, при компиляции программы в некоторой стандартной модели памяти адресные модификаторы (near, huge, far) могут специфицировать для какого-либо указателя другой размер, чем определяемый по умолчанию выбранной моделью памяти. Более подробная информация о работе с указателями в различных моделях памяти приведена в разделе 8 "Модели памяти".

Примеры:

int i = 4, j;

float x[10];

float *px;

px =

&x[4] + 1;       /* пример 1 */

j = &x[i] — &x[i-2];  /* пример 2*/

В первом примере целочисленный операнд i складывается с адресом пятого (по порядку следования) элемента массива х. Значение i

умножается на длину типа float и складывается с адресом x[4]. Значение результирующего указателя представляет собой адрес девятого элемента массива.

Во втором примере адрес третьего элемента массива х (заданный как &х[i-2]) вычитается из адреса пятого элемента (заданного как &x[i]). Полученная разность делится на размер типа float. В результате получается целое значение 2.

Алфавит

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

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

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

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

символ. Компилятор языка Си выдает сообщение об ошибке при обнаружении неверно использованных символов.

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

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

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

Таблица 3.1.

Базовые типы		Спецификация типов
Целые		signed char		знаковый символьный
		signed int		знаковый целый
		signed short int		знаковый короткий целый
		signed long int		знаковый длинный целый
		unsigned char		беззнаковый символьный
		unsigned int		беззнаковый целый
		unsigned short int		беззнаковый короткий целый
		unsigned long int		беззнаковый длинный целый
Плавающие		float		плавающий одинарной точности
		double		плавающий двойной точности
		long float		длинный плавающий одинарной точности
		long double		длинный плавающий двойной точности
Прочие		void		пустой
		enum		перечислимый

Тип 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.

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

Спецификация типа	Сокращение
signed char	char
signed int	signed, int
signed short int	short, signed short
signed long int	long, signed long
unsigned char	-
unsigned int	unsigned
unsigned short int	unsigned short
unsigned long int	unsigned long
float	-
long float	double
long double	double (СП MSC 5.0, СП TC 1.5)
long double	—(СП TC 2.0)

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

по умолчанию имеет знак.

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

Синтаксис:

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

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

Примеры:

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

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

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

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

В первом примере переменная х инициализируется константным выражением 10, переменная у

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

Буквы и цифры

Множество символов языка Си включает прописные и строчные буквы латинского алфавита и арабские цифры:

прописные латинские буквы: ABCDEFGHIJKLMNOPQRSTUVWXYZ;

строчные латинские буквы: abcdefghijkimnopqrstuvwxyz;

десятичные цифры: 0123456789.

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

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

Целые константы

Целая константа — это десятичное, восьмеричное или шестнадцатеричное число, которое представляет целое значение.

Десятичная константа имеет следующий формат представления:

<цифры>

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

Восьмеричная константа имеет следующий формат представления:

0<в-цифры>

<в-цифры>—это одна или более восьмеричных цифр от 0 до 7. Запись нуля впереди обязательна.

Шестнадцатеричная константа имеет следующий формат представления:

0х<ш-цифры>

или 0Х<ш-цифры>

<ш-цифры> —одна или более шестнадцатеричных цифр. Шестнадцатеричная цифра может быть цифрой от 0 до 9 или буквой (большой или малой) от А до F. Допускается "смесь" больших и малых букв. Запись нуля впереди и следующего за ним символа х или Х обязательна.

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

Таблица 1.4.

Десятичные константы		Восьмеричные константы		Шестнадцатеричные константы
10		012		0ха или 0хА
132		0204		0х84
32179		076663		0x7dB3 или 0x7DB3

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

Каждая целая константа имеет тип, определяющий ее представление в памяти (описание типов приведено в разделе 3.1 "Базовые типы данных"). Десятичные константы могут иметь тип int (целый тип) или long (длинный целый тип).

Восьмеричные и шестнадцатеричные константы в зависимости от размера могут иметь тип int, unsigned int, long или unsigned long. Если константа может быть представлена типом int, то компилятор языка Си присваивает ей тип int. Если ее значение больше, чем максимальное положительное значение, которое может быть представлено типом int, но может быть представлено тем же числом битов, что и int, ей присваивается тип unsigned int. Наконец, константа, значение которой больше, чем максимальное значение, представляемое типом unsigned int, задается типом long

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

имеет длину 16 битов и тип long имеет длину 32 бита.

Таблица1.5.

Десятичные константы	Восьмеричные константы	Шестнадцатеричные константы	Тип
0—32767	0—077777	0х0—0x7FFF	int
	0100000—0177777	0х8000—0xFFFF	unsigned int
32767—2147483647	02000001—017777777777	0х10000—0x7FFFFFFF	long
	020000000000—030000000000	0х80000000—0xFFFFFFFF	unsigned long

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

Программист может явно определить для любой целой константы тип long, записав букву "l" или "L"

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

Таблица 1.6.

Десятичные константы	Восьмеричные константы	Шестнадцатеричные константы
12L	012L	0xaL или 0xAL
0l	0115l	0х4fl или 0x4Fl

В СП ТС

реализован также суффикс U (или u), означающий, что константа имеет тип unsigned. Можно использовать одновременно оба суффикса — L и U — для одной и той же константы. Кроме того, в СП ТС константе присваивается тип unsigned long, если ее значение превышает 65535, независимо от наличия или отсутствия суффикса U (в СП MSC в этом случае константе был бы присвоен тип long).

Директива #define

Синтаксис:

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

#define <идентификатор> <список параметров> <текст>

Директива #define заменяет все вхождения <идентификатора> в исходном файле на <текст>, следующий в директиве за <идентификатором>. Этот процесс называется макроподстановкой, <идентификатор> заменяется лишь в том случае, если он представляет собой отдельную лексему. Например, если <идентификатор> является частью строки или более длинного идентификатора, он не заменяется. Если за <идентификатором> следует <список параметров>, то директива определяет макроопределение с аргументами.

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

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

дает значение 1 (смотри раздел 7.4.1).

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

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

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

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

Внутрь <текста> в директиве #define могут быть вложены имена других макроопределений или констант. Их расширение производится лишь при расширении <идентификатора> этого <текста>, а не при его определении директивой #define. Это надо учитывать, в частности, при взаимодействии вложенных именованных констант и макроопределений с директивой #undef: к моменту расширения содержащего их текста они могут уже оказаться отменены директивой #undef.

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

#define х х

не приведет к зацикливанию препроцессора.

Примеры.

/* пример 1 */

#define WIDTH 80

#define LENGTH (WIDTH +

10)

/* пример 2 */

#define FILEMESSAGE "Попытка создать файл\

не удалась из-за нехватки дискового пространства"

/* пример 3 */

#define REG1 register

#define REG2 register

#define REG3

/* пример 4 */

#define MAX(x, y)((x)>(у)) ? (x) : (у)

/* пример 5 */

#define MULT(a, b) ((a)*(b))

В первом примере идентификатор WIDTH определяется как целая константа со значением 80, а идентификатор LENGTH — как текст (WIDTH +

10). Каждое вхождение идентификатора LENGTH в исходный файл будет заменено на текст (WIDTH + 10), который после расширения идентификатора WIDTH превратится в выражение (80 + 10). Скобки, окружающие текст (WIDTH +



10), позволяют избежать ошибок в операторах, подобных следующему:

var = LENGTH * 20;

После обработки препроцессором оператор примет вид:

var = (80 + 10)* 20;

Значение, которое присваивается var, равно 1800. В отсутствие скобок в макроопределении оператор имел бы следующий вид:

var = 80 + 10*20;

Значение var равнялось бы 280, поскольку операция умножения имеет более высокий приоритет, чем операция сложения.

Во втором примере определяется идентификатор FILEMESSAGE. Его определение продолжается на вторую строку путем использования символа обратный слэш непосредственно перед нажатием клавиши ENTER.

В третьем примере определены три идентификатора, REG1, REG2, REG3. Идентификаторы REG1 и REG2 определены как ключевые слова register. Определение REG3 опущено и, таким образом, любое вхождение REG3 будет удалено из исходного файла. В разделе 7.4.1 приведен пример, показывающий, как эти директивы могут быть использованы для задания класса памяти register

наиболее важным переменным программы.

В четвертом примере определяется макроопределение МАХ. Каждое вхождение идентификатора МАХ в исходном файле заменяется на выражение ((x)>(у))?(x):(у), в котором вместо формальных параметров х и у подставлены фактические. Например, макровызов

МАХ(1,2)

заменится на выражение

((1)>(2))?(1):(2)

а макровызов

MAX(i, s[i])

заменится на выражение

((i)>(s(i]))?(i):(s(i])

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

MAX(i, s[i++])

заменится на выражение

((i)>(s[i++]))?(i):(s[i++])

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

В пятом примере определяется макроопределение MULT. Макровызов MULT(3,5) в тексте программы заменяется на (3)*(5). Круглые скобки, в которые заключаются фактические аргументы, необходимы в тех случаях, когда аргументы макроопределения являются сложными выражениями. Например, макровызов

MULT(3+4,5+6)

заменится на (3+4)*(5+6), что равняется 76. В отсутствие скобок результат подстановки 3+4*5+6 был бы равен 29.

Директива обработки ошибок

В СП ТС

реализована директива #error. Ее формат:

#error <текст>

Обычно эту директиву записывают среди директив условной компиляции для обнаружения некоторой недопустимой ситуации. По директиве #error

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

Fatal: <имя-файла> <номер-строки> Error directive: <текст>

Fatal — признак фатальной ошибки; <имя-файла> — имя исходного файла; <номер-строки> — текущий номер строки; Error directive — сообщение об ошибке в директиве; <текст> — собственно текст диагностического сообщения.

Например, если именованная константа MYVAL может иметь значение либо 0, либо 1, можно поместить в исходный файл операторы условной компиляции для проверки на некорректное значение MYVAL:

#if (MYVAL != 0 && MYVAL != 1)

#error MYVAL должно иметь значение либо 0, либо 1

#endif

Препроцессор просматривает текст сообщения в директиве #error, и исключает из него комментарии (если они имеются), но именованные константы и макроопределения в тексте не выявляет и макроподстановку не производит.

Директива #undef

Синтаксис:

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

Директива #undef отменяет действие текущего определения #define для <идентификатора>. Чтобы отменить макроопределение посредством директивы #undef, достаточно задать его <идентификатор>. Задание списка параметров не требуется.

Не является ошибкой применение директивы #undef

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

Директива #undef обычно используется в паре с директивой #define, чтобы создать область исходной программы, в которой некоторый идентификатор определен.

Пример:

#define WIDTH 80

#define ADD(X, Y) (X)+(Y)

#undef WIDTH

#undef ADD

В этом примере директива #undef отменяет определение именованной константы WIDTH и макроопределения ADD. Обратите внимание на то, что для отмены макроопределения задается только его идентификатор.

Директивы #if, #elif, #else, #endif

Синтаксис:

#if <ограниченное-константное-выражение> [<текст>]

[#elif <ограниченное-константное-выражение> <текст>]

[#elif <ограниченное-константное-выражение> <текст>]

[#else <текст>]

#endif

Директива #if совместно с директивами #elif, #else и #endif управляет компиляцией частей исходного файла. Каждой директиве #if в том же исходном файле должна соответствовать завершающая ее директива #endif. Между директивами #if и #endif

допускается произвольное количество директив #elif

(в том числе ни одной) и не более одной директивы #else. Если директива #else присутствует, то между ней и директивой #endif на данном уровне вложенности не должно быть других директив #elif.

Препроцессор выбирает один из участков <текста> для обработки. <Текст> может занимать более одной строки. Обычно это участок программного текста, однако это не обязательно: препроцессор можно использовать для обработки произвольного текста. Если <текст> содержит директивы препроцессора (в том числе и директивы условной компиляции), то эти директивы выполняются. Обработанный препроцессором текст передается на компиляцию.

Участок текста, не выбранный препроцессором, игнорируется на стадии препроцессорной обработки и не компилируется.

Препроцессор выбирает участок текста для обработки на основе вычисления <ограниченного-константного-выражения>, следующего за каждой директивой #if или #elif. Выбирается <текст>, следующий за <ограниченным-константным-выражением> со значением истина (не нуль), вплоть до ближайшей директивы #elif, #else, или #endif, ассоциированной с данной директивой #if.

Если ни одно ограниченное константное выражение не истинно, то препроцессор выбирает <текст>, следующий за директивой #else. Если же директива #else отсутствует, то никакой текст не выбирается.

Ограниченное константное выражение описано в разделе 4.2.9 "Константные выражения". Такое выражение не может содержать операцию sizeof (в СП ТС — может), операцию приведения типа, константы перечисления и плавающие константы, но может содержать препроцессорную операцию defined(<идентификатор>). Эта операция дает истинное (не равное нулю) значение, если заданный <идентификатор> в данный момент определен; в противном случае выражение ложно (равно нулю). Следует помнить, что идентификатор, определенный без значения, тем не менее рассматривается как определенный. Операция defined

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

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

#if defined(mysym) || defined(yoursym)

СП TC ( в отличие от СП MSC) позволяет использовать операцию sizeof в ограниченном константном выражении для препроцессора. В следующем примере в зависимости от размера указателя определяется одна из констант — либо SDATA, либо LDATA:

#if (sizeof(void *) == 2)

#define SDATA

#else

#define LDATA

#endif

Директивы #if могут быть вложенными. При этом каждая из директив #else, #elif, #endif ассоциируется с ближайшей предшествующей директивой #if.

Примеры:

/* пример 1 */

#if defined(CREDIT)

credit();

#elif defined (DEBIT)

debit();

#else

printerror();

#endif

/* пример 2 */

#if DLEVEL > 5

#define SIGNAL 1

#if STACKUSE == 1

#derine STACK 200

#else

#define STACK 100

#endif

#else

#define SIGNAL 0

#if STACKUSE == 1

#define STACK 100

#else

#define STACK 50

#endif

#endif

/* пример 3 */

#if DLEVEL == 0

#define STACK 0

#elif DLEVEL == 1

#define STACK 100

#elif DLEVEL > 5

display(debugptr);

#else

#define STACK 200

#endif

/* пример 4 */

#define REG 1 register

#define REG2 register

#if defined (M_86)

#define REG3

#define REG4

#else

#ifdefined(M_68000)

#define REG4 register

#endif

#endif

В первом примере директивы #if, #elif, #else, #endif

управляют компиляцией одного из трех вызовов функции. Вызов функции credit компилируется, если определена именованная константа CREDIT. Если определена именованная константа DEBIT, то компилируется вызов функции debit. Если ни одна из .именованных констант не определена, то компилируется вызов функции printerror. Следует учитывать, что CREDIT и credit являются различными идентификаторами в языке Си.

В следующих двух примерах предполагается, что константа DLEVEL предварительно определена директивой #define.

Во втором примере показаны два вложенных набора директив #if, #else, #endif. Первый набор директив обрабатывается, если значение DLEVEL больше 5. В противном случае обрабатывается второй набор.



В третьем примере директивы уловной компиляции используют для выбора текста значение константы DLEVEL. Константа STACK определяется со значением 0, 100 или 200, в зависимости от значения DLEVEL. Если DLEVEL больше 5, то компилируется вызов функции display, а константа STACK не определяется.

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

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

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

func(REG3 int а)

{

REG1 int b;

REG2 int c;

REG4 int d;

}

Если определена константа М_86, препроцессор удаляет идентификаторы REG3 и REG4 из файла путем замены их на пустой текст. Регистровую память в этом случае получат только переменные b и с. Если определен идентификатор М_68000, то все четыре переменные объявляются с классом памяти register.

Если не определена ни одна из констант — ни М_86, ни М_68000, — то регистровую память получат переменные а, b и с.

Директивы #ifdef и #ifndef

Синтаксис:

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

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

Аналогично директиве #if, за директивами #ifdef и #ifndef может следовать набор директив #elif и директива #else. Набор должен быть завершен директивой #endif.

Использование директив #ifdef и #ifndef эквивалентно применению директивы #if,

использующей выражение с операцией defined(<идентификатор>). Эти директивы поддерживаются исключительно для совместимости с предыдущими версиями компиляторов языка Си. Для новых программ рекомендуется использовать директиву #if

с операцией defined(<идентификатор>).

Когда препроцессор обрабатывает директиву #ifdef, он проверяет, определен ли в данный момент <идентификатор> директивой #define. Если да, условие считается истинным, если нет — ложным.

Директива #ifndef противоположна по действию директиве #ifdef. Если <идентификатор> не был определен директивой #define, или его определение уже отменено директивой #undef, то условие считается истинным. В противном случае условие ложно.

Фактические аргументы

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

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

Фактические аргументы (выражения в вызове функции) вычисляются и преобразуются следующим образом:

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

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

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

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

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

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

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

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

Пример:



main()

{

void swap(int *, int *);

int x, у;

swap(&x, &y);

}

void swap(int *a, int *b)

{

int t;

t = *a;

*a = *b;

*b = t;

}

В функции main функция swap

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

также объявлены как указатели на int. При вызове функции

swap(&x, &y)

адрес х запоминается в а, адрес у

запоминается в b. Выражения *a

и *b в функции swap

ссылаются на переменные х и у

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

Формальные параметры

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

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

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

Для доступа к значениям параметров, имена которых не заданы в списке параметров функции, рекомендуется использовать макроопределения va_arg, va_end, va_start, описанные в разделе 12.

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

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

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

char s[];

char s[10];

char *s;

Параметры могут иметь класс памяти auto

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

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

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

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

После преобразования все формальные параметры имеют тип размером не меньше, чем int,

и ни один из формальных параметров не имеет тип float. Это означает, например, что объявление формального параметра с типом char эквивалентно его объявлению с типом int, а объявление с типом float эквивалентно объявлению с типом double.

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

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



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

Пример:

struct student {

char name [20];

int id;

long class;

struct student *nextstu;

} student;

main(void)

{

int match(struct student *, char *);

.

.

.

if(match (student.nextstu, student.name) > 0) {

.

.

.

}

}

match (struct student *r, char *n)

{

int i = 0;

while(r->name[i] == n[i])

if(r->name[i++] == '\0')

return(r->id);

return (0);

}

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

Функция match объявлена с двумя аргументами. Первый аргумент — указатель на структуру типа student, второй — указатель на значение типа char.

В определении функции match заданы два формальных параметра, r и n. Параметр r

объявлен как указатель на структуру типа student. Параметр n объявлен как указатель на значение типа char. По умолчанию, для функции match

подразумевается тип возвращаемого значения int.

Функция match вызывается с двумя аргументами. Оба аргумента являются элементами переменной структурного типа student с именем student.

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

Обратите внимание на то, что имя массива, заданное в качестве второго аргумента в вызове функции, преобразуется по умолчанию к указателю на char. В функцию передается не сам массив, а адрес начала массива. Соответствующий формальный параметр также объявлен как указатель на char, а мог бы быть объявлен и как char n[], поскольку в выражении используется как идентификатор массива. Идентификатор массива рассматривается в выражении как адресное выражение, поэтому объявление формального параметра char *n; эквивалентно объявлению char n[];.

Внутри функции объявляется локальная переменная i, используемая в качестве индекса массива. Функция возвращает структурный элемент id, если структурный элемент name совпал с содержимым массива n; в противном случае функция возвращает нулевое значение.

Идентификаторы

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

В идентификаторах версии 1.5 СП ТС допускается знак $, однако, идентификатор не может с него начинаться.

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

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

Примеры идентификаторов:

temp1

top_of_page

skip12

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

add

ADD

Add

aDD

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

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

Например, идентификатор while недопустим (однако идентификатор While—допустим).

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

1) Идентификаторы переменных целого и плавающего типа представляют значения соответствующего типа.

2) Идентификатор переменной перечислимого типа представляет значение одной константы из соответствующего этому типу списка перечисления. Тип этого значения—int.

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

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

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

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

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

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

Директива #define обычно используется для замены часто используемых в программе констант, ключевых слов, операторов и выражений осмысленными идентификаторами. Идентификаторы, которые заменяют числовые или текстовые константы либо произвольную последовательность символов, называются именованными константами. Идентификаторы, которые представляют некоторую последовательность действий, заданную операторами или выражениями языка Си, называются макроопределениями. Макроопределения могут иметь аргументы. Обращение к макроопределению в программе называется макровызовом.

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

Директива #undef отменяет текущее определение именованной константы. Только когда определение отменено, именованной константе может быть сопоставлено другое значение. Однако многократное повторение определения с одним и тем же значением не считается ошибкой.

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

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

Имеется ряд предопределенных идентификаторов, которые нельзя использовать в директивах #define и #undef в качестве идентификаторов. Они рассмотрены в разделе 7.9 "Псевдопеременные".

Индексные выражения

Синтаксис:

<выражение1>[<выражение2>]

Здесь квадратные скобки являются символами языка Си, а не элементами описания.

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

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

Индексное выражение вычисляется путем сложения целого значения со значением указателя (или с адресом массива) и последующим применением к результату операции косвенной адресации. Операция косвенной адресации описана в разделе 4.3.2. Например, для одномерного массива следующие четыре выражения эквивалентны, если а — массив или указатель, а b — целое.

а[b]

*(а + b)

*(b + а)

b[а]

В соответствии с правилами преобразования типов для операции сложения (смотри раздел 4.3.4) целочисленное значение при сложении с указателем (адресом) должно умножаться на размер типа, адресуемого указателем. Предположим, например, что идентификатор line

определен как массив типа int. При вычислении выражения line[i], целое значение i умножается на размер типа int. Полученное значение представляет i

ячеек типа int. Это значение складывается со значением указателя line, что дает адрес объекта, смещенного на i ячеек типа int

относительно line, т.е. адрес i-го элемента line.

Заключительным шагом вычисления индексного выражения является применение к полученному адресу операции косвенной адресации. Результатом является значение i-го элемента массива line.

Следует помнить, что индексное выражение line[0] представляет значение первого элемента массива, так как индексация элементов массива начинается с нуля. Следовательно, выражение line[5] ссылается на шестой по порядку следования в памяти элемент массива.

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

Индексное выражение может иметь более одного индекса. Синтаксис такого выражения следующий:

<выражение1>[<выражение2>][<выражение3>]…

Индексное выражение интерпретируется слева направо. Сначала вычисляется самое левое индексное выражение — <выражение1>[<выражение2>]. С адресом, полученным в результате сложения <выражения1> и <выражения2>, складывается (по правилам сложения указателя и целого) <выражение3> и т. д. <ВыражениеЗ> и последующие <выражения> имеют целый тип. Операция косвенной адресации осуществляется после вычисления последнего индексного выражения. Однако, если значение последнего указателя адресует значение типа массив, операция косвенной адресации не применяется (смотри третий и четвертый примеры ниже).

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

Примеры:

int рrор[3][4][6];

int i, *ip, (*ipp)[6];

i =

prop[0][0][1];      /*

пример 1 */

i = prop[2][1][3];      /* пример 2 */

ip = prop[2][1];        /* пример 3 */

ipp =

prop[2];          /*

пример 4 */

Массив с именем prop содержит 3 элемента, каждый из которых является двумерным массивом значений типа int. В примере 1 показано, каким образом получить доступ ко второму элементу (типа int) массива prop. Поскольку массив заполняется построчно, последний индекс меняется наиболее быстро. Выражение prop[0][0][2] ссылается на следующий (третий) элемент массива и т. д.

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

1) Первый индекс 2 умножается на размер двумерного массива (4 на 6), затем на размер типа int и прибавляется к значению указателя prop. Результат будет указывать на третий двумерный массив (размером 4 на 6 элементов) в трехмерном массиве prop.

2) Второй индекс 1 умножается на размер 6-элементного массива типа int

и прибавляется к адресу, представляемому выражением prop[2].

3) Каждый элемент 6-элементного массива имеет тип int, поэтому индекс 3 умножается на размер типа int и прибавляется к адресу, представляемому выражением prop[2][1].

Результирующий указатель адресует четвертый элемент массива из шести элементов.

4) На последнем шаге вычисления выражения рrор[2][1][3] выполняется косвенная адресация по указателю. Результатом является элемент типа int, расположенный по вычисленному адресу.

В примерах 3 и 4 представлены случаи, когда косвенная адресация не применяется. В примере 3 выражение prop[2][1] представляет указатель на массив из шести элементов в трехмерном массиве prop. Поскольку значение указателя адресует массив, операция косвенной адресации не применяется. Аналогично, результатом вычисления выражения prop[2] в примере 4 является значение указателя, адресующего двумерный массив.

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

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

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

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

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

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

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

Инициализация переменных класса памяти auto

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

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

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

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

Модификаторы const, volatile, near, far, huge

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

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

int * const р; - это 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 *);

7    6      2   1  3 5     4

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

1. Идентификатор getint

объявляется как

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

char*(*(*var)())[10].

7 6 4 2 1  3 5

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.

Исходная программа

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

Объявление переменной задает имя и атрибуты переменной. Определение переменной, помимо задания ее имени и атрибутов, приводит к выделению для нее памяти. Кроме того, определение задает начальное значение переменной (явно или неявно).

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

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

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

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

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

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

int х = 1; /* определения переменных. */

inl у = 2;

extern int printf(char *, ..,); /* объявление функции */

main () /* определение главной функции */

{

int z; /* объявления переменных */

int w;

z = у + х; /* выполняемые операторы */

w = y – x;

printf("z = %d\nw = %d\n", z, w);

}

Эта исходная программа определяет функцию с именем main

и объявляет функцию printf. Переменные х и у определяются на внешнем уровне, а переменные z и w объявляются внутри функции.

Исходные файлы

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

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

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

в те исходные файлы, в которых они требуются.

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

В нижеследующем примере исходная программа состоит из двух исходных файлов. Функции main и max

представлены в отдельных файлах. Функция main

использует функцию max в процессе своего выполнения.

/* исходный файл 1 — функция main */

#define ONE 1

#define TWO 2

#define THREE 3

extern int max (int, int); /* объявление функции */

main () /* определение функции */

{

int w = ONE, x = TWO, у = THREE;

int z = 0;

z = max(x, y);

z = max(z, w);

}

/* исходный файл 2 — функция max */

int max (a, b) /* определение функции */

int a, b;

{

if ( a > b )

return (a);

else

return (b);

}

В первом исходном файле функция max

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

содержит вызовы функции max.

Строки, начинающиеся с символа #, являются директивами препроцессора. Директивы указывают препроцессору на необходимость замены в первом исходном файле идентификаторов ONE, TWO, THREE на соответствующие значения. Область действия директив не распространяется на второй исходный файл.

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

Явные преобразования типов

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

(<абстрактное-имя-типа>) <операнд>

<абстрактное-имя-типа> — специфицирует некоторый тип; <операнд> — выражение, значение которого должно быть преобразовано к специфицированному типу (абстрактные имена типов рассмотрены в разделе 3.8.3).

Преобразование операнда осуществляется так, как если бы он присваивался переменной типа <имя-типа>. Правила преобразования для операции присваивания, приведенные в разделе 4.7.1, полностью действуют для операции приведения типа. Однако, преобразование к типу char или short выполняется как преобразование к int. а преобразование к типу float — как преобразование к double.

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

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

Результат операции приведения типа L-выражения сам является L-выражением и может представлять левый (или единственный) операнд операции присваивания, если приведенный тип не превышает по размеру исходный тип.

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

int (*р)(long);             /* объявление указателя на функцию */

(*(int(*)(int))р)(0);       /*вызов функции по указателю */

В операции приведения типа можно также задавать объявление структурного типа (тега), например:

(struct {int

a; int b;} *)р->а = 5;

Область действия этого тега распространяется в СП MSC на остаток блока, а в СП ТС — на остаток тела функции.

ЭЛЕМЕНТЫ ЯЗЫКА СИ

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

–         алфавит;

–         константы;

–         идентификаторы;

–         ключевые слова;

–         комментарии.

Компилятор языка Си воспринимает исходный файл, содержащий программу на языке Си, как последовательность текстовых строк. Каждая строка завершена символом новой строки. Этот символ вставляется текстовым редактором при нажатии клавиши ENTER (ВВОД).

Компилятор языка Си последовательно считывает строки программы и разбивает каждую из считанных строк на группы символов, называемые лексемами. Лексема—это единица текста программы, которая имеет самостоятельный смысл для компилятора языка Си и которая не содержит в себе других лексем. Никакие лексемы, кроме символьных строк, не могут продолжаться на последующих строках текста программы. Знаки операций, константы, идентификаторы и ключевые слова, описанные в этом разделе, являются примерами лексем. Разделители, например квадратные скобки [], фигурные скобки {}, круглые скобки (), угловые скобки < >

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

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

i+++j

В этом примере компилятор языка Си вначале сформирует из первых двух знаков "плюс" операцию инкремента (++), а из оставшегося знака плюс — операцию сложения. Выражение проинтерпретируется как (i++)+(j), а не как (i)+(++j). В подобных случаях рекомендуется для ясности разделять лексемы пробельными символами или круглыми скобками.

Класс памяти

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

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

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

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

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

auto

register

static

extern

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

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

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

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

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

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

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

(это требование не является обязательным для СП ТС).

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

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

Ключевые слова

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

список ключевых слов:

auto

continue

else

for

long

signed

switch

void

break

default

enum

goto

register

sizeof

typedef

while

case

do

extern

if

return

static

union

char

double

float

int

short

struct

unsigned

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

#define BOOL int

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

Имеется также ряд специальных ключевых слов:

СП MSC:		cdecl		СП ТС:		asm		_cs		_BX
		far				cdecl		_ds		_ch
		fortran				far		_es		_cl
		huge				huge		_ss		_Cx
		near				interrupt		_AH		_DH
		pascal				near		_AL		_DI
		const				pascal		_AX		_DL
		volatile				const		_BH		_DX
		interrupt				volatile		_BL		_SI
								_BP		_SP

В версии 4.0 СП MSC ключевые слова const и volatile зарезервированы, но использовать их невозможно. В версии 5.0 СП MSC ключевое слово volatile реализовано лишь синтаксически, а const — полностью (как синтаксически, так и семантически). В СП ТС и const, и volatile полностью реализованы. В версии 4.0 СП MSC ключевое слово interrupt не реализовано.

Ключевое слово fortran используется для организации связи программ, написанных на языках Си и Фортран. По действию оно аналогично ключевому слову pascal. Ключевое слово asm применяется для записи в программе на языке Си ассемблерных инструкций. Специальные ключевые слова, начинающиеся с подчеркивания, представляют собой имена псевдопеременных, соответствующих регистрам микропроцессора. Ключевые слова cdecl, pascal, interrupt, near, far, huge, const, volatile объясняются подробно в разделе 3.3.3 "Описатели с модификаторами".

это последовательность символов, которая воспринимается

Комментарий — это последовательность символов, которая воспринимается компилятором языка Си как отдельный пробельный символ и игнорируется. Комментарий имеет следующий вид:
/* <символы> */
<символы> должны принадлежать множеству представимых символов. Символ новой строки также допустим внутри комментария. Это означает, что комментарии могут занимать более одной строки программного текста. Внутри комментария недопустима комбинация символов */.
Это означает, что комментарии не могут быть вложенными.
Компилятор языка Си рассматривает комментарий как пробельный символ, поэтому комментарии допускается использовать везде, где можно использовать пробельные символы (но нельзя, например, внутри лексем). Компилятор языка Си игнорирует все символы комментария, поэтому даже запись в комментариях ключевых слов не приведет к ошибке.
Следующие примеры иллюстрируют использование комментариев:
/* Комментарии помогают документировать программу.*/
/* Комментарии могут содержать ключевые слова, например while и for */
/********************
Комментарий может занимать
несколько строк.
********************/
Так как комментарии не могут содержать вложенных комментариев, то следующий пример будет ошибочным:
/* Недопустимы /* вложенные */ комментарии */
Компилятор языка Си распознает первую комбинацию символов */ после слова "вложенные" как конец комментария. Затем компилятор языка Си попытается обработать оставшийся текст и выявить в нем лексемы языка Си, что приведет к ошибке.
Во избежание случайного возникновения ситуации вложенности комментариев рекомендуется ограничивать участок программного текста, который должен быть закомментирован, директивами препроцессора #if 0 и #endif.
В СП ТС
существует опция компиляции, допускающая вложенные комментарии.

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

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

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

Константные выражения, используемые в директивах препроцессора, имеют дополнительные ограничения, поэтому они называются ограниченными константными выражениями. Ограниченные константные выражения не могут содержать операцию sizeof (в СП ТС — могут), констант перечисления и выражений приведения типа и плавающих констант. Однако ограниченные константные выражения, используемые в директивах препроцессора, могут содержать специальные константные выражения defined (<идентификатор>), описанные в разделе 7.2.1 "Директива #define". . Только выражения инициализации допускают применение плавающих констант, выражений приведения типа к неарифметическим типам и операции адресации. Операция адресации может быть применена к переменной внешнего уровня базового или структурного типа, к объединению, а также к элементу массива. В этих выражениях допускается сложение или вычитание адресного выражения с константным выражением, не содержащим операции адресации.

Константы

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

Операнду-константе соответствует значение и тип представляющей его константы. Типы констант подробно описаны в разделе 1.2. Символьная константа имеет тип int. Целая константа имеет один из следующих типов: int, long, unsigned int или unsigned long, в зависимости от размера целого на данном компьютере и от того, как специфицировано ее значение. Константы с плавающей точкой имеют тип double (в версии 2.0 СП ТС допустимы также константы типа float). Символьные строки имеют тип массив символов; они обсуждаются в разделе 4.2.3.

Константы с плавающей точкой

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

[<цифры>][.<цифры>][<э>[-]<цифры>]

<цифры> —одна или более десятичных цифр (от 0 до 9); <э>—признак экспоненты, задаваемый символом Е или е. Либо целая, либо дробная часть константы может быть опущена, но не обе сразу. Либо десятичная точка с дробной частью, либо экспонента может быть опущена, но не обе сразу.

Экспонента состоит из символа экспоненты, за которым следует целочисленное значение экспоненты, возможно со знаком

плюс или минус.

Между цифрами или символами константы пробельные символы недопустимы.

Примеры констант с плавающей точкой:

15.75

1.575Е1

1575е-2

25.

Примеры констант с плавающей точкой с опущенной целой частью:

.75

.0075е2

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

Примеры:

-0.0025

-2.5е-3

-.125

-.175Е-2

Все константы с плавающей точкой имеют тип double. В СП ТС можно явно присвоить константе тип float, добавив к ней суффикс f или F.

Логические операции

Логические операции выполняют над своими операндами логические функции И (&&) и ИЛИ (||). Операнды логических операций могут иметь целый, плавающий тип, либо быть указателями. Типы первого и второго операндов могут различаться. Сначала всегда вычисляется первый операнд; если его значения достаточно для определения результата операции, то второй операнд не вычисляется.

Логические операции не выполняют преобразования по умолчанию. Вместо этого они вычисляют операнды и сравнивают их с нулем. Результатом логической операции является либо 0 (ЛОЖЬ), либо 1 (ИСТИНА). Тип результата — int.

Логическое И (&&)

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

Логическое ИЛИ (||)

Логическая операция ИЛИ выполняет над своими операндами операцию включающее ИЛИ. Она вырабатывает значение 0, если оба операнда имеют значение 0; если какой-либо из операндов имеет ненулевое значение, то результат операции равен 1. Если первый операнд не равен нулю, то значение второго операнда не вычисляется.

Примеры:

int х, у;

if(х<у && у<z) printf("x меньше z\n");           /* пример 1 */

if(х==у !!

х==z) printf("x равен у или z\n");    /* пример 2 */

В первом примере функция printf вызывается для печати сообщения в том случае, если х меньше у и у меньше 2. Если х больше у, то второй операнд (у<z) не вычисляется и печати не происходит.

Во втором примере сообщение печатается в том случае, если х равен у или z. Если х равен у, то значение второго операнда (х==z) не вычисляется.

МОДЕЛИ ПАМЯТИ

Реализация моделей памяти в СП MSC и в СП ТС имеет ряд отличий. В разделах 8.1 и 8.2 описаны модели

памяти СП MSC, а в разделе 8.3 приведены отличия моделей памяти СП ТС.

Модели памяти СП ТС

Организация работы с моделями памяти в СП ТС имеет ряд отличий от СП MSC.

В дополнение к описанным выше моделям СП ТС имеет еще одну — tiny (минимальную). В этой модели вся программа — код, данные, стек, динамическая память — размещается в одном сегменте. Таким образом, размер программы ограничен 64 Кбайтами. Все указатели в этой модели имеют тип near. Программы модели памяти tiny могут быть преобразованы в формат выполняемых файлов СОМ операционной системы MSDOS.

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

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

Указатели типа huge в СП ТС всегда хранятся в нормализованном виде, так что значение смещения никогда не превышает 15. Нормализация требует дополнительных временных затрат при работе с указателями тип huge, но зато позволяет применять к ним операции отношения (с ненормализованными 32-битовыми указателями операции отношения работают

некорректно).

Допустимо применение модификатора huge к функциям и указателям на функции.

Имеется также четыре специальных указателя типа near с именами _cs, _ds, _ss, _es. Это 16-битовые указатели, ассоциированные с сегментными регистрами микропроцессора, содержащими адреса сегментов кода, данных, стека и динамической памяти, соответственно. Например, указатель р,

объявленный следующим образом

char _ss *р;

будет содержать 16-битовое значение, хранящееся в сегменте стека.

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

int * far р;

допустимое в СП MSC, считается ошибкой в СП ТС.

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

Работая в некоторой стандартной модели памяти, программист может в той или иной мере модифицировать ее, применяя в объявлениях модификаторы near, far и huge. Правила интерпретации объявлений с модификаторами рассмотрены в разделе 3.3.3.4 "Модификаторы near, far, huge".

Модификатор 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.

Модификаторы 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.

Модификаторы 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 = maxini--; /* Уменьшение константы */

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, поскольку в теле цикла их значения не изменяются. Это привело бы к зацикливанию программы.

Модификаторы 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 fаг *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

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

указателем на far

указатель на значение типа char. Это объявление можно для ясности записать и так:

char *(far *х);

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

В примере 4 также представлены два объявления. Первое объявляет массив типа char

с именем initiist и модификаторами far

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

указывает на то, что имя данного массива используется не только в программе на языке Си, но и в программе на языке Паскаль (или другом языке программирования с подобными правилами написания имен внешних переменных). Модификатор far

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

Второе объявление объявляет три указателя на far значения типа char

с именами nextchar, prevchar и currentchar.

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

Модификаторы типа функции

Компилятор языка Си поддерживает ряд модификаторов типа функций: pascal, cdecl, interrupt, near, far и huge (модификатор interrupt

не реализован в версии 4 СП MSC). Модификаторы рассмотрены в разделе 3.3.3 "Описатели с модификаторами".

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

К мультипликативным операциям относятся операции умножения *, деления / и получения остатка от деления %. Операндами операции % должны быть целые значения. Операции умножения * и деления / выполняются над целыми и плавающими операндами. Типы первого и второго операндов могут отличаться, при этом выполняются преобразования операндов по умолчанию. Типом результата является тип операндов после преобразования.

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

Умножение (*)

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

Деление (/)

Операция деления выполняет деление первого своего операнда на второй. Если оба операнда являются целыми значениями

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

Остаток от деления (%)

Результатом операции является остаток от деления первого операнда на второй. Знак результата совпадает со знаком делимого.

Примеры:

int i =

10, j = 3, n;

double x =

2.0, у,

у = х*i;     /* пример 1 */

n = i/j;     /*

пример 2 */

n = i%j;     /* пример 3 */

В первом примере х умножается на i. Результат равен 20.0 и имеет тип double.

Во втором примере 10 делится на 3. Результат округляется до 3 и имеет тип int.

В третьем примере п

присваивается остаток от деления 10 на 3, т.е. 1.

Объявление данных

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

Например, объявление

char far х;

сообщает, что адрес объекта х имеет тип far.

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

char far *р;

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

char * far р;

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

char far * far р;

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

Примеры:

char а[3000];         /* пример 1: малая модель */

char far b[30000];    /* пример 2: малая модель */

char a[3000];         /*

пример 3: большая модель */

char near b[3000];    /*

пример 4: большая модель */

char huge a[70000];   /*

пример 5: малая модель */

char huge *pa;        /* пример 6: малая модель */

char *pa;             /*

пример 7: малая модель */

char far *pb;         /*

пример 8: малая модель */

char far **pa;        /* пример 9: малая модель */

char far **pa;        /*

пример 10: большая модель */

char far *near *pb;   /*

пример 11: любая модель */

char far *far *pb;    /* пример 12: любая модель */

В примере 1 массиву а выделяется память в стандартном сегменте данных; массиву b во втором примере память может быть выделена в любом из сегментов данных программы. Поскольку оба объявления сделаны в малой модели, то, вероятно, массив а содержит часто используемые данные, которые для ускорения доступа должны располагаться в стандартном сегменте, а массив b содержит редко используемые данные, которые могут выйти за пределы 64-Кбайтного

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

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

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

не является критичной; независимо от того, попадет он в стандартный сегмент или не попадет, обращение к нему всегда будет осуществляться по 32-битовому адресу. В примере 4 массиву b с помощью модификатора near явно назначен стандартный сегмент, с целью ускорения доступа к нему в большой модели.

В примере 5 массив а должен быть явно объявлен как huge, поскольку его размер превышает 64 Кбайта. Использование модификатора huge вместо выбора максимальной модели памяти в качестве стандартной позволяет сэкономить время доступа: только к массиву а обращение будет осуществляться по адресу типа huge, а все остальные данные будут размещаться в стандартном сегменте. Для обращения к массиву а может быть использован указатель ра

из примера 6. Все арифметические операции над указателем ра

(например, ра++) будут выполняться над всеми 32 его битами.

В примере 7 ра объявляется как указатель на near char. Указатель получает тип near по умолчанию, поскольку речь идет о малой модели. В примере 8 pb явно объявляется как указатель на far char. Он может быть использован, в частности, для доступа к символьному массиву, расположенному не в стандартном сегменте памяти. Например, ра

может указывать на массив а из примера 1, а pb — на массив b из примера 2.

Хотя объявления ра в примерах 9 и 10 идентичны, в примере 9 ра объявляется как указатель на near

массив указателей на тип far char, а в примере 10 ра объявляется как указатель на far массив указателей на тип far

char.

В примере 11 pb объявляется как указатель на near массив указателей на тип far

char. В примере 12 pb

объявляется как указатель на far массив указателей на тип far char. В этих примерах употребление слов far и near изменяет действующие по умолчанию соглашения, связанные с моделями памяти; в отличие от примеров 9 и 10, объявления pb не зависят от выбранной модели памяти и в любой модели имеют одинаковый смысл.

Объявление функции

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

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

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

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

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

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

Пример:

main(void)

{

int а = 0, b = 1;

float х = 2.0, у = 3.0;

double realadd

(double, double);

a = intadd(a, b);

x = realadd(x, y);

}

intadd(int a, int b)

{

return (a + b);

}

double realadd(double x, double y)

{

return (x + y);

}

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

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

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

Метод объявления функции, описанный в данном разделе, используется только в версии 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;                           /* пример 7 */

short *q;

int prt(void *);

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

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

Во втором примере объявляется функция с именем calc,

которая возвращает значение типа double. Список типов аргументов пуст.

В третьем примере

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

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

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

означающее отсутствие аргументов функции.

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

В шестом примере функция с именем select

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

В седьмом примере объявлена функция prt,

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

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



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

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

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

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

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

Объявление функций

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

char far fun();

определяет fun как функцию, вызываемую по 32-битовому адресу и возвращающую тип char.

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

char (far *pfun)();

определяет pfun как указатель (32-битовый) на far

функцию, возвращающую char.

Модификатор huge к функциям и указателям на функции неприменим.

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

Примеры:

char far fun();            /*

пример 1: малая модель */

static char far *near fun(); /* пример 2: большая модель */

void far fun();            /*

пример 3: малая модель */

void (far *pfun)() = fun;

double far * far fun();    /*

пример 4: компактная модель */

double far* (far *pfun)() = fun;

В первом примере fun объявляется как функция, возвращающая char. Ключевое слово far

в объявлении означает, что fun вызывается по 32-битовому адресу типа far.

Во втором примере fun объявляется как near

функция класса памяти static, возвращающая указатель на far char. Такая функция в большой модели памяти может быть использована, например, как вспомогательная подпрограмма, которая вызывается часто, но только функциями из своего исходного файла. Поскольку все функции из одного исходного файла помещаются в один и тот же сегмент, они могут обращаться друг к другу по адресам типа near. Будет ошибкой, однако, передать адрес функции fun

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

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

В примере 4 pfun объявляется как указатель на far

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

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

Синтаксис:

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

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

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

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

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

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

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

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

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

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

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

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

char а[2][3]

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

Примеры.

/* пример 1 */

int scores[10], game:

/* пример 2 */

float matrix[10][15];

/* пример 3 */

struct {

float х, у;

} complex[100];

/* пример 4 */

char *name[20];

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

объявлена как простая переменная целого типа.

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

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

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

является указателем на значение типа char.

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

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

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 и массива ж из 20 элементов типа float. Тип объединения не поименован тегом. Память, выделяемая переменной jack, равна памяти, необходимой для хранения массива f, поскольку это самый длинный элемент объединения.

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

Объявления переменной на внешнем уровне используют спецификации класса памяти 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	Класс 2	СП TC	СП MSC
extern	static	static	static
static	пусто	static	ошибка
static	extern	static	static
пусто	static	static	ошибка

Пример: /*

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

/* объявление i,

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

extern int i;

main()

{

i = i + 1;

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

next();

}

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

next()

{

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.

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

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

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

auto считается неопределенным. Память под переменные класса памяти auto отводится в стеке.

Спецификация класса памяти register

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

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

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

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

Для каждого рекурсивного входа в блок порождается новый набор переменных класса памяти auto

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

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

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

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

не влияет на область действия объявляемой глобальной переменной в любой другой части программы.

Пример:

inl 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, c);

}

other()

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

int i = 16;



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

static int a =

2;

a += 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 при этом не изменилось бы.

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

Синтаксис:

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. В данном разделе для простоты изложения объявления описываются без спецификаций класса памяти и инициализаторов. Спецификации класса памяти описаны в разделе 3.6, инициализаторы — в разделе 3.7.

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

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

Синтаксис:

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

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

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

Примеры.

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

unsigned long

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

double order; /*

пример 3 */

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

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

long.

В третьем примере

объявлена переменная order, которая имеет тип double.

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

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

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

Синтаксис:

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, имеющая тип структура. Эта структура состоит из двух элементов х и у типа float. Тип структуры не поименован, поскольку тег в объявлении отсутствует.

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

соответственно. Структурный тип поименован тегом employee.

В третьем примере объявлены три переменные типа структура с именами student, faculty и staff.

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

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

на значения типа float. Третий элемент с именем next объявлен как указатель на структуру того же самого типа sample.

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

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

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

Примеры.

/* пример 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.

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

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

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

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

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

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

Объявление 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 *pfr.

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

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

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

Синтаксис:

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

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

пустой, структурный тип или тип объединение. Если спецификация типа опущена, предполагается тип int.

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

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

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

либо над указуемым

объектом, необходимо явно привести тип указателя к типу, отличному от void. Например, если объявлена переменная i

типа int и указатель р на тип void

int i;

void *p;

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

p = &i;

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

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

(int *)р++;

/* допустимо */

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

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

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

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

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

В стандартном включаемом файле stdio.h

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

Примеры.

char *message;/*

пример 1 */

im *аrrау1 [10]; /*

пример 2 */

int (*pointer1)[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 в выражении).

ОБЪЯВЛЕНИЯ

В этом разделе описываются формат и составные части объявлений переменных, функций и типов. В разделе 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.

---

---