---

Разделы На главную История денег и экономики История экономических знаний Формы безналичных денег Международные финансы Экономические концепции Экономические теории Экономика в реальной жизни Экономический анализ и интеграция Макроэкономика Экономика и социальное общество Социальная экономика Социология Кризисная экономика Инфляция в экономике Экономика зарубежных стран Иностранные деньги Государственное регулирование Бюджетная система Политическая экономия Политология Законы денег Налогообложение Аудит Банкротство Теория рынка Конкуренция Международная торговля Товарная биржа Нефть и газ на бирже Логистика Банки - услуги и операции Банки в России Банковский кредит Недвижимость Ипотека в банке Инвестирование Стратегии инвестирования Инвестиционные фонды Ценные бумаги Акции Вексель Облигации Опционы Фьючерсы Биржевая торговля Биржа Forex Фондовый рынок Фондовый рынок России Волны Эллиотта Теория фракталов Торговая теория Ганна Фибоначчи на бирже Графический анализ на бирже Паттерны Биржевой анализ "Крестики-нолики" Японские свечи Технический анализ Математика на бирже Фундаментальный анализ Биржевая торговля Стратегии торговли Механические торговые системы Программирование МТС Управление торговым капиталом Управление портфелем Управление риском Страхование Профессия трейдер Практический трейдинг Технологии инфосистем Информационный рынок Безопасность информации Криптология и криптография Реклама PR - Public Relations Маркетинг Финансовая система Начало бизнеса Предпринимательство Малый бизнес Микроэкономика Торговля Ценообразование Работа в Интернете Сайты, софт, дизайн Управление качеством Управление предприятием Производство продукции Стратегический менеджмент Учебники по менеджменту Системы и организации Теория систем Планирование Статистика финансов Управление персоналом Трудовые отношения Бухгалтерия «1С:Бухгалтерия» Управленческий учет Делопроизводство и офис Автоматизация делопроизводства Рынок труда Карьера Менеджер Лидерство и бизнес карьера Лидерство и карьера Общение и переговоры Общение в бизнесе Бизнес переговоры Инновации в моделировании Экономическое моделирование Нейронные сети Нейролингвистика Логика нейросетей Программирование Пакет Excel Технологии программирования Языки программирования Практическая психология Психологические тренинги Психология в медицине Возрастная психология Ваши скрытые резервы Здоровье и долголетие Работа с эмоциями Пикап Управление временем Гипнотерапия Подсознание Трансовые техники Магия Здоровье советы Спорт для здоровья Йога Религии Эзотерика Мистицизм

---

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

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

Таблица 3.3.

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

Тип		Представление в памяти		Область значений
char		1 байт		от -128 до 127
int		зависит от реализации
short		2 байта		от -32768 до 32767
long		4 байта		от -2.147.483.648 до 2.147.483.647
unsigned char		1 байт		от 0 до 255
unsigned		зависит от реализации
unsigned short		2 байта		от 0 до 65535
unsigned long		4 байта		от 0 до 4.294.967.295
float		4 байта		стандартный формат IEEE
double		8 байтов		стандартный формат IEEE
long double		10 байтов		стандартный формат IEEE

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

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

char.

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

(короткое целое), либо типу long int

(длинное целое), в зависимости от компьютера. Аналогично, тип unsigned

int эквивалентен либо типу unsigned

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

и unsigned int только 16 разрядов.

Спецификации типов int и unsigned

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

и unsigned int

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

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

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

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

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

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

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

Допустим, требуется использовать в выражении значение -32768 типа short. Константное выражение -32768 состоит из арифметической операции отрицания (-),



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

Восьмеричные и шестнадцатеричные

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

СП ТС

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

Для представления значений с плавающей точкой используется стандартный формат IEEE (Institute of Electrical and Electronics Engineers, Inc.). Значения типа float

занимают 4 байта, состоящих из бита знака, 7-битовой двоичной экспоненты и 24-битовой мантиссы. Мантисса представляет число в интервале от 1.0 до 2.0. Поскольку старший бит мантиссы всегда равен единице, он не хранится в памяти. Это представление дает область значений приблизительно от 3.4Е-38 до 3.4Е+38.

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

Значения типа long double

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

Операции

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

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

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

Таблица 1.3.

Операция		Наименование		Операция		Наименование
!		Логическое НЕ		^		Поразрядное исключающее ИЛИ
~		Обратный код		&&		Логическое И
+		Сложение; унарный плюс		||		Логическое ИЛИ
-		Вычитание; унарный минус		?:		Условная операция
*		Умножение; косвенная адресация		++		Инкремент
/		Деление		--		Декремент
%		Остаток от деления		=		Простое присваивание
<<		Сдвиг влево		+=		Присваивание со сложением
>>		Сдвиг вправо		-=		Присваивание с вычитанием
<		Меньше		*=		Присваивание с умножением
<=		Меньше или равно		/=		Присваивание с делением
>		Больше		%=		Присваивание с остатком от деления
>=		Больше или равно		>>=		Присваивание со сдвигом вправо
==		Равно		<<=		Присваивание со сдвигом влево
!=		Не равно		&=		Присваивание с поразрядным И
&		Поразрядное И; адресация		|=		Присваивание с поразрядным включающим ИЛИ
|		Поразрядное включающее ИЛИ		^=		Присваивание с поразрядным исключающим ИЛИ
,		Последовательное выполнение (запятая)

Примечание. Условная операция ?: является не двухсимвольной, а тернарной (трехоперандной) операцией. Она имеет следующий формат: <операнд1> ? <операнд2> : <операнд3>

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

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

b << 2 << 2

выполняется как (b << 2) << 2, а не как b << (2 << 2). Ассоциативность "справа налево" означает, что первой будет выполняться операция, знак которой записан правее остальных.

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

Знак операции		Наименование
-		унарный минус
+		унарный плюс
~		обратный код
!		логическое отрицание
&		адресация
*		косвенная адресация
sizeof		определение размера

Примечание. Операция унарного плюса реализована полностью только в СП ТС.

В СП MSC версии 4 она отсутствует, а в версии 5 реализована только синтаксически.

Унарные операции предшествуют своему операнду и ассоциируются справа налево.

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

Знак		Наименование
* / %		мультипликативные операции
+ -		аддитивные операции
<< >>		операции сдвига
< > <= >= == !=		операции отношения
& | ^		поразрядные операции
&& ||		логические операции
,		операция последовательного вычисления

Бинарные операции ассоциируются слева направо. В языке Си имеется одна тернарная операция — условная, обозначаемая ?:. Она ассоциируется справа налево.

Операции и L-выражения

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

Первичные выражения рассмотрены в разделах 4.2.4, 4.2.5, 4.2.6.

Унарное выражение состоит из операнда с предшествующей ему унарной операцией.

Синтаксис:

<унарная-операция> <операнд>

Унарные операции рассмотрены в разделе 4.3.2.

Бинарное выражение состоит из двух операндов, разделенных бинарной операцией.

Синтаксис:

<операнд1> <бинарная-операция> <операнд2>

Бинарные операции рассмотрены в разделах 4.3.3 — 4.3.9.

Тернарное выражение состоит из трех операндов, разделенных знаками условной операции "?:".

Синтаксис:

<операнд1> ? <операнд2> : <операнд3>

Условная операция рассмотрена в разделе 4.3.10.

Выражения присваивания используют унарные или бинарные операции присваивания. Унарными операциями присваивания являются инкремент "++" и декремент "--". Бинарные операции присваивания — это простое присваивание "=" и составные операции присваивания. Каждая составная операция присваивания представляет собой комбинацию какой-либо бинарной операции с простой операцией присваивания.

Синтаксис выражений присваивания:

Унарные операции присваивания:

<операнд> ++

<операнд> --

++ <операнд>

--<операнд>

Бинарные операции присваивания:

<операнд1> = <операнд2>

<операнд1> <составное-присваивание> <операнд2>

Операция присваивания рассмотрена в разделе 4.4.

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

Синтаксис:

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

Операция приведения типа подробно рассматривается в разделе 4.7.2. Абстрактные имена типов описаны в разделе 3.8.3.

Операнды некоторых операций в языке Си должны представлять собой так называемые L-выражения

(Lvalue expressions). L-выражением

является выражение, которое ссылается на ячейку памяти и потому имеет смысл в левой части бинарной операции присваивания. Простейшим примером L-выражения является идентификатор переменной: он ссылается на ячейку памяти, которая хранит значение этой переменной.

Поскольку L-выражение

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

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

К L-выражениям

относятся:

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

— индексные выражения, исключая те из них, значение которых имеет тип массив;

— выражение выбора элемента, если выбранный элемент сам является одним из допустимых L-выражений;

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

— L-выражение в скобках;

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

char *р;

int i;

long n;

(long *)p = &n; /* допустимое приведение типа */

(long)i = n; /* недопустимое приведение типа */

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

Операции инкремента и декремента

Операции ++ и -- инкрементируют

(увеличивают на единицу) и декрементируют

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

Операнды целого или плавающего типа увеличиваются или уменьшаются на целую единицу. Над операндом не производятся преобразования по умолчанию. Тип результата соответствует типу операнда. Операнд типа указатель инкрементируется или декрементируется на размер объекта, который он адресует, по правилам, описанным в разделе 4.3.4. Инкрементированный указатель адресует следующий элемент данного типа, а декрементированный указатель—предыдущий.

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

Примеры:

/* пример 1 */

if(pos++ > 0) *p++ = *q++;

/* пример 2 */

if(line[--i] != '\n') return;

В первом примере переменная pos

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

инкрементируются.

Во втором примере переменная i декрементируется перед ее использованием в качестве индекса массива line.

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

Операции отношения сравнивают первый операнд со вторым и вырабатывают значение 1 (ИСТИНА) или 0 (ЛОЖЬ). Результат имеет тип int. Имеются следующие операции отношения:

Операция		Проверяемое отношение
<  >  <= >= == !=		Первый операнд меньше, чем второй операнд Первый операнд больше, чем второй операнд Первый операнд меньше или равен второму операнду Первый операнд больше или равен второму операнду Первый операнд равен второму операнду Первый операнд не равен второму операнду

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

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

>=) отражает относительное положение двух адресов памяти.

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

Сравнение между собой указателей типа far

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

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

Из-за специфики машинной арифметики не рекомендуется проверять плавающие значения на равенство, поскольку 1.0/3.0*3.0 не будет равно 1.0.

Примеры:

int х, у;

х < у        /* выражение 1 */

у > х        /* выражение 2 */

x <= У       /* выражение 3 */

x >= У       /* выражение 4 */

x == У       /* выражение 5 */

x != у       /* выражение 6 */

Если х и у равны, то выражения 3, 4, 5 имеют значение 1, а выражения 1, 2, 6 имеют значение 0.

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

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

Операция		Действие
++ -- = *= /= %= += -= <<= >>= &= |= ^=		Унарный инкремент Унарный декремент Простое присваивание Умножение с присваиванием Деление с присваиванием Остаток от деления с присваиванием Сложение с присваиванием Вычитание с присваиванием Сдвиг влево с присваиванием Сдвиг вправо с присваиванием Поразрядное И с присваиванием Поразрядное включающее ИЛИ с присваиванием Поразрядное исключающее ИЛИ с присваиванием

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

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

Операции сдвига

Операции сдвига сдвигают свой первый операнд влево (<<)

или вправо (>>)

на число разрядов машинного слова, специфицированное вторым операндом. Оба операнда должны быть целыми значениями. Выполняются преобразования по умолчанию, причем в СП MSC над обоими операндами совместно, а в СП ТС независимо над каждым операндом. Например, если переменная b имеет тип int,

а переменная и тип unsigned long, то перед выполнением операции b<<u в СП MSC переменная b будет преобразована к типу unsigned

long.

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

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

Если второй операнд отрицателен, то результат операции сдвига не определен.

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

Пример:

unsigned int х, у, z;

х =

0х00АА;

у = 0х5500;

z= (х<<8) + (у>>8);

В примере х сдвигается влево на 8 позиций, а у

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

Операция последовательного вычисления

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

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

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

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

Примеры:

/* пример 1 */

for(i=j=1; i+j<20; i+=i, j--)…

/* пример 2 */

func_one( x, у + 2, z);

func_two((x--, y + 2), z);

В первом примере каждый операнд третьего выражения оператора цикла for

вычисляется независимо. Сначала вычисляется i+=i, затем j--.

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

у+2,

2. Здесь символ "запятая" используется просто как разделитель

В вызове функции func_two внутренние скобки вынуждают компилятор интерпретировать первую запятую как операцию последовательного вычисления. Этот вызов передает функции func_two два аргумента. Первый аргумент — это результат последовательного вычисления (х--,у+2), имеющий значение и тип выражения у+2. Вторым аргументом является z.

Операнды

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

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

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

Оператор цикла с постусловием do

Синтаксис:

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

Действие:

Тело оператора цикла do выполняется один или несколько раз до тех пор, пока значение <выражения> не станет ложным (равным нулю). Вначале выполняется тело цикла — <оператор>, затем вычисляется условие — <выражение>. Если выражение ложно, то оператор цикла do завершается и управление передается следующему за оператором while

оператору программы. Если значение выражения истинно (не равно нулю), то тело цикла выполняется снова, и снова вычисляется выражение. Выполнение тела оператора цикла do повторяется до тех пор, пока выражение не станет ложным. Оператор do может также завершиться при выполнении в своем теле операторов break, goto, return.

Пример:

do {

у = f(x);

х--;

} while(x > 0);

Вначале выполняется составной оператор. Затем вычисляется выражение х>0. Если оно истинно, то составной оператор выполняется снова, и снопа вычисляется выражение х>0. Тело оператора цикла do выполняется до тех пор, пока значение х

не станет меньше или равно нулю.

Оператор цикла с предусловием while

Синтаксис:

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

Действие:

Тело оператора цикла while выполняется до тех пор, пока значение <выражения> не станет ложным (т.е. равным нулю). Вначале вычисляется <выражение>. Если <выражение> изначально ложно, то тело оператора while вообще не выполняется и управление сразу передается на следующий за телом цикла оператор программы. Если <выражение> истинно, то выполняется тело цикла. Перед каждым следующим выполнением тела цикла <выражение> вычисляется заново. Этот процесс повторяется до тех пор, пока <выражение> не станет ложкам. Оператор цикла while может также завершиться при выполнении операторов break, goto, return внутри своего тела.

Пример:

while (i >= 0) {

slring1[i] = string2[i];

i--;

}

В вышеприведенном примере элементы массива string2

копируются в массив string1. Если i больше или равно нулю, то производится копирование (путем присваивания) очередного элемента, после чего i декрементируется. Когда i становится меньше нуля, выполнение оператора while завершается.

Оператор перехода goto

Синтаксис:

goto <метка>;

.

.

.

<метка>: <оператор>

Действие:

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

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

Можно войти в блок, тело цикла, условный оператор, оператор-переключатель по метке.

Нельзя с помощью оператора goto передать управление на конструкции case и default

в теле переключателя.

Пример:

if(errorcode > 0) goto exit;

…

exit: return (errorcode);

В примере оператор перехода goto передает управление на оператор, помеченный меткой exit, если errorcode больше нуля.

Оператор-переключатель switch

Синтаксис:

switch(<выражение>)

{

[<объявление>]

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

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

[default:] [<оператор>]

}

Действие:

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

в круглых скобках). После этого управление передается одному из <операторов> тела переключателя. В теле переключателя содержатся конструкции case <константное-выражение>:, которые синтаксически представляют собой метки операторов. Константные выражения в данном контексте называются константами варианта. Оператор, получающий управление, — это тот оператор, значение константы варианта которого совпадает со значением выражения переключения. Значение каждой константы варианта должно быть уникальным внутри тела оператора-переключателя.

Выполнение тела оператора-переключателя switch

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

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

Выражение переключения должно иметь целочисленный тип. В версии 4 СП MSC этот тип не должен превышать по размеру int; в версии 5 СП MSC и в СП ТС это может быть любой целочисленный тип (в том числе enum). Однако в версии 5 СП MSC выражение переключения всегда преобразуется к типу int. Если при этом преобразовании возможна потеря значащих битов, то компилятор выдаст предупреждающее сообщение. Тип каждой константы варианта также приводится к типу выражения переключения.

Синтаксически конструкции case и default являются метками (однако, на них нельзя передать управление по оператору goto). Метки case и default существенны только при начальной проверке, когда выбирается оператор для выполнения в теле переключателя. Все операторы тела, следующие за выбранным, выполняются последовательно, как бы "не замечая" меток case

и default, если только какой-либо из операторов не передаст управление за пределы тела оператора switch. Для выхода из тела переключателя обычно используется оператор разрыва break. Одна из распространенных ошибок состоит в том, что программисты забывают разделять альтернативные операторы в теле переключателя операторами break.

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

Примеры:

/* пример 1 */

switch (с) {

case 'А': capa++;

case 'a': lettera++;

default: total++;

}

/* пример 2 */

switch (i) {

case -1: n++;

break;

case 0: z++;

break;

case 1: p++;

break;

}

/* пример 3 */

switch (i) {

case 1:    if(a > 0) {

case 2: b = 3;

} else

case 3: k = 0;

}

В первом примере все три оператора в теле оператора switch

выполняются, если значение с равно 'А'. Передача управления осуществляется на первый оператор (capa++;), далее операторы выполняются в порядке их следования в теле.

Если с равно 'а', те инкрементируются переменные lettera и total. Наконец, если с не равно 'А' или 'а', то инкрементируется только переменная total.

Во втором примере в теле оператора switch после каждого оператора следует оператор разрыва break, который осуществляет принудительный выход из тела оператора-переключателя switch. Если i равно -1, переменная n

инкрементируется. Оператор break, следующий за оператором n++, вызывает передачу управления за пределы тела переключателя, минуя остающиеся операторы. Аналогично, если i равно нулю, инкрементируется только переменная z; если i равно 1, инкрементируется только переменная р. Передний оператор break не является обязательным, поскольку без него управление все равно перешло бы на конец составного оператора, но он включен для единообразия.

В третьем примере при i, равном 1, будет выполнена следующая последовательность действий:

if(а > 0)

b = 3;

else

k = 0;

При i, равном 2, переменной b будет присвоено значение 3. При i, равном 3, переменная k будет обнулена.

Оператор в теле переключателя может быть помечен множественными метками case, как показано в следующем примере:

switch (с) {

case 'а':

case 'b':

case 'с':

case 'd':

case 'e':

case 'i': hexcvt(c);

}

В этом примере, если выражение переключения примет любое из значений 'а', 'b', 'с', 'd', 'e', 'i', будет вызвана функция hexcvt.

Оператор пошагового цикла for

Синтаксис:

for([<начальное-выражение>]; [<условное-выражение>]; [<выражение-приращения>])

<оператор>

Действие:

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

Первым шагом при выполнении оператора цикла for

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

1) Если условное выражение истинно (не равно нулю), то выполняется тело оператора. Затем вычисляется выражение приращения (если оно есть), и процесс повторяется.

2) Если условное выражение опущено, то его значение принимается за истину и процесс выполнения продолжается, как описано выше. В этом случае оператор цикла for представляет бесконечный цикл, который может завершиться только при выполнении в его теле операторов break, goto, return.

3) Если условное выражение ложно, то выполнение оператора for заканчивается и управление передается следующему за ним оператору в программе. Оператор for может завершиться и при

выполнении операторов break, goto, return в теле оператора.

Пример:

for(i = space = tab = 0; i < MAX; i++) {

if(line[i] == '\x20')

space++;

if(line[i] =='\1'){

lab++;

line[i] = '\x20';

}

}

В приведенном примере подсчитываются символы пробела ('\x20') и горизонтальной табуляции ('\1') в массиве символов с именем line и производится замена каждого символа горизонтальной табуляции на пробел.

Сначала i, space и tab инициализируются нулевыми значениями. Затем i сравнивается с константой МАХ. Если i

меньше МАХ, то выполняется тело оператора. В зависимости от значения line[i]

выполняется тело одного из операторов if (или ни одного из них). Затем переменная i инкрементируется и снова сравнивается с именованной константой МАХ. Тело оператора выполняется до тех пор, пока значение i не станет больше или равно МАХ.

Оператор продолжения continue

Синтаксис:

continue;

Действие:

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

Пример:

while(i-- > 0) {

х

= f(i);

if(х == 1)

continue;

else

y = x * x;

}

Тело оператора цикла while выполняется, если i больше нуля. Сначала значение f(i)

присваивается х; затем, если х

не равен 1, то у присваивается значение квадрата х, и управление передается в заголовок цикла, т. е. на вычисление выражения i-->0. Если же х равен 1, выполняется оператор продолжения continue, и выполнение возобновляется с заголовка оператора цикла while, без вычисления квадрата х.

Оператор разрыва break

Синтаксис:

break;

Действие:

Оператор разрыва break прерывает выполнение операторов do, for, while или switch. Он может содержаться только в теле этих операторов. Управление передается оператору программы, следующему за прерванным. Появление оператора break вне операторов do, for, while, switch

компилятор рассматривает как ошибку.

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

и перехода goto.

Пример:

for(i =

0; i < LENGTH; i++) {

for(j = 0; j < WIDTH; j++)

if(lines[i][j] == '\0') break;

lengths[i] =

j;

}

В вышеприведенном примере построчно обрабатывается массив строк переменной длины lines. Именованная константа LENGTH задает количество строк в массиве LINES. Именованная константа WIDTH задает максимально допустимую длину строки. Задача состоит в заполнении массива lengths

длинами всех строк массива lines. Оператор разрыва break прерывает выполнение внутреннего цикла for при обнаружении признака конца символьной строки ( \0'). После этого i-му элементу одномерного массива length

[i] присваивается длина i-й строки в байтах. Управление передается внешнему оператору цикла for. Переменная i инкрементируется

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

не станет больше или равно значению константы LENGTH.

Оператор возврата return

Синтаксис:

return [<выражение>];

Действие:

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

Пример:

main()

{

void draw(int, int);

long sq(int);

у = sq(x);

draw(x, y);

}

long sq(int x)

{

return (x*x);

}

void draw(int x, int y)

{

return,

}

Функция main вызывает две функции, sq и draw. Функция sq возвращает значение квадрата x. Это значение присваивается переменной у. Функция draw объявлена с типом void, как не возвращающая значения. Попытка присвоить значение. возвращаемое функцией draw, привело бы к сообщению компилятора об ошибке.

<Выражение> в операторе возврата return принято заключать в скобки, как показано в примере. Это, однако, не является требованием языка.

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

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

Оператор-выражение

Синтаксис:

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

Действие:

<Выражение> вычисляется в соответствии с правилами, изложенными в разделе 4 "Выражения". Отличие оператора-выражения состоит в том, что значение содержащегося в нем выражения никак не используется. Кроме того, он может быть записан лишь там, где по синтаксису допустим оператор.

Примеры:

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

х++;           /*пример 2*/

f(x);          /*пример 3*/

В первом примере х

присваивается значение у+3. Во втором примере х

инкрементируется.

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

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

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

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

pascal, near, far, huge, interrupt.

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

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

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

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

<тело функции>

Спецификация класса памяти <спецификация КП> задает класс памяти функции. <Спецификация типа> в совокупности с описателем определяет тип возвращаемого значения и имя функции. <Список объявлений параметров> аналогичен списку типов аргументов в прототипе функции (см. раздел 3.5 "Объявление функции").

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

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

Побочные эффекты

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

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

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

—конец инициализирующего выражения для переменной класса памяти auto;

—конец выражений, управляющих выполнением операторов if, switch, for, do, while и выражения в операторе return. Приведем примеры побочных эффектов:

add(i + 1, i = j

+ 2);

Аргументы вызова функции add могут быть вычислены в любом порядке. Выражение i+1 может быть вычислено перед выражением i=j+2, или после него, с различным результатом в каждом случае.

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

int i, а [10];

i = 0;

a[i++] = i;

Неизвестно, какое значение будет присвоено элементу а[0] — нуль или единица, поскольку для операции присваивания порядок вычисления аргументов не оговаривается.

Поразрядные операции

Поразрядные операции выполняют над разрядами своих операндов логические функции И (&),

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

Таблица значений для поразрядных операций:

х		0		0		1		1
у		0		1		0		1
х|у		0		1		1		1
х&у		0		0		0		1
x^y		0		1		1		0

Примеры:

short i = 0хAВ00;

short j = 0xABCD;

short n;

n =

i & j;      /*

пример 1 */

n =

i | j;      /* пример 2 */

n =

i ^ j;      /* пример 3 */

В первом примере n присваивается шестнадцатеричное

значение АВ00.

Во втором примере результатом операции включающего ИЛИ будет шестнадцатеричное значение ABCD, а в третьем примере результатом операции исключающего ИЛИ будет шестнадцатеричное значение CD.

Преобразования по умолчанию

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

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

1) Все операнды типа float

преобразуются к типу double.

2) Только для СП ТС: если один операнд имеет тип long double, то второй операнд также преобразуется к типу long double.

3) Если один операнд имеет тип double, то второй операнд преобразуется к типу double.

4) Если один операнд имеет тип unsigned long, то второй операнд преобразуется к типу unsigned long.

5) Если один операнд имеет тип long, то второй операнд преобразуется к типу long.

6) Если один операнд имеет тип unsigned int, то второй операнд преобразуется к типу unsigned int.

7) Все операнды типов char или short

преобразуются к типу int.

8) Все операнды типов unsigned char или unsigned short преобразуются к типу unsigned int.

9) Иначе оба операнда имеют тип int.

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

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

Преобразования типов при присваивании

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

Тип long double ведет себя в преобразованиях аналогично типу double.

Преобразования знаковых целых типов Знаковое целое значение преобразуется к короткому знаковому целому значению (short

signed int) посредством усечения старших битов. Знаковое целое значение преобразуется к длинному знаковому целому значению (long signed int) путем расширения знака влево. Преобразование знаковых целых значений к плавающим значениям происходит путем преобразования к типу long, а затем преобразования к плавающему типу. При этом возможна некоторая потеря точности. При преобразовании знакового целого значения к беззнаковому

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

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

char (см. таблицу 4.3).

Таблица 4.2.

Преобразование знаковых целых типов

От типа		К типу		Метод
char		short		дополнение знаком
char		long		дополнение знаком
char		unsigned char		сохранение битового представления;
char		unsigned short		старший бит теряет функцию знакового бита дополнение знаком до short; преобразование short в unsigned short
char		unsigned long		дополнение знаком до long; преобразование long в unsigned long
char		float		дополнение знаком до long; преобразование long к float
char		double		дополнение знаком до long; преобразование long к double
short		char		сохранение младшего байта
short		long		дополнение знаком
short		unsigned char		сохранение младшего байта
short		unsigned short		сохранение битового представления; старший бит теряет функцию знакового бита
short		unsigned long		дополнение знаком до long; преобразование long в unsigned long
short		float		дополнение знаком до long; преобразование long к float
short		double		дополнение знаком до long; преобразование long к double
long		char		сохранение младшего байта
long		short		сохранение младшего слова
long		unsigned char		сохранение младшего байта
long		unsigned short		сохранение младшего слова
long		unsigned long		сохранение битового представления; старший бит теряет функцию знакового бита
long		float		представляется как float; возможна некоторая потеря точности
long		double		представляется как double; возможна некоторая потеря точности

<
Примечание. В СП MSC и СП ТС тип int

эквивалентен типу short и преобразование для типа int производится как для типа short. В некоторых реализациях языка Си тип int эквивалентен типу long и преобразование для типа int

производится как для типа long.

Преобразование беззнаковых целых типов

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

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

Правила преобразования беззнаковых целых типов приведены в таблице 4.3.

Таблица 4.3.

Преобразование беззнаковых целых типов

От типа	К типу	Метод
unsigned char	char	сохранение битового представления; старший бит становится знаковым
unsigned char	short	дополнение нулевыми битами
unsigned char	long	дополнение нулевыми битами
unsigned char	unsigned short	дополнение нулевыми битами
unsigned char	unsigned long	дополнение нулевыми битами
unsigned char	float	дополнение нулевыми битами до long; преобразование long к float
unsigned char	double	дополнение нулевыми битами до long; преобразование long к double
unsigned short	char	сохранение младшего байта
unsigned short	short	сохранение битового представления; старший бит становится знаковым
unsigned short	long	дополнение нулевыми битами
unsigned short	unsigned char	сохранение младшего байта
unsigned short	unsigned long	дополнение нулевыми битами
unsigned short	float	дополнение нулевыми битами до long; преобразование long к float
unsigned short	double	дополнение нулевыми битами до long; преобразование long к double
unsigned long	char	сохранение младшего байта
unsigned long	short	сохранение младшего слова
unsigned long	long	сохранение битового представления; старший бит становится знаковым
unsigned long	unsigned char	сохранение младшего байта
unsigned long	unsigned short	сохранение младшего слова
unsigned long	float	преобразование к long; преобразование long к float
unsigned long	double	преобразование к long; преобразование long к double (в версии 5 СП MSC это преобразование производится напрямую, без промежуточного типа long)

<


Примечание. В СП MSC и СП ТС тип unsigned int эквивалентен типу unsigned short и преобразование для типа unsigned int

производится как для типа unsigned short. В некоторых реализациях языка Си тип unsigned int эквивалентен типу unsigned

long и преобразование для типа int

производится как для типа unsigned long.

Преобразование плавающих типов Значения типа float

преобразуются к типу double без потери точности. Значения типа double при преобразовании к типу float представляются с некоторой потерей точности. Однако если порядок значения типа double слишком велик для представления экспонентой

значения типа float, то происходит потеря значимости, о чем сообщается во время выполнения.

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

Таблица 4.4.

От типа	К типу	Метод
float	char	преобразование к long; преобразование long к char
float	short	преобразование к long; преобразование long к short
float	long	усечение дробной части; результат не определен, если он слишком велик для представления типом long
float	unsigned short	преобразование к long; преобразование long к unsigned short
float	unsigned long	преобразование к long; преобразование long к unsigned long
float	double	дополнение мантиссы нулевыми битами справа
double	char	преобразование к float; преобразование float к char
double	short	преобразование к float; преобразование float к short
double	long	усечение дробной части; результат не определен, если он слишком велик для представления типом long
double	unsigned short	преобразование к long; преобразование long к unsigned short
double	unsigned long	преобразование к long; преобразование long к unsigned long
double	float	усечение младших битов мантиссы; возможна потеря точности; если значение слишком велико для представления типом float, то результат преобразования не определен

<


Преобразование указателей

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

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

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

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

—принятому по умолчанию размеру указателя для действующей модели памяти (например, в средней модели указатель на данные имеет тип near);

—размеру типа аргумента.

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

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

—если указатель имеет тот же самый или меньший размер, чем целый тип, то указатель преобразуется по тем же правилам, что и беззнаковое целое;

—если размер указателя больше, чем размер целого типа, то указатель сначала преобразуется к указателю того же размера, что и целый тип, а затем преобразуется к целому типу.



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

Преобразования других типов

Из определения перечислимого типа следует, что его значения имеют тип int. Поэтому преобразования к перечислимому типу и из него осуществляются так же, как для типа int.

Недопустимы преобразования объектов типа структура или объединение.

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

Преобразования типов при вызовах функций

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

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

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

преобразуются к типу int, значения типов unsigned char и unsigned short

преобразуются к типу unsigned int.

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

Приоритет и порядок выполнения

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

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

Таблица 4.1.

Приоритет и ассоциативность операций в языке Си

Знак операции		Наименование		Ассоциативность
() [] . ->		Первичные		Слева направо
+ - ~ ! * & ++ -- sizeof приведение типа		Унарные		Справа налево
* / %		Мультипликативные		Слева направо
+ -		Аддитивные		Слева направо
>> <<		Сдвиг		Слева направо
< > <= >=		Отношение		Слева направо
== !=		Отношение		Слева направо
&		Поразрядное И		Слева направо
^		Поразрядное исключающее ИЛИ		Слева направо
|		Поразрядное включающее ИЛИ		Слева направо
&&		Логическое И		Слева направо
||		Логическое ИЛИ		Слева направо
?:		Условная		Справа налево
= *= /= %= += -= <<= >>= &= |= ^=		Простое и составное присваивание		Справа налево
,		Последовательное вычисление		Слева направо

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

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

с их ассоциативностью — либо справа налево, либо слева направо.

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

приоритет, чем арифметические операции (сложение и др.). Поэтому выражение

а = b & 0xFF + 5

вычисляется как

а = b & (0xFF +

5),

а выражение

а +с >> 1

вычисляется как

(а + с) >> 1

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

В СП ТС

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

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

таких гарантий). Гарантируется лишь то, что к моменту вызова функции все аргументы уже вычислены.

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

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

Пример:

int х,

у, z, f();

z =

х > у || f(x, у);

Сначала вычисляется выражение х>у. Если оно истинно, то переменной z присваивается значение 1, а функция f не вызывается. Если же значение х не больше у, то вычисляется выражение f(x,y). Если функция f возвращает ненулевое значение, то переменной z присваивается 1, иначе 0. Отметим также, что при вызове функции f гарантируется, что значение ее первого аргумента больше второго.



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

if(!feof(pf)) && (с = getc(pf)) …

Здесь feof — функция проверки на конец файла, getc — функция чтения символа из файла (см. раздел 12).

В-третьих, можно гарантировать, что в выражении f(x)&&g(y)

функция f будет вызвана раньше, чем функция g. Для выражения f(x)+g(y) этого утверждать нельзя.

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

Выражение	Группирование операндов
a & b || c	(a & b) || c
a = b || c	a = (b || c)
q && r || s--	(q && r) || (s--)
p == 0 ? p += 1 : p += 2	(p == 0 ? p += 1 : p) += 2

В первом примере поразрядная операция И (&) имеет больший приоритет, чем -логическая операция ИЛИ (||), поэтому выражение а&b является первым операндом логической операции ИЛИ.

Во втором примере логическая операция ИЛИ (||) имеет больший приоритет, чем операция простого присваивания, поэтому выражение b||с

образует правый операнд операции присваивания. (Обратите внимание на то, что значение, присваиваемое а, есть нуль или единица.)

В третьем примере показано синтаксически корректное выражение, которое может выработать неожиданный результат. Логическая операция И (&&) имеет более высокий приоритет, чем логическая операция ИЛИ (||), поэтому запись q&&r

образует операнд. Поскольку логические операции сначала вычисляют свой левый операнд, то выражение q&&r вычисляется раньше, чем s--. Однако если q&&r

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



s отдельной операцией.

В четвертом примере показано неверное выражение, которое приведет к ошибке при компиляции. Операция равенства (==)

имеет наибольший приоритет, поэтому p==0

группируется в операнд. Тернарная операция ?:

имеет следующий приоритет. Ее первым операндом является выражение p==0, вторым операндом — выражение p+=1. Однако последним операндом тернарной операции будет считаться p, а не p+=2. так как в данном случае идентификатор p по приоритету операций связан более тесно с тернарной операцией, чем с составной операцией сложения с присваиванием. В результате возникает синтаксическая ошибка, поскольку левый операнд составной операции присваивания не является L-выражением.

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

(р == 0) ? (р += 1) : (р += 2)

Пробельные символы

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

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

Символ CONTROL-Z (шестнадцатеричный

код 1А) рассматривается как индикатор конца файла. Он автоматически вставляется текстовым редактором при создании файла в его конец. Компилятор языка Си завершает обработку файла с исходным текстом программы при обнаружении символа CONTROL-Z.

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

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

Простое присваивание

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

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

Пример 1:

double х;

int у;

х =

у; Значение у преобразуется к типу double и присваивается х.

Пример 2:

int а, b, с; b =

2; a = b + (с = 5);

Переменной с присваивается значение 5, переменной а — значение b + 5, равное 7.

Пространства имен

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

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

Таблица 2.2.

Объекты		Пространство имен
Переменные, функции, формальные параметры, элементы списка перечисления, typedef		Уникальность имен в пределах этого пространства тесно связана с понятием области действия. Это выражается в том, что в данном пространстве могут содержаться совпадающие идентификаторы, если области действия именуемых ими объектов не пересекаются. Другими словами, совпадение идентификаторов возможно только при локальном переобъявлении (см. раздел 2.4). Обратите внимание на то, что имена формальных параметров функции сгруппированы в одном пространстве с именами локальных переменных. Поэтому переобъявление формальных параметров внутри любого из блоков функции недопустимо, typedef — это объявления имен типов (см. раздел 3.8.2).
Теги		Теги всех переменных перечислимого типа, структур и объединений (см. разделы 3.4.2 — 3.4.4) сгруппированы в одном пространстве имен. Каждый тег переменной перечислимого типа, структуры или объединения должен быть отличен от других тегов с той же самой областью действия. Ни с какими другими именами имена тегов не конфликтуют.
Элементы структур и объединений		Элементы каждой структуры или объединения) образуют свое пространство имен, поэтому имя каждого элемента должно быть уникальным внутри структуры или объединения, но не обязано отличаться от любого другого имени в программе, включая имена элементов других структур и объединений.
Метки операторов		Метки операторов образуют отдельное пространство имен. Каждая метка должна быть отлична от всех других меток операторов в той же самой функции. В разных функциях могут быть одинаковые метки.

Пример: struct student

{

char student [20]; /*массив из 20 элементов типа char*/

int class;

int id;

} student; /* структура из трех элементов */

В этом примере имя тега

структуры, элемента структуры и самой структуры относится к трем различным пространствам имен, поэтому не возникает противоречия между тремя объектами с одинаковым именем student. Компилятор языка Си определит по контексту использования, на какой из объектов ссылается идентификатор в каждом конкретном случае. Например, когда идентификатор student появится после ключевого слова struct, это будет означать, что именуется тег структуры. Когда идентификатор student появится после операции выбора элемента (->

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

Псевдопеременные

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

__LINE__

Номер текущей обрабатываемой строки исходного файла—десятичная константа. Первая строка исходного файла имеет номер 1.

__FILE__

Имя компилируемого исходного файла — символьная строка. Значение данной псевдопеременной изменяется каждый раз, когда компилятор обрабатывает директиву #include или директиву #line, а также по завершении включаемого файла.

Следующие две псевдопеременные поддерживаются только СП ТС.

__DATE__

Дата начала компиляции текущего исходного файла — символьная строка. Каждое вхождение __DATE__ в заданный файл дает одно и то же значение, независимо от того, как долго уже продолжается обработка. Дата имеет формат mmm dd УУУУ, где mmm — месяц (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec), dd — число текущего месяца (1…31; в 1-й позиции dd ставится пробел, если число меньше 10), уууу — год (например, 1990).

__TIME__

Время начала компиляции текущего исходного файла — символьная строка. Каждое вхождение __TIME__ в заданный файл дает одно и то же значение, независимо от того, как долго уже продолжается обработка. Время имеет формат hh:mm:ss, где hh — час (00…23), mm — минуты (00…59), ss

— секунды (00…59).

Пустая директива

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

Пустой оператор

Синтаксис:

;

Действие:

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

Пример:

for(i = 0; i < 10; line[i++] = 0);

Для таких операторов, как do, for, if, while, требуется, чтобы в их теле был хотя бы один оператор. Пустой оператор удовлетворяет требованиям синтаксиса в случаях, когда никаких действий не требуется. В приведенном примере третье выражение в заголовке оператора цикла for инициализирует первые 10 элементов массива line нулем. Тело оператора for

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

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

Разделители

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

Таблица 1.1.

Символ		Наименование		Символ		Наименование
,		Запятая		!		Восклицательный знак
.		Точка		|		Вертикальная черта
;		Точка с запятой		/		Наклонная черта вправо (слэш)
:		Двоеточие		\		Наклонная черта влево(обратный слэш)
?		Знак вопроса		~		Тильда
‘		Одиночная кавычка (апостроф)		_		Подчеркивание
(		Левая круглая скобка		#		Знак номера
)		Правая круглая скобка		%		Процент
{		Левая фигурная скобка		&		Амперсанд
}		Правая фигурная скобка		^		Стрелка вверх
<		Знак "меньше"		-		Знак минус
>		Знак "больше"		=		Знак равенства
[		Левая квадратная скобка		+		Знак плюс
]		Правая квадратная скобка		*		Знак умножения (звездочка)

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

Рекурсивные вызовы

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

и register, так что их значения в предшествующих, незавершенных вызовах недоступны и не портятся.

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

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

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

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

'<символ>'

<Символ> может быть любым символом из множества представимых символов (в том числе любым специальным символом), за исключением символов апостроф ('), обратный слэш (\) и новая строка.

Для представления символов апостроф и обратный слэш в качестве символьной константы необходимо вставить перед ними символ обратный слэш — '\'' и '\\'.

Для представления символа новой строки используется запись '\n' (см. раздел 1.1.4).

Примеры символьных констант приведены в таблице 1.7.

Таблица 1.7.

Константа		Значение
'а'		Малая буква а
‘?’		Знак вопроса
‘\b’		Символ забой
‘\х1В’		Символ ESC в коде ASCII

Символьные константы имеют тип int. Младший байт хранит код символа, а старший байт — знаковое расширение младшего байта.

Помимо односимвольных констант, в СП ТС реализованы двухсимвольные константы, например 'An', '\n\t', '\007\007'. Они представляются 16-битовым значением типа int, причем первый символ заносится в младший байт, а второй — в старший. Односимвольные константы также представляются 16-битовыми значениями типа int, и в старший байт, как и в СП MSC,

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

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

Символьные строки

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

"<символы>"

<символы> — это произвольное (в том числе нулевое) количество символов из множества представимых символов, за исключением символов двойная кавычка ("),

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

"Это символьная строка\n"

"Первый \\ Второй"

"\"Да, конечно,\"— сказала она."

"Следующая строка — пустая:"

""

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

"Длинные строки могут быть раз\

биты на части."

идентична строке:

"Длинные строки могут быть разбиты на части."

В СП MSC версии 5.0 и в СП ТС

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

Например, программа

main()

{

char *р;

p = "Данная программа — пример того, как можно"

" автоматически\nосуществлять объединение"

" строк в очень длинную строку;\n"

" такая форма записи может повысить"

" наглядность программ.\n";

printf("%s", p);

}

напечатает следующий текст:

Данная программа—пример того, как можно автоматически

осуществлять объединение строк в очень длинную строку;

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

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

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

Тип символьной строки—массив элементов типа char. Число элементов в массиве равно числу символов в символьной строке плюс один, поскольку нулевой символ (признак конца символьной строки) тоже является элементом массива.

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

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

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

Синтаксис описателей рекурсивными правилами:

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

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

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

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

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

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

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

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

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

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

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

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

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

Склейка лексем и преобразование аргументов макроопределений

СП ТС и версия 5.0 СП MSC реализуют две специальные препроцессорные операции: ## и #.

В директиве #define две лексемы могут быть "склеены" вместе. Для этого их нужно разделить знаками ## (слева и справа от ## допустимы пробельные символы). Препроцессор объединяет такие лексемы в одну; например, макроопределение

#define VAR (i, j) i##j

при макровызове VAR(х,6) образует идентификатор х6. Некоторые компиляторы позволяют в аналогичных целях употребить запись х/**/6, но этот метод менее переносим.

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

заменяется на "<фактический аргумент>".

Пример: макроопределение TRACE позволяет печатать с помощью стандартной функции printf значения переменных типа int в формате <имя> = <значение>.

#define TRACE(flag) printf (#flag " = %d\n", flag)

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

highval = 1024;

TRACE (highval);

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

highval = 1024;

printf("highval" " = %d\n", highval);

Следующие друг за другом символьные строки рассматриваются компилятором языка Си в СП MSC версии 5 и в СП ТС как одна строка, поэтому полученная запись эквивалентна следующей:

highval = 1024;

printf("highval = %d\n", highval);

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

main()

{

#define АВ "стандарт"

#define А "отклонение"

#define В "от стандарта"

#define CONCAT(P,Q) Р##Q

printf(CONCAT(A,В) "\n");

}

Скобочные выражения

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

(10+5)/5

скобки означают, что выражение 10+5 является левым операндом операции деления. Результат выражения равен 3. В отсутствие скобок значение выражения равнялось бы 11. Хотя скобки влияют на то, каким путем группируются операнды в выражении, они не гарантируют определенный порядок вычисления операндов для операций, обладающих свойством коммутативности (мультипликативные, аддитивные, поразрядные операции). Например, выражение (а+b)+с компилятор может вычислить как а+(b+с) или даже как (а+с)+b.

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

Составное присваивание

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

<выражение1> += <выражение2>

Оно может быть записано и таким образом:

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

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

Значение операции вырабатывается по тем же правилам, что и для операции простого присваивания. Однако выражение составного присваивания не эквивалентно обычной записи, поскольку в выражении составного присваивания <выражение1> вычисляется только один раз, в то время как в обычной записи оно вычисляется дважды: в операции сложения и в операции присваивания. Например, оператор

*str1.str2.ptr += 5;

легче для понимания и выполняется быстрее, чем оператор

*str1.str2.ptr = *str1.str2.ptr + 5;

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

Пример:

n &= 0xFFFE;

В этом примере операция поразрядное И выполняется над n и шестнадцатеричным значением FFFE, и результат присваивается n.

Составной оператор

Синтаксис:

{

[<объявление>]

.

.

.

[<оператор>]

}

Действие:

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

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

Пример:

if(i >

0) {

line[i] = х;

х++;

}

Типично использование составного оператора в качестве тела другого оператора, например оператора if. В приведенном примере, если i

больше нуля, будут последовательно выполнены операторы, содержащиеся в составном операторе.

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

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

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

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

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

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

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

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

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

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

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

Пример 1:

int р[4][3] =

{

{1, 1, 1},

{2, 2, 2},

{3, 3, 3,},

{4, 4, 4,},

};

В примере объявляется двумерный массив р,

размером 4 строки на 3 столбца,

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

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

int p[4][3] = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4};

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

Пример 2.

struct {

int n1, n2, n3;

} nlist[2][3] = {

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

{{10,11,12},

{13,14,15}, {15,16,17}} /*

строка 2 */

}

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

следующим образом:

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

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

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

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

4) Процесс инициализации элементов подмассива

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

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

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

struct {

int n1, n2, nЗ;



} nlist[2][3] = {

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

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

};

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

а оставшиеся две структуры — nlist[l][l] и nlist[1][2] — по умолчанию инициализируются нулевыми значениями. Когда компилятор языка Си обнаружит следующий список инициализаторов {7,8,9), он попытается инициализировать подмассив

nlist[2]. Однако, поскольку nlist содержит только две строки и элемента nlist[2] в нем не существует, будет выдано сообщение об ошибке.

Пример 3.

union {

char m[2][3];

int i, j, k;

} y = {

{'1'},

{'4'}

};

В третьем примере инициализируется переменная у типа объединение. Первым элементом объединения является массив; он и будет инициализироваться. Список инициализаторов {'1'}

задает значения для первой строки массива (m[0]). Поскольку в списке всего одно значение, то только первый элемент строки массива — m[0][0] —инициализируется символом '1', а оставшиеся два элемента в строке инициализируются по умолчанию нулевыми значениями (символом '\0').

Аналогично, первый элемент второй строки массива m инициализируется значением '4',

а остальные элементы инициализируются по умолчанию нулевыми значениями.

Специальные символы

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

В СП ТС

шестнадцатеричное значение байта может задаваться не только как \х, но и как \Х.

В СП ТС, помимо перечисленных специальных символов, имеется еще один: \?—знак вопроса (код Ox3F). Он введен в состав языка Си для совместимости со стандартом ANSI на язык Си. Стандарт ANSI предусматривает использование пары знаков вопроса (??) в качестве признака последовательности, представляющей какой-либо символ, который может не иметь представления на клавиатуре терминала. Если же необходимо просто записать подряд два знака вопроса (например, в символьной строке), следует записать их так: ?\?.

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

Таблица 1.2.

Специальный символ		Шестнадцатеричное значение в коде ASCII		Наименование
\n		ОА		Новая строка
\t		09		Горизонтальная табуляция
\v		0В		Вертикальная табуляция
\b		08		Забой
\г		OD		Возврат каретки
\f		ОС		Новая страница
\а		07		Звуковой сигнал
\’		2С		Апостроф
\"		22		Двойная кавычка
\\		5C		Обратный слэш
\ddd				Байтовое значение в восьмеричном представлении
\xdd				Байтовое значение в шестнадцатеричном представлении

Примечание. При работе с текстовым редактором ввод каждой строки завершается нажатием клавиши ENTER (ВВОД). Фактически при этом в текст вставляются два символа: возврат каретки и новая строка (с шестнадцатеричными значениями 0D и 0А в коде ASCII). Однако стандартные библиотечные функции ввода и вывода текстовой информации рассматривают эту пару символов как один символ — символ новой строки с шестнадцатеричным значением 0А. Этот символ представляется в символьных константах и символьных строках как \n. При чтении текстовой строки стандартные библиотечные функции заменяют упомянутую пару символов единственным символом новой строки, а при записи символа новой строки добавляют перед ним символ возврат каретки.

Если обратный слэш предшествует символу, не входящему в приведенный список, то обратный слэш игнорируется, а символ представляется обычным образом. Например, сочетание \h

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

Конструкция \ddd позволяет задать произвольное байтовое значение как последовательность от одной до трёх восьмеричных цифр. Конструкция \xdd позволяет задать произвольное байтовое значение как последовательность от одной до двух шестнадцатеричных цифр, а для версии 5.0 СП MSC – до трех шестнадцатеричных цифр. Например, символ забой в коде ASCII может быть задан как \010 или \х08. Нулевой код может быть задан как \0 или \х0. В восьмеричном представлении байта могут быть заданы только восьмеричные цифры, причем по крайней мере одна цифра должна быть задана. Например, символ забой может быть задан как \10. Аналогично, в шестнадцатеричном

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

представление символа забой может быть задано и как \х08, и как \х8.

Примечание. Если восьмеричное или шестнадцатеричное

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

цифрой, он будет интерпретироваться как часть этого представления. Например, в версии 4.0 СП MSC строка \х7Веll при выводе на печать будет выглядеть как {ell, поскольку \х7В проинтерпретируется как код левой фигурной скобки. Строка \х07Ве11 будет правильным представлением кода звукового сигнала с последующим словом

Bell.

В СП ТС

разбор конструкций, представляющих байтовое значение, реализован не вполне корректно; так, запись "\1234" считается ошибочной, хотя она представляет восьмеричное значение 123 и символ '4'.

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

(символ ESC в коде ASCII) часто используется как первый символ команд управления терминалом и принтером.

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

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

Существует специальная форма инициализации массива типа char

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

char code[] = "abc";

инициализирует массив code четырьмя символами—'a', 'b', 'c' и символом '\0',

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

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

char code[3] =

"abcd";

В примере только три первые символа инициализатора заносятся в массив code. Символ d и символ '\0' отбрасываются.

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

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

char *ptr = "abcd";

указатель ptr

будет инициализирован адресом массива типа char, содержащего символы 'а', 'b',

'с', 'd', '\0'.

Тело функции

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

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

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

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

Типы возвращаемых значений

Синтаксис задания типа возвращаемого значения функции описан в разделе 3.5 "Объявление функции",

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

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

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

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

Примеры:

/* пример 1 */

/* тип возвращаемого значения int */

static add(int х, int у)

{

return (х + у);

}

/* пример 2 */

/* тип возвращаемого значения STUDENT */

typedef

struct {

char name [20],

int id;

long class;

} STUDENT;

STUDENT sortstu(STUDENT a, STUDENT b)

{

return (a.id < b.id ? a : b);

}

/* пример 3 */

/* тип возвращаемого значения — указатель на char */

char *smallstr(char *s1, char *s2)

{

int i;

i = 0;

while(s1[i] != '\0' && s2[i] != '\0')

i++;

if(s1[i] == '\0')

return (s1);

else

return (s2);

}

В первом примере по умолчанию тип возвращаемого значения функции add

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

Во втором примере посредством объявления typedef создан структурный тип STUDENT. Далее определена функция sortstu с типом возвращаемого значения STUDENT, функция возвращает тот из своих двух аргументов структурного типа, элемент id которого меньше.

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

Указания компилятору языка Си

Синтаксис:

#pragma <последовательность-символов>

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

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

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

Унарный минус (-)

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

Унарный плюс (+)

Эта операция реализована полностью в СП ТС. В СП MSC версии 5 она реализована только синтаксически. Операция применяется для того, чтобы запретить компилятору языка Си реорганизовывать скобочные выражения.

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

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

f = а *+ (b * с)

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

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

t = b * с;

f = а * t

Обратный код (~)

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

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

Логическое отрицание (!)

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

Примеры:

/* пример 1 */

short х = 987;

х = ~х;

/* пример 2 */

unsigned short у = 0xAAAA;

y = ~y;

/* пример 3 */

if(!(x<y))…

В первом примере новое значение х равно -987.

Во втором примере переменной у присваивается новое значение, которое является обратным кодом беззнакового значения OxAAAA, т. е. 0х5555.

В третьем примере, если х больше или равен у, то результат условного выражения в операторе if равен 1 (ИСТИНА). Если х меньше у, то результат равен 0 (ЛОЖЬ).

Адресация "&"

Операция адресации вырабатывает адрес своего операнда. Операндом может быть L-выражение, в т. ч. немодифицируемое (см. раздел 4.2.7). Результат операции адресации является указателем на операнд. Тип результата — указатель на тип операнда.

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

См. примеры после описания операции косвенной адресации.

Косвенная адресация "*"

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

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

Примеры:

int *ра, х;

int a[20];

double d;

pa = &а[5];           /* пример 1 */

x = *ра;              /* пример 2 */

if ( х == *&x )       /* пример 3 */

printf("BEPHO\n");

d = *(double *)(&x);  /* пример 4 */

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

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



В третьем примере будет печататься слово ВЕРНО. Пример демонстрирует симметричность операций адресации и косвенной адресации: *&х

эквивалентно х.

Четвертый пример показывает полезное приложение этого свойства. Адрес х

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

Операция sizeof

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

имеет следующий вид:

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

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

Операндом является либо <выражение>, либо абстрактное имя типа в скобках. Результатом операции sizeof

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

int (например, в СП MSC допустимы массивы типа huge размером более 64 Кбайтов), то следует использовать приведение типа:

(long) sizeof <выражение>

В СП MSC версии 4 допустимым выражением является L-выражение, а в версии 5 и в СП ТС — произвольное выражение. Следует учитывать, что само <выражение> не вычисляется, т. к. операция sizeof выполняется на этапе компиляции программы. Для нее существен только тип результата <выражения>, а не его значение. Недопустим тип void. Применение операции sizeof к идентификатору функции в СП ТС считается ошибкой, а в СП MSC эквивалентно определению размера указателя на функцию.

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

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

struct {

char m[3][3];

} s;

то значение sizeof(s.m) будет равно 9, а значение sizeof(s) будет равно 10.

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

используется для спецификации размера типа int в качестве аргумента стандартной функции распределения памяти calloc. Значение, возвращаемое функцией (адрес выделенного блока памяти), присваивается переменной buffer.

buffer = calloc(100, sizeof(int));

Управление нумерацией строк

Синтаксис:

#line <константа> ["имя-файла"]

Директива #line сообщает компилятору языка Си об изменении имени исходного файла и порядка нумерации строк. Это изменение отражается только на диагностических сообщениях компилятора: исходный файл будет теперь именоваться как <имя-файла>, а текущая компилируемая строка получит номер <константа>. После обработки очередной строки счетчик номеров строк увеличивается на единицу. В случае изменения номера строки и имени исходного файла директивой #line компилятор "забывает" их прежние значения и продолжает работу уже с новыми значениями.

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

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

Текущий номер строки и имя исходного файла доступны в программе через псевдопеременные с именами __LINE__ и __FILE__. Эти псевдопеременные могут быть использованы для выдачи во время выполнения сообщений о точном местоположении ошибки.

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

Примеры.

/* пример 1 */

#line 151 "copy.с"

/* пример 2 */

#define ASSERT(cond) if (!cond)\

{printf ("ошибка в строке %d файла %s\n", \

__LINE__, __FILE__);} else;

В первом примере устанавливается имя исходного файла сору.с и текущий номер строки 151.

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

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

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

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

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

<операнд1> ? <операнд2>: <операнд3>

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

Тип результата зависит от типов второго и третьего операндов (они могут различаться) следующим образом:

1) Если второй и третий операнды имеют целый или плавающий тип, то выполняются преобразования по умолчанию. Типом результата является тип операндов после преобразования.

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

3) Если либо второй, либо третий операнд имеет тип void

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

4) Если либо второй, либо третий операнд является указателем на какой-либо тип, а другой является указателем на void, то результат имеет тип указатель на void.

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

Пример:

j =

(i < 0 )?(-i) : (i);

В примере j присваивается абсолютное значение i. Если i меньше нуля, то j присваивается -i. Если i больше или равно нулю, то j

присваивается i.

Условный оператор if

Синтаксис:

if(<выражение>)

<оператор1>

[else

<оператор2>]

Действие:

Тело условного оператора if выполняется в зависимости от значения <выражения>.

Сначала вычисляется <выражение>. Если значение выражения истинно (не равно нулю), то выполняется <оператор1>. Если же значение выражения ложно, то выполняется <оператор2>, непосредственно следующий за ключевым словом else.

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

Пример:

if(i >

0)

У = х/i;

else {

х = 1;

у =

f(x);

}

В примере, если i больше нуля, выполняется оператор у=x/i;. Если i меньше или равно нулю, то значение i присваивается переменной х, а значение, возвращаемое функцией f(x), присваивается переменной у.

Вложенность

Оператор if может быть вложен в <оператор1> или <оператор2> другого оператора if. При вложении операторов if

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

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

На ключевое слово if можно поставить метку, а на ключевое слово else — нельзя (однако можно поставить метку на <оператор2>, следующий за else).

Примеры.

/* пример 1 — без скобок */

if(i >

0)

if(j >

i)

x = j;

else x = i;

/* пример 2 — со скобками */

if(i >

0) {

if(j >

i)

x = j;

}

else

x = i;

В первом примере ключевое слово else ассоциируется с внутренним условным оператором if. Если i

меньше или равно нулю, то переменной х ничего не присваивается.

Во втором примере фигурные скобки ограничивают внутренний условный оператор if и тем самым делают конструкцию else

частью внешнего условного оператора if. Если i меньше или равно нулю, то переменной х

присваивается значение i.

Виды моделей

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

—размер кода программы превышает 64 Кбайта;

—размер статических данных программы превышает 64 Кбайта.

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

Архитектура микропроцессора типа 8086/8088 предусматривает разбиение оперативной памяти на физические сегменты. Размер одного сегмента не превышает 64 Кбайта. Минимальное количество сегментов, которое выделяется программе, равно двум: один для кода, другой для статических данных. Эти сегменты называются стандартными. Малая модель памяти использует только эти два сегмента. Другие модели позволяют

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

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

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

Адрес оперативной памяти состоит из двух частей:

1) 16-битового числа, представляющего базовый адрес сегмента;

2) 16- битового числа, представляющего смещение внутри этого сегмента.

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

Если код или данные располагаются за пределами стандартных сегментов, для доступа к ним должны использоваться обе части адреса — и адрес сегмента, и смещение. Указатели для такого доступа объявляются с модификатором far (дальний). Доступ к объектам по указателям типа far занимает больше памяти и времени, однако позволяет адресовать всю оперативную память, а не только 64 Кбайта.

Имеется третий вид указателей — huge

(максимальный). Адрес типа huge подобен адресу типа far, поскольку оба включают и адрес сегмента, и смещение. Однако адресная арифметика для far и huge адресов различается. Поскольку объекты, адресуемые far указателями, не выходят за границу адресуемого сегмента, действия адресной арифметики выполняются только над второй половиной адреса — над смещением. Это ускоряет доступ, однако ограничивает размер одного программного объекта 64 Кбайтами. Для указателей типа huge

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

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

Малая модель

В малой (small) модели памяти программа занимает два стандартных сегмента: сегмент кода и сегмент данных, в котором размещен также стек. Как код, так и данные программы не могут превышать 64 Кбайтов; следовательно, суммарный размер программы не может превышать 128 Кбайтов. Малая модель подходит для большинства программ и потому назначается компилятором по умолчанию.



В малой модели для доступа к объектам кода или данных используются указатели типа near. Можно, однако, изменить это умолчание, применяя модификаторы far или huge

для объявления элементов данных и модификатор far

для функций.

Средняя модель

В средней (medium) модели памяти для данных и стека программы выделяется один сегмент, а для кода — столько сегментов, сколько потребуется. Каждому исходному модулю программы выделяется собственный сегмент кода.

Средняя модель применяется обычно для программ с большим количеством операторов (более 64 Кбайтов кода), но сравнительно небольшим размером данных (менее 64 Кбайтов). Для доступа к функциям по умолчанию используются указатели типа far, для доступа к данным — указатели типа near. Можно, однако, изменить это умолчание, применяя модификаторы far или huge

для объявления элементов данных и модификатор near

для функций.

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

Компактная модель

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

В компактной модели доступ к коду (функциям) производится по указателям типа near, а к данным — по указателям типа far. Это умолчание можно обойти, используя модификаторы near и huge для объявления данных и модификатор far для функций.

Большая модель

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

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

для объявления данных и модификатор near для функций.

Максимальная модель

Максимальная (huge) модель аналогична большой модели, за исключением того, что в ней снимается ограничение на размер массивов (указатели типа far, применяемые в большой модели, ограничивают размер отдельного элемента данных 64 Кбайтами). Некоторые ограничения, однако, налагаются на размер элементов huge



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

1) Никакой элемент массива не может превышать по размеру 64 Кбайта.

2) Если размер массива больше 128 Кбайтов, размер его элементов (в байтах) должен быть степенью двойки (т. е. 2, 4, 8, 16 и т.д.). Если же размер массива меньше или равен 128 Кбайтам, то размер его элементов может быть от 1 байта до 64 Кбайтов (включительно).

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

имеет тип unsigned int, однако число байтов в huge массиве может быть представлено только типом unsigned long. Для получения правильного значения в этом случае следует применять приведение типа операции sizeof:

(unsigned long)sizeof(huge_item)

Аналогично, результат вычитания указателей определен в языке Си как значение типа int. При вычитании указателей типа huge может оказаться, что результат имеет тип long. В этом случае также необходимо применить приведение типа:

(long)(huge_ptr1—huge_ptr2)

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

Синтаксис:

#include "имя пути"

#include <имя пути>

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

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

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

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

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

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

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

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

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

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

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

Примеры:

#include <stdio.h>    /*

пример 1 */

#include "defs.h"     /* пример 2 */

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

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

В СП ТС

имеется возможность задавать имя пути в директиве #include

с помощью именованной константы. Если за словом include

следует идентификатор, препроцессор проверяет, не именует ли он константу или макроопределение. Если же за словом include

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

Примеры:

#define myinclude "c:\tc\include\mystuff.h"

#include myinclude

#include "myinclude.h"

Первая директива #include заставит препроцессор просматривать директорию C:\TC\INCLUDE\MYSTUFF.H, а вторая заставит искать файл MYINCLUDE.H в текущей директории.

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

Время жизни и область действия

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

Блок представляет собой составной оператор. Составные операторы могут содержать объявления и операторы (см. раздел 5.3 "Составной оператор").

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

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

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

Область действия объекта определяет, в каких участках программы допустимо использование имени этого объекта. Так, объект с глобальным временем жизни существует в течение всего времени выполнения программы, однако он доступен только в тех частях программы, на которые распространяется его область действия. Область действия объекта распространяется на блок или исходный файл, если в этом блоке или исходном файле известны тип и имя объекта. Объект может иметь глобальную или локальную область действия. Глобальная область действия означает, что объект доступен, или может быть через соответствующие объявления сделан доступным в пределах всех исходных файлов, образующих программу. Этот вопрос рассматривается в разделе 3.6 "Классы памяти". Локальная область действия означает, что объект доступен только в том блоке или файле, в котором он объявлен или определен.

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

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

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

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

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

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



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

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

Область действия функции, объявленной с классом памяти extern,

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

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

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

Таблица 2.1.

Уровень	Объект	Спецификация класса памяти	Время жизни	Область действия
Внешний	Определение переменной	static	Глобальное	Остаток исходного файла
	Объявление переменной	extern	Глобальное	Остаток исходного файла
	Объявление или определение функции	static или extern	Глобальное	Остаток исходного файла
Внутренний	Объявление переменной	extern	Глобальное	Блок
	Определение переменной	static	Глобальное	Блок
	Определение переменной	auto или register	Локальное	Блок
	Объявление функции	extern или static	Локальное	Остаток исходного файла

<


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

/* i определяется на внешнем уровне */

int i = 1;

/* функция main определяется на внешнем уровне */

main()

{

/* печатается 1 (значение переменной i внешнего уровня) */

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

/* первый вложенный блок */

{

/* i переопределяется */

int i = 2, j = 3;

/* печатается 2, 3 */

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

/* второй вложенный блок */

{

/* i переопределяется */

int i = 0;

/* печатается 0, 3 */

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

/* конец второго вложенного блока */

}

/* печатается 2 (восстановлено определение i в охватывающем блоке) */

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

/* конец первого вложенного блока */

}

печатается 1 (восстановлено определение внешнего уровня)*/

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

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

}

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

определена в библиотеке стандартных функций (см. раздел 12). Функция main печатает значения 1, 2, 3, 0,3,2,1.

Среди современных языков программирования язык

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


Выражение — это комбинация операндов и операций, задающая порядок вычисления некоторого значения. Операции определяют действия, выполняемые над операндами. Операнд в простейшем случае является константой или переменной. В общем случае каждый операнд выражения также представляет собой выражение, имеющее некоторое значение.
В отличие от многих языков программирования высокого уровня, в языке Си присваивание само является выражением. Как любое выражение, присваивание имеет значение — это тот результат, который присваивается переменной, задаваемой левым операндом. Помимо простого присваивания, в языке Си существуют составные операции присваивания, которые выполняют дополнительные операции над своими операндами.
Результат вычисления выражения зависит от приоритета операций, а также от возможных побочных эффектов. Приоритет операций определяет группирование операндов в выражении и последовательность выполнения операций. Побочным эффектом называется изменение значения какого-либо операнда, вызванное вычислением другого операнда. Для некоторых операций возникновение побочного эффекта зависит от порядка вычисления операндов.
Значение, представляемое операндом в выражении, имеет тип. Этот тип может быть в ряде случаев преобразован (явно или неявно) к другому типу по некоторым правилам. Преобразования типов описаны в разделе 4.7.


Операторы языка Си управляют процессом выполнения программы. Набор операторов языка Си содержит все управляющие конструкции структурного программирования. Ниже представлен полный список операторов:
пустой оператор
составной оператор или блок
оператор-выражение
условный оператор if
оператор пошагового цикла for
оператор цикла с предусловием while
оператор цикла с постусловием do
оператор продолжения continue
оператор-переключатель switch
оператор разрыва break
оператор перехода goto
оператор возврата return
В составе некоторых операторов используются выражения, выполняющие роль условий. В зависимости от значения такого условного выражения выбирается та или иная последовательность действий. В языке Си отсутствуют булевские выражения как самостоятельный класс выражений; в качестве условных выражений применяются обычные выражения языка Си. Значение выражения считается истинным, если оно не равно нулю, и ложным, если равно нулю. Из этого следует, что условные выражения не обязательно должны содержать операции отношения
if(а < 0) …
а могут выглядеть, например, так:
if(а) … или if(а + b)
В теле некоторых операторов языка Си могут содержаться другие операторы. Оператор, находящийся в теле другого оператора, в свою очередь может содержать операторы.
Составной оператор ограничивается фигурными скобками. Все другие операторы заканчиваются точкой с запятой (;). Точка с запятой в языке Си является признаком конца оператора, а не разделителем операторов, как в ряде других языков программирования.
Перед любым оператором языка Си может быть записана метка, состоящая из имени и двоеточия. Операторные метки распознаются только оператором goto (см. раздел 5.12 "Оператор перехода goto").
Программа на языке Си выполняется последовательно, оператор за оператором, за исключением случаев, когда какой-либо оператор явно передает управление в другую часть программы, например при вызове функции или возврате из функции.


Функция — это совокупность объявлений и операторов, предназначенная для выполнения некоторой отдельной задачи. Количество функций в программе не ограничивается. Любая программа на языке Си содержит, по крайней мере, одну функцию, так называемую главную функцию, с именем main. В данном разделе описывается, как определять, объявлять и вызывать функции в языке Си.
Определение функции специфицирует имя функции, атрибуты ее формальных параметров, и тело функции, содержащее Объявления и операторы. В определении функции также может задаваться класс памяти функции и тип возвращаемого значения.
Объявление функции задает имя и тип возвращаемого значения функции, явное определение которой приведено в другом месте программы. В объявлении функции могут быть также специфицированы класс памяти, число аргументов функции и их типы. Прототип функции (версия 5.0 СП MSC и СП ГГС) позволяет, помимо того, задавать в объявлении идентификаторы и класс памяти аргументов. Это позволяет компилятору сравнивать при вызове типы фактических аргументов и формальных параметров функции.
Указание типа возвращаемого значения в определении функции необязательно, если это тип int. При другом типе возвращаемого значения необходимо указать этот тип в объявлении функции. К моменту вызова функции тип ее возвращаемого значения должен быть известен, поэтому перед вызовом может потребоваться предварительное объявление функции с указанием типа ее возвращаемого значения.
Вызов функции передает управление от вызывающей функции к вызываемой. Значения фактических аргументов, если они есть, передаются в вызываемую функцию. При выполнении оператора возврата return
в вызываемой функции управление и возвращаемое значение (если оно есть) передаются в вызывающую функцию.


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

#define	#else	#if	#ifndef	#line
#elif	#endif	#ifdef	#include	#undef

Символ #
должен быть первым в строке, содержащей директиву в СП MSC версии 4. В СП MSC версии 5 ив СП ТС ему могут предшествовать пробельные символы. Как в СП MSC, так и в СП ТС пробельные символы допускаются между символом # и первой буквой директивы.
Некоторые директивы могут содержать аргументы. Директивы могут быть записаны в любом месте исходного файла, но их действие распространяется только от точки программы, в которой они записаны, до конца исходного файла.
Указания компилятору, или прагмы, представляют собой инструкции, записываемые в исходном тексте программы и предназначенные для управления действиями компилятора языка Си в определенных ситуациях. Набор указаний компилятору и их смысл различаются для разных компиляторов языка Си, поэтому в разделе 7.8 описывается только общий синтаксис указаний компилятору.
В рассматриваемых системах программирования есть возможность получить промежуточный текст программы после работы препроцессора, до начала собственно компиляции. В этом файле уже выполнены макроподстановки, а все строки, содержащие директивы #define и #undef, заменены на пустые строки. На место строк #include подставлено содержимое соответствующих включаемых файлов. Выполнена обработка директив условной компиляции #if, #elif, #else, #ifdef, #ifndef, #endif, а строки, содержащие их, заменены пустыми строками. Пустыми строками заменены и исключенные в процессе условной компиляции фрагменты исходного текста. Кроме того, в этом файле есть строки следующего вида:
#<константа>["имя файла"]
которые соответствуют точкам изменения номера текущей строки и/или номера файла по директивам #line или #include.

Выбор элемента

Синтаксис:

<выражение>.<идентификатор>

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

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

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

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

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

для случая, когда <выражение> имеет тип указатель, эквивалентна записи

(*<выражение>).<идентификатор>

однако более наглядна.

Примеры:

struct pair {

int a;

inl b;

struct pair *sp;

} item, list[10];

item.sp = &item;           /* пример 1 */

(item.sp)->a = 24;         /* пример 2 */

list[8].b =

12;            /* пример 3 */

В первом примере адрес структуры Нет присваивается элементу sp

этой же структуры. В результате структура item

содержит указатель на себя.

Во втором примере используется адресное выражение item.sp

с операцией выбора элемента ->,

присваивающее значение элементу а. Учитывая результат примера 1,

пример 2 эквивалентен записи

item.a = 24;

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

Выполнение программы

Каждая программа на языке Си содержит главную функцию. В языке Си главная функция программы должна иметь имя main. С функции main начинается выполнение программы; обычно она управляет выполнением программы, организуя вызовы других функций. Программа может завершить выполнение по достижению конца функции main, однако может завершиться и в других точках путем вызова стандартных библиотечных функций, предназначенных для выхода из программы (см. описание функций exit и abort в разделе 12).

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

либо когда выполнение доходит до конца тела функции.

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

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

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

Пример:

PROG 25 "ab с" 100

Программе с именем PROG передаются три аргумента — символьные строки "25", "ab с" и "100".

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

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

и envp,

однако это не является требованием языка.

Пример объявления формальных параметров функции main:

main (int

argc, char *argv[], char *envp []){}

Если программа не требует аргументов, то функцию main

можно объявить без формальных параметров:

main()

{

…

}

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

Параметр argv представляет собой массив адресов, каждый элемент которого указывает на строковое представление соответствующего по порядку аргумента, передаваемого программе. Параметр argc определяет общее число передаваемых аргументов. Первый элемент массива argv (т. е. argv[0]) всегда содержит имя программы, по которому она была вызвана. Этот элемент всегда заполнен, поэтому значение argc всегда равно по крайней мере 1. Доступ к первому аргументу, переданному программе, можно осуществить с помощью выражения argv[1], к последнему аргументу —argv[argc-1].

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

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

и spawn.

Вызов функции

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

<выражение>([<список выражений>])

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

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

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

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

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

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

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

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

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

int (*fpointer)(int, int);

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

extern int f (int, int);

fpointer = &f; /*знак & необязателен */

(*fpointer)(3,4); /* можно и просто fpointer(3,4); */

Примеры:

/* пример 1 */

double *realcomp(double, double);

double a, b, *rp;

rp = realcomp(a, b);

/* пример 2 */

main()

{

long lift(int), slep(int), drop(int);

void work(int, long (*)(int));

int select, count;

.

.

.

switch(select) {

case 1: work(count, lift); break;

case 2: work(count, step); break;

case 3: work(count, drop); break;

default: break;

}

void work(int n,

long (*func)(int))

{

int i;

long j;

for(i = j = 0; i < n; i++)

j +=

(*func)(i); /* можно просто j += func(i); */

}

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

Во втором примере функции work передаются два аргумента: целая переменная count и адрес функции (lift,

step, или drop). Обратите внимание на то, что адрес функции может задаваться просто указанием идентификатора функции, поскольку идентификатор функции интерпретируется как адресное выражение. Чтобы использовать идентификатор функции подобным образом, функция должна быть объявлена или определена перед использованием идентификатора, иначе идентификатор не будет распознан. Поэтому в начале функции main приведены объявления функций lift, step, drop.

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

и возвращающую значение типа long. Скобки, заключающие символ *, обязательны. Без них объявление специфицировало бы функцию, возвращающую указатель на значение типа long. Функция work вызывает выбранную функцию оператором

(*func) (i);

Аргумент i

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

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

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

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

что подразумевает переменное число аргументов (см. раздел 6.2.4).

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

См. описания макроопределений va_arg, va_end, va_start, которые могут быть полезны при работе с переменным числом аргументов.

Вызовы функций

Синтаксис:

<выражение> (<список-выражений>)

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

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

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

---

---