|
Основы алгоритмического языка С++
Здесь представлены базовые компоненты программ на С++. В их число
входят типы данных, переменные, константы и выражения. - Предопределенные типы данных в С++ включают в себя типы int,
char, float, double и void. В языке С++ гибкость типов данных увеличивается
благодаря применению модификаторов типов. Эти модификаторы изменяют точность
представления и диапазон значений переменных. Модификаторами типа являются
signed, unsigned, short и long. - Идентификаторы в С++ могут иметь длину до
32 символов и должны начинаться с буквы или подчеркивания. Последующие символы
идентификатора могут быть буквой, цифрой или подчеркиванием. Идентификаторы С++
чувствительны к регистру. Ограничение на 32 символа может быть, однако, изменено
путем установки опций компилятора. - Директива #include является специальной
командой компилятора. Она предписывает компилятору включить в программу
содержимое определенного файла, как если бы вы сами ввели его в текущий исходный
файл. - Объявление констант предусматривает использование директивы #define
для объявления констант, определенных при помощи макросов, или использование
ключевого слова const для объявления формальных констант. Формальные константы
требуют от вас определения их типа (значением по умолчанию является int), имени
и ассоциированного с ними значения. - Объявление переменной требует, чтобы вы
задали ее тип и имя, С++ дает вам возможность инициализировать переменную при ее
объявлении. Вы можете объявить несколько переменных в одном операторе
объявления. - Арифметические выражения различаются по сложности. Самое простое
выражение содержит единственный элемент данных (литерал, константу или
переменную). Сложные выражения включают набор операций, функции, литералы,
константы и переменные. - Операцииинкремента и декремента используются в
префиксной и постфиксной формах. Язык С++ дает вам возможность применять эти
операции к переменным, в которых хранятся символы, целые числа и даже числа с
плавающей точкой. - Арифметические операции присваивания дают вам возможность
записывать более короткие арифметические выражения, в которых первый операнд
является также переменной, принимающей результат вычислений. - Механизм приведения типа дает вам возможность форсировать
преобразование типа выражения. - Булевы выражения
объединяют операции отношений и логические операции для формулирования
нетривиальных условий. Эти выражения позволяют программе принимать сложные
решения. - Операции манипулирования битами
выполняют поразрядные операции AND, OR, XOR и NOT. Кроме того, в С++
поддерживаются поразрядные операции сдвига << и >>. - Операции
манипулирования битами с присваиванием предлагают короткие формы для простых
операций манипулирования битами. Множество символов Си
включает большие и малые буквы из английского алфавита и 10 десятичных арабских
цифр: -малые английские буквы: a b c d e f g h i j k l m n o p q r t u v w x
y z Буквы и цифры используются при
формировании констант, идентификаторов и ключевых слов. Все эти конструкции
описаны ниже. Компилятор Си рассматривает одну и ту же малую и большую буквы как
отличные символы. Если в данной записи использованы малые буквы, то замена малой
буквы "a" на большую букву "A" сделает отличной данную запись от
предшествующей. Пробел, табуляция, перевод
строки, возврат каретки, новая страница, вертикальная табуляция и новая строка-
это сиволы, называемые пробельными, поскольку они имеют то же самое назначение,
как и пробелы между словами и строками на печатной странице. Эти символы
разделяют объекты, определенные пользователем, такие, как константы и
идентификаторы, от других объектов программы. Символ CONTROL-Z
рассматривается как индикатор конца файла. Компилятор игнорирует любой текст,
следующий за символом Компилятор Си игнорирует пробельные
символы, если они не используются как разделители или как компоненты константы-
символа или строковых литералов. Это нужно иметь в виду, чтобы дополнительно
использовать пробельные символы для повышения наглядности программы
(например,для просмотра редактором текстов). Эти символы имеют специальный смысл для компилятора
Си. Их использование в языке Си описывается в дальнейшем содержании руководства.
Знаки пунктуации из множества представимых символов, которые не представлены в
данном списке, могут быть использованы только в строковых литералах, константах-
символах и комментариях. ESC- последовательности-
это специальные символьные комбинации, которые представляют пробельные символы и
неграфические символы в строках и символьных константах. Их типичное
использование связано со спецификацией таких действий, как возврат каретки и
табуляция , а также для задания литеральных представлений символов, таких как
символ двойная кавычка. ESC-последовательность состоит из наклонной черты влево,
за которой следует буква, знаки пунктуации ' " \ или комбинация цифр. В таблице
2.2. приведен список ESC- последовательностей языка Си. Если наклонная
черта влево предшествует символу, не включенному в этот список, то наклонная
черта влево игнорируется, а символ представляется как литеральный. Например,
изображение \c представляет символ "c" в литеральной строке или константе-
символе. Последовательности \ddd и \xdd позволяют задать любой символ в ASCII
(Американский стандартный код информационного интерфейса) как последовательность
трех восьмеричных цифр или двух шестнадцатеричных цифр. Например, символ пробела
может быть задан как \010 или \x08. Код ASCII "нуль" может быть задан как \0 или
\x0 . В восьмеричной ESC- последовательности могут быть использованы от одной до
трех восьмеричных цифр. Например, символ пробела может быть задан как \10 .
Точно так же в шестнадцатеричной ESC- последовательности могут быть использованы
от одной до двух шестнадцатеричных цифр. Так, шестнадцатеричная
последовательность для символа пробела может быть задана как \x08 или \x8 . Когда используется восьмеричная или шестнадцатеричная
ESCпоследовательность в строках, то нужно полностью задавать все цифры ESC-
последовательности (три цифры для восьмеричной и две цифры для шестнадцатеричной
ESC- последовательностей). Иначе, если символ непосредственно следующий за ESC-
последовательностью, случайно окажется восьмеричной или шестнадцатеричной
цифрой, то он проинтерпретируется как часть последовательности. Например, строка
\x7Bell при выводе на печать будет выглядеть как {ell , поскольку \x7B
проинтерпретируется как символ левой фигурной скобки({) . Строка \x07Bell будет
правильным представлением символа "звонок" с последующим словом Bell. ESC-
последовательности позволяют посылать неграфические управляющие символы к
внешним устройствам. Например, ESC- последовательность\033 часто используется
как первый символ команд управления терминалом и принтером. Неграфические
символы всегда должны представляться ESC-последовательностями, поскольку,
непосредственное использование в программах на Си неграфических символов будет
иметь непредсказуемый результат. Наклонная черта влево (\) помимо определения
ESC-последовательностей используется также, как символ продолжения строки в
препроцессорных определениях. Если символ "новая строка" следует за наклонной
чертой влево, то новая строка игнорируется и следующая строка рассматривается,
как часть предыдущей строки. Операции- это специальные комбинации
символов, специфицирующие действия по пробразованию различных величин.
Компилятор интерпретирует каждую из этих комбинаций как самостоятельную единицу,
называемую лексемой (token). Операция условного выражения ?: -это тернарная,
а не двухсимвольная операция. Формат условного выражения следующий:
<expression>?<expression>:<expression>
Константа- это число, символ или строка символов. Константы используются в
программе как неизменяемые величины. В языке Си различают четыре типа констант:
целые константы, константы с плавающей точкой, константы-символы и строчные
литералы. Целая константа- это десятичное, восьмеричное
или шестнадцатеричное число, которое представляет целую величину. Десятичная
константа имеет следующий формат представления: Восьмеричная
константа имеет следующий формат представления: где
<odigits> - это одна или более восьмеричных цифр от 0 до 7. Запись
ведущего нуля необходима. 0X<hdigits>, где
<hdigits> одна или более шестнадцатеричных цифр. Шестнадцатеричная цифра
может быть цифрой от 0 до 9 или буквой (большой или малой) от A до F. В
представлении константы допускается "смесь" больших и малых букв. Запись
ведущего нуля и следующего за ним символа x или X необходима. Пробельные
символы не допускаются между цифрами целой константы. В Табл. 2.4 иллюстрируются
примеры целых констант. Целые константы всегда специфицируют положительные
величины. Если требуется отрицательные величины, то необходимо сформировать
константное выражение из знака минус и следующей за ним константы. Знак минус
рассматривается как арифметическая операция. Каждая целая константа
специфицируется типом, определяющим ее представление в памяти и область
значений. Десятичные константы могут быть типа int или long. Восьмеричные и
шестнадцатеричные константы в зависимости от размера могут быть типа int,
unsigned int, long или unsigned long. Если константа может быть представлена как
int, она специфицируется типом int. Если ее величина больше, чем максимальная
положительная величина, которая может быть представлена типом int, но меньше
величины, которая представляется в том же самом числе бит как и int, она
задается типом unsigned int. Наконец, константа, величина которой больше чем
максимальная величина, представляемая типом unsigned int, задется типом long или
unsigned long, если это необходимо. Важность рассмотренных выше правил
состоит в том, что восьмеричные и шестнадцатеричные константы не содержат
"знаковых" расширений, когда они преобразуются к более длинным типам
(преобразование типов смотри в разделе 5 "Выражения и присваивания").
Программист может определить для любой целой константы тип long, приписав
букву "l" или "L" в конец константы. В Табл. 2.6 показаны примеры целых
констант. Константа с плавающей точкой- это
действительное десятичное положительное число. Величина действительного числа
включает целую, дробную части и экспоненту. Константы с плавающей точкой имеют
следующий формат представления: где <digits> - одна или более десятичных цифр (от 0
до 9), а E или e -символ экспоненты. Целая или дробная части константы могут
быть опушены, но не обе сразу. Десятичная точка может быть опущена только тогда,
когда задана экспонента. Экспонента состоит из символа экспоненты, за которым
следует целочисленная величина экспоненты, возможно отрицательная. Константы с плавающей
точкой всегда специфицируют положительные величины. Если требуются отрицательные
величины, то необходимо сформировать константное выражение из знака минус и
следующей за ним константы. Знак минус рассматривается как арифметическая
операция. 25e-4 Все константы с плавающей точкой имеют тип double. Константа-символ- это буква, цифра, знак пунктуации или ESC-
символ, заключенные в одиночные кавычки. Величина константы-символа равна
значению представляющего ее кода символа. где <char> может быть любым
символом иэ множества представимых символов, включая любой ESC- символ, исключая
одиночную кавычку ('), наклонную черту влево (\) и символ новой строки. Чтобы
использовать одиночную кавычку или наклонную черту влево в качестве константы-
символа, необходимо вставить перед этими знаками наклонную черту влево. Чтобы
представить символ новой строки, необходимо использовать запись '\n'. Строковый литерал- это
последовательность букв, цифр и символов, заключенная в двойные кавычки.
Строковый литерал рассматривается как массив символов, каждый элемент которого
представляет отдельный символ. Строковый литерал имеет следующую форму
представления: где <characters> - это нуль
или более символов из множества представимых символов, исключая двойную кавычку
("), наклонную черту влево (\) и символ новой строки. Чтобы использовать символ
новой строки в строковом литерале, необходимо напечатать наклонную черту влево,
а затем символ новой строки. Наклонная черта влево вместе с символом новой
строки будут проигнорированы компилятором , что позволяет формировать строковые
литералы, располагаемые более чем в одной строке. Например, строковый
литерал: "Long strings can be brocken into two pieces." Чтобы использовать
двойные кавычки или наклонную черту влево внутри строкового литерала, нужно
представить их с предшествующей наклонной чертой влево, как показано в следующем
примере: "The following line shows a null string:" Заметим, что
ESC- символы (такие как \\ и \") могут появляться в строковых литералах. Каждый
ESC- символ считается одним отдельным символом. Символы строки запоминаются в
отдельных байтах памяти. Символ null (\0) является отметкой конца строки. Каждая
строка в программе рассматривается как отдельный объект. Если в программе
содержатся две идентичные строки, то каждая из них будет храниться в отдельном
месте памяти. Строчные литералы имеют тип char[]. Под этим подразумевается,
что строка- это массив, элементы которого имеют тип char. Число элементов в
массиве равно числу символов в строчном литерале плюс один, поскольку символ
null (отметка конца строки) тоже считается элементом массива. Идентификаторы- это имена переменных, функций и меток,
используемых в программе. Идентификатор создается объявлением соответствующей
ему переменной или функции.После этого его можно использовать в последующих
операторах программы. Идентификатор- это последовательность из одной или более
букв, цифр или подчерков(_), которая начинается с буквы или подчерка.
Допускается любое число символов в идентификаторе, однако только первые 31
символ распознаются компилятором. (Программы, использующие результат работы
компилятора, такие как, линкер, могут распознавать меньшее число символов).
При использовании подчерков в идентификаторе нужно быть осторожным, поскольку
идентификаторы, начинающиеся с подчерка могут совпадать (войти в конфликт) с
именами "скрытых" системных программ. Компилятор Си рассматривает буквы верхнего и нижнего
регистров как различные символы. Поэтому можно создать отдельные независимые
идентификаторы, которые совпадают орфографически, но различаются большими и
малыми буквами. Например, каждый из следующих идентификаторов является
уникальным: Компилятор Си не допускает
идентификаторов, которые имеют ту же самую орфографию, что и ключевые слова.
Ключевые слова описаны в следующем раздела По сравнению с
компилятором, сборщик может в большей степени ограничивать количество и тип
символов для глобальных идентификаторов, и в отличие от компилятора не делать
различия между большими и малыми буквами. (Подробнее смотри руководство по
пакету MSC). Ключевые слова- это предопределенные
идентификаторы, которые имеют специальное значение для компилятора Си. Их можно
использовать только так как они определены. Имена объектов программы не могут
совпадать с названиями ключевых слов. char
extern return union Ключевые слова не могут
быть переопределены. Тем не менее, они могут быть названы другим текстом, но
тогда перед компиляцией они должны быть заменены посредством препроцессора на
соответствующие ключевые слова. Следующие идентификаторы могут
быть ключевыми словами для некоторых приложений: Комментарий- это последовательность
символов, которая воспринимается компилятором как отдельный пробельный символ
или, другими словами, игнорируется. где <characters> может быть
любой комбинацией символов из множества представимых символов, включая символы
новой строки, но исключая комбинацию */. Это означает, что комментарии могут
занимать более одной строки, но не могут быть вложенными. Комментарии
допускаются везде, где разрешены пробельные символы. Компилятор игнорирует
символы комментария, в частности, в комментариях допускается запись ключевых
слов и зто не приведет к ошибке. Так как компилятор рассматривает комментарий
как символ пробела, то комментарии не могут появляться внутри лексем.
lines of a program. */ Comments can occupy several
lines. *******************************************/
/* You cannot/* nest */ comments */ Компилятор распознает первую комбинацию
*/ после слова nest как конец комментария. Затем, компилятор попытается
обрабатывать оставшийся текст и выработает сообщение об ошибке. Чтобы обойти
компиляцию комментариев больших размеров, нужно использовать директиву #if
препроцессора. Когда компилятор обрабатывает программу, он
разбивает программу на группы символов, называемых лексемами. Лексема- это
единица текста программы, которая имеет определенный смысл для компилятора и
которая не может быть разбита в дальнейшем. Операции, константы, идентификаторы
и ключевые слова, описанные в этом разделе,являются примерами лексем. Знаки
пунктуации, такие как квадратные скобки ([]), фигурные скобки ({}), угловые
скобки (<>), круглые скобки и запятые, также являются лексемами. Границы
лексем определяются пробельными символами и другими лексемами, такими как
операции и знаки пунктуации. Чтобы предупредить неправильную работу компилятора,
запрещаются пробельные символы между символами идентификаторов, операциями,
состоящими из нескольких символов и символами ключевых слов. Когда компилятор
выделяет отдельную лексему, он последовательно объединяет столько символов,
сколько возможно, прежде чем перейти к обработке следующей лексемы. Поэтому
лексемы, не разделенные пробельными символами, могут быть проинтерпретированы
неверно. В этом примере
компилятор вначале создает из трех знаков плюс самую длинную из возможных
операций (++), а затем обработает оставшийся знак +, как операцию сложения (+).
Выражение проинтерпретируется как (i++)+(j), а не как (i)+(++j). В таких случаях
необходимо использовать пробельные символы или круглые скобки, чтобы однозначно
определить ситуацию. #include <iostream.h>
cout << "i = " << i << endl cout << "y = " << y
<< endl x =
39.4784 #define MIN_IN_HOUR 60 cin >> hours; cin
>> seconds; cout << endl << totalSec << "
секунд прошло с полуночи" << endl;
36000 секунд прошло сполуночи const int SEC_IN_MIN
= 60; // глобальная константа long
totalSec; cin >> minutes; SEC_IN_MIN) + seconds; return
0; 4220 секунд прошло с полуночи int main() cout
<< endl << "Введите первое целое число: "; cout
<< endl; long5 = int1 % int2;
cout << int1 << " - " << int2 << " = " << long2
<< endl; cout << int1 << " / " << int2
<< " = " << long4 << endl; cout <<
endl << endl; cout << "Введите второе вещественное число: "; cout << x << " + " << y <<
" = " << real1 << endl; cout << x << " * "
<< y << " = " << real3 << endl; cout
<< endl << endl; 10 + 5 = 15 Введите второе вещественное число: 2.58 //Демонстрация операций инкремента и декремента см. в
программе OPER2.CPP // для этого операцию sizeof() с переменными и типами
данных. char aChar; cout << " Тип данных Используемая " << endl; cout << "-----------------
- -----------" << endl; cout << " integer " <<
sizeof(anInt) << endl; cout << " character " <<
sizeof(aChar) << endl; cout << " Тип данных Используемая" << endl; cout << "-----------------
- -----------" << endl; cout << " integer " <<
sizeof(int) << endl; cout << " character " << sizeof(char)
<< endl; Тип данных Используемая память (в байтах) Таблица 2. Размеры
памяти для типов данных long integer 4 #include <iostream.h>
char aChar; // действия выполняются без приведения типа aChar = aLong + 5; // автоматическое преобразование cout <<
"shortInt1 = " << shortInt1 << endl << "anInt = " << anInt << endl << "aReal = " << aReal << endl << endl <<
endl; anInt = (int) (shortInt1 - shortInt2); aReal = (float) (shortInt1 * shortInt2 + 0.5); << "shortInt2 = "
<< shortInt2 << endl << "aLong = "
<< aLong << endl << "aReal = " << aReal << endl << endl <<
endl; aChar is A aReal = 60.5 Существует
несколько стилей, которые стали популярными в последние годы. Стиль, который
используется в наших занятиях, требует начинать имя переменной с символа,
набранного в нижнем регистре. Если идентификатор состоит из нескольких слов,
как, например, numberOfElements, набирайте первый символ каждого последующего
слова в верхнем регистре. Компилятор выдает
предупреждение, что на переменную нет ссылок. Каково булево выражение для
проверки того, что значение переменной i находится в заданном диапазоне значений
(например, определяемом переменными lowVal и hiVal)? Выражением, которое
определяет, находится ли значение переменной i в некотором диапазоне, является
(i >= lowVal && i <= hiVal). Предъявляет ли С++ какие-либо требования на
отступ операторов в предложениях оператора? Нет. Отступ определяется
только Вами. Типовые размеры отступа составляют два или четыре пробела.
Использование отступов делает ваш листинг намного более удобочитаемым. j = 10 - i; Последний
вариант читается много легче; легко указать, где операторы if и else. Более
того, если вы будете работать с вложенными циклами, отступы еще более значимы в
отношении удобочитаемости кода. Здесь существуют два подхода. Первый рекомендует писать
условия так, что true будет чаще, чем false. Второй подход рекомендует избегать
отрицательных выражений (тех, которые используют операции сравнения != и булевы
операции !). в следующую
эквивалентную форму: Как обработать
условие, подобное нижеследующему, где имеется деление на переменную, которая
может оказаться равной нулю? С++ не всегда оценивает проверяемые условия полностью. Эта частичная
оценка происходит, когда член булева выражения превращает все выражение в false
или true, независимо от значения других членов. В этом случае, если переменная i
равна 0, исполняющая система не будет оценивать 1/i > 1, потому что член i !=
0 есть false и обращает в false все выражение, независимо от значения второго
члена. Это называется укороченной оценкой булевых выражений. Действительно
ли необходимо включать предложения else или default в многоальтернативные
операторы if-else и switch? Программисты настоятельно рекомендуют
включение этих всеохватывающих предложений для гарантии того, что
многоальтернативные операторы будут обрабатывать все возможные условия. Однако
технически для компиляции программы это не является необходимым. for (i=1; i<=10; i+=2) { while ( i <= 10) { Циклу while
необходим начальный оператор, инициирующий переменную управления циклом. Заметим
также, что внутри цикла while находится оператор, изменяющий значение переменной
управления циклом. do { while (i <= 10) { Оба цикла имеютодинаковые условия в предложениях
while. Заметим, однако, что если цикл спроектирован таким образом, что
начальное значение i может быть неизвестным заранее, то это может привести к
различным эффектам. Например, если i исходно равно 11, то цикл слева выполнится
один раз, тогда как цикл справа не сделает ни одной итерации. Открытый цикл for
эмулирует другие циклы С++ установкой оператора if выхода из цикла в начале или
конце цикла. Рассмотрим пример эмуляции цикла while открытым циклом for: cout
<< i << endl; cout << i << endl; Заметим, что открытый цикл for использует оператор if выхода из цикла как
первый оператор внутри цикла. Условие, проверяемое оператором if, есть
логическое обращение условия цикла while.
cout << i << endl; cout << i << endl; Открытый цикл for
использует оператор if выхода из цикла перед концом цикла. Оператор if проверяет
обратное логическое условие, так же как в цикле do-while. Однако имейте,
пожалуйста, в виду, что приведенные примеры довольно грубы и неэлегантны. Никто
никогда не будет использовать открытый оператор for подобным образом. Конечно,
можно было бы пропустить одно из трех предложений внутри скобок цикла for
(например, предложение инициализации, если управляющая переменная уже
инициализирована). Открытые циклы for чаще всего используются в случаях, когда
выход из цикла бывает редким событием, например, если при обработке данных,
вводимых пользователем с клавиатуры, нажатие клавиши Esc должно приводить к
выходу из программы. Можно ли во вложенном цикле for использовать
переменную управления внешним циклом в качестве границы диапазона значений для
внутренних циклов? Да. С++ не только не запрещает такое использование, на
самом деле оно в порядке вещей. Рассмотрим простой пример. Нет.
В программе на С++ вы можете вкладывать любые комбинации циклов. В этом разделе описывается структура исходной программы на Си и
определяются термины, используемые в последующих разделах руководства при
описании языка. По сути, здесь представлен общий обзор особенностей языка Си,
которые в дальнейшем рассмотрены в деталях. Исходная
программа- это совокупность следующих объектов: директив, указаний компилятору,
объявлений и определений. Директивы задают действия препроцессора по
преобразованию текста программы перед компиляцией. Указания компилятору- это
команды, выполняемые компилятором во время процесса компиляции. Объявления
задают имена и атрибуты переменных, функций и типов, используемых в программе.
Определения- это объявления, определяющие переменные и функции. Определение
переменной в дополнении к ее имени и типу задает начальное значение объявленной
переменной. Кроме того, определение предполагает распределение памяти для
переменной. Определение функции специфицирует ее структуру, которая
представляет собой смесь из объявлений и операторов, которые образуют саму
функцию. Определение функции также задает имя функции, ее формальные параметры и
тип возвращаемой величины. Исходная программа может содержать любое число
директив, указаний компилятору, объявлений и определений. Любой из объектов
программы имеет определенный синтаксис, описанный в этом руководстве,и каждая
составляющая может появляться в любом порядке, хотя влияние порядка, в котором
следуют переменные и функции может быть использовано в программе (см. раздел 3.5
"Время жизни и видимость"). Нетривиальная программа всегда содержит более
одного определения функции. Функция определяет действия, выполняемые
программой. int y = 2; { printf("z = %d \nw = %d \n", z,
x); Эта исходная программа определяет функцию с именем main и объявляет
функцию printf. Переменные x и y задаются своими определениями. Переменные z и w
только объявляются. В этом разделе описываются форматы и
составные части объявлений переменных, функций и типов. Объявления Си имеют
следующий синтаксис: [<sc-specifier>][<type-
specifier>]<declarator>[=<initializer>]
[,<declarator>[=<initializer>...],
<declarator>- идентификатор, который может быть модифицирован при
объявлении указателя, массива или функции; Все переменные Си должны быть явно объявлены перед их
использованием. Функции Си могут быть объявлены явно или неявно в случае их
вызова перед определением. Язык Си определяет стандартное множество типов
данных. К этому множеству можно добавлять новые типы данных посредством их
объявлений на типах данных уже определенных. Объявление Си требует одного или
более деклараторов. Декларатор- это идентификатор, который может быть определен
с квадратными скобками ([]), эвездочкой (*) или круглыми скобками () для
объявления массива, указателя или функции. Когда об'является простая переменная
(такая как символ, целое или плавающее), структура или совмещение простых
переменных, то декларатор- это идентификатор.
Спецификатор класса памяти определяет, каким образом объявляемый объект
запоминается и инициализируется и из каких частей программы можно ссылаться на
него. Расположение объявления внутри программы, а также наличие или отсутствие
других объявлений- также важные факторы при определении видимости переменных. Перечислимые
типы также рассматриваются как основные типы. Спецификаторы перечислимых типов
рассмотрены в разделе 4.7.1. Типы signed char, signed int, signed short int и
signed long int вместе с соответствующими двойниками unsigned называются типами
целых. Спецификаторы типов float и double относятся к типу "плавающих". В
объявлениях переменых и функций можно использовать любые спецификаторы "целый" и
"плавающий". Тип void может быть использован только для объявления функций,
которые не возвращают значения. Типы функций рассмотрены в разделе 4.4. При записи спецификаторов типов допустимы сокращения как
показано в табл. 4.2. В целых типах ключевое слово signed может быть опущено.
Так, если ключевое слово unsigned опускается в записи спецификатора типа, то тип
целого будет знаковым, даже если опущено ключевое слово signed. В некоторых
реализациях могут быть использованы опции компилятора, позволяющие изменить
умолчание для типа char со знакового на беззнаковый. Когда задана такая опция,
сокращение char имеет то же самое значение, что и unsigned char, и следовательно
ключевое слово sidned должно быть записано при объявлении символьной величины со
знаком. unsigned char unsigned int unsigned Замечание: в этом руководстве в основном используются
сокращенные формы, перечисленные в Табл. 4.2, при этом предполагается, что char
по умолчанию знаковый. В табл. 4.3 для каждого типа приведены: размер
распределяемой памяти и области значений переменных для данного типа. Поскольку
тип void не представляет переменных, он не включен в эту таблицу. unsigned char 1 байт 0 до 255 float 4 байта IEEE стандартное соглашение Тип char используется для запоминания буквы, цифры или
символа из множества представимых символов. Значением объекта типа char является
ASCII код, соответствующий данному символу. Так как тип char интерпретируется
как однобайтовая целая величина с областью значений от -128 до 127, то только
величины от 0 до 127 имеют символьные эквиваленты. Аналогично, тип unsigned char
может запоминать величины с областью значений от 0 до 255. Заметим, что
представление в памяти и область значений для типов int и unsigned int не
определены в языке Си. По умолчанию размер int (со знаком и без знака)
соответствует реальному размеру целого на данной машине. Например, на 16-ти
разрядной машине тип int всегда 16 разрядов или 2 байта. На 32-ух разрядной
машине тип int всегда 32 разряда или 4 байта. Таким образом, тип int
эквивалентен типам short int или long int в зависимости от реализации.
Аналогично, тип unsigned int эквивалентен типам unsigned short или unsigned
long. Спецификаторы типов int и unsigned int широко используются в программах на
Си, поскольку они позволяют наиболее эффективно манипулировать целыми величинами
на данной машине. Однако, размер типов int и unsigned int переменный, поэтому
программы, зависящие от специфики размера int и unsigned int могут быть
непереносимы. Переносимость кода можно улучшить путем включения выражений с
sizeof операцией. <declarator>[constant-expression>] (<declarator>) Си позволяет объявлять: массивы величин,
указатели на величины, величины возвратов функций. Чтобы объявить эти объекты,
нужно использовать декларатор, возможно модифицированный квадратными скобками
([]), круглыми скобками () и звездочкой (*), что соответствует типам массива,
функции или указателя. Деклараторы появляются в объявлениях указателей, массивов
и функций. Когда декларатор
состоит из немодифицируемого идентификатора, то об'ект, который объявляется,
имеет немодифицированный тип. Звездочка, которая может появиться слева от
идентификатора, модифицирует его в тип указателя. Если за идентификатором
следуют квадратные скобки ([]), то тип модифицируется на тип массива. Если за
идентификатором следуют круглые скобки, то тип модифицируется на тип функции.
Сам по себе декларатор не образует полного объявления. Для этого в объявление
должен быть включен спецификатор типа. Спецификатор типа задает тип элементов
массива или тип адресуемых объектов и возвратов функции.
3. double func(void), 3. Функция func без аргументов, возвращающая величину
double Любой декларатор может быть заключен в
круглые скобки. Обычно, круглые скобки используются для спецификации
особенностей интерпретации составного декларатора. Составной декларатор- это
идентификатор, определяемый более чем одним модификатором массива, указателя или
функции. С отдельным идентификатором могут появиться различные комбинации
модификаторов массива, указателя или функции. Некоторые комбинации недопустимы.
Например, массив не может быть композицией функций, а функция не может
возвратить массив или функцию. При интерпретации составных деклараторов
квадратные и круглые скобки (справа от идентификатора) имеют приоритет перед
звездочкой (слева от идентификатора). Квадратные или круглые скобки имеют один и
тот же приоритет и рассматриваются слева направо. Спецификатор типа
рассматривается на последнем шаге, когда декларатор уже полностью
проинтерпретирован. Можно использовать круглые скобки, чтобы изменить порядок
интерпретации на необходимый в данном случае. При интерпретации составных
деклараторов может быть предложено простое правило, которое читается следующим
образом: "изнутри- наружу". Нужно начать с идентификатора и посмотреть вправо,
есть ли квадратные или круглые скобки. Если они есть, то проинтерпретировать эту
часть декларатора, затем посмотреть налево, если ли звездочка. Если на любой
стадии справа встретится закрывающая круглая скобка, то вначале необходимо
применить все эти правила внутри круглых скобок, а затем продолжить
интерпретацию. на последнем шаге интерпретируется спецификатор типа. В следующем
примере проиллюстрированы эти правила. Последовательность шагов при
интерпретации перенумерована. 2. Указатель на 7. Величины типа char. 1.
int *var[5]; - массив указателей на величины типа int. 3. long *var(long,long); - функция,
возвращающая указатель на величину типа long.
int a; 6. double ( *var( double (*)
[3] ) ) [3]; unsigned y; массив указателей на массив указателей на совмещения. В первом примере, модификатор массива имеет высший приоритет, чем
модификатор указателя, так что var объявляется массивом. Модификатор указателя
определяет тип элементов массива; элементами являются указатели на величины типа
int. Во втором примере скобки меняют значение объявления первого примера.
Теперь модификатор указателя имеет более высокий приоритет, чем модификатор
массива, и переменная var объявляется как указатель на массив из пяти величин
типа int. В третьем примере модификатор функции имеет более высокий
приоритет, чем модификатор указателя, так что переменная var объявляется
функцией, возвращающей указатель на величину типа long. Функция объявлена с
двумя аргументами типа long. Четвертый пример похож на второй. Скобки задают
более высокий приоритет модификатору указателя, и поэтому переменная var
объявляется как указатель на функцию, возвращающую величину типа long. По
прежнему функция объявлена с двумя аргументами типа long. Элементы массива не
могут быть функциями. Взамен этому в пятом примере показано, как объявить массив
указателей на функции. В этом примере переменная var объявлена как массив из
пяти указателей на функции, возвращающие структуры с двумя элементами. Оба
аргумента функции объявлены как структуры типа both. Заметим, что круглые
скобки, в которые заключено выражение *var[5], обязательны. Без них объявление
будет неверным, поскольку будет объявлен массив функций: В шестом примере
показано, как объявлять функцию, возвращающую указатель на массив. Здесь var
объявлена функцией, возвращающей указатель на массив из трех величин типа
double. Тип аргумента функции задан составным абстрактным декларатором. Круглые
скобки, заключающие звездочку, требуются, так как в противном случае типом
аргумента был бы массив из трех указателей на величины типа double. В седьмом
примере показано, что указатель может указывать на другой указатель и массив
может состоять из массивов. Здесь var- это массив из пяти элементов. Каждый
элемент, в свою очередь, так же массив из пяти элементов, каждый из которых
является указателем на указатель совмещения, состоящего из двух элементов. смысл объявления. В этом
примере var- это массив из пяти указателей на массив из пяти указателей на
совмещения. В этом разделе дано описание
синтаксиса и семантики объявлений переменной. В частности, здесь объясняется
каким образом объявить следующие переменные: на другую переменную (содержит местоположение другой переменной в
форме адреса). [<sc-
spesifier>] <type-spesifier> <declarator>
[,<declarator>...], где <type- spesifier> - задает тип данных,
представляемых переменной, а <declarator> - это имя переменной, возможно
модифицированное для объявления массива или указателя. В объявлении мо жет быть
задана более чем одна переменная путем задания множественного объявления, в
котором деклараторы разделены запятыми. <sc- spesifier> задает класс
памяти переменной. В некоторых случаях переменные могут быть инициализированы
при их определении. Классы памяти и инициализация описаны в разделах 4.6 и 4.7
соответственно. Объявление простой
переменной определяет имя переменной и ее тип; оно может также определять класс
памяти переменной, как это описано в разделе 4.6. Имя переменной- это
идентификатор, заданный в объявлении. Спецификатор типа <type-specifier>
задает имя определяемого типа данных. Можно определить имена различных
переменных в том же самом объявлении, задавая список идентификаторов,
разделенных запятой. Каждый идентификатор списка именует переменную. Все
переменные, заданные в объявлении, имеют один и тот же тип. В первом примере объявляется простая переменная x. Эта
переменная может принимать любое значение из множества значений, определяемых
для типа int. В третьем примере объявлена переменная
order, которая имеет тип double. Этой переменной могут быть присвоены величины с
плавающей запятой. Синтаксис:
enum[<tag>]{<enum-list>}<identifier>[,<identifier>...];
enum<tag><identifier>[,<identifier>...]; Объявление
перечисления задает имя переменной перечисления и определяет список именованных
констант, называемый списком перечисления. Значением каждого имени списка
является целое число. Переменная перечисления принимает значение одной из
именованных констант списка. Именованные константы списка имеют тип int. Таким
образом, память соответствующая переменной перечисления- это память, необходимая
для размещения отдельной целой величины. Объявление перечисления начинается с
ключевого слова enum и имеет две формы представления. В первой форме
представления имена перечисления задаются в списке перечисления <enum-
list>. Переменную перечисления
именует <identifier>. В объявлении может быть описана более чем одна
переменная перечисления. Во второй форме используется тег перечисления,
который ссылается на тип перечисления. В этой форме объявления список
перечисления не представлен, поскольку тип перечисления определен в другом
месте. Если задаваемый тег не ссылается на уже определенный тип перечисления,
или если именуемый тегом тип находится вне текущей видимости, то выдается
ошибка. <identifier>[=<constant-
expression>][,<identifier> Каждый идентификатор именует элементы перечисления. По
умолчанию первому идентификатору соответствует значение 0, следующий
идентификатор ассоциируется со значением 1 и т. д. Имя константы перечисления
эквивалентно ее значению. Запись =<constant-expression> переопределяет
последовательность значений, заданных по умолчанию. Идентификатор, следующий
перед записью =<constant-expression> принимает значение, задаваемое этим
константным выражением. Константное выражение имеет тип int и может быть
отрицательным. Следующий идентификатор в списке ассоциируется с величиной,
равной <constant-expression>+1, если он явно не задается другой
величиной. Перечисление может содержать повторяющиеся значения
идентификаторов, но каждый идентификатор должен быть уникальным. Кроме того, он
должен быть отличным от всех других идентификаторов перечислений с той же
видимостью. Например, двум различным идентификаторам null и zero может быть
задано значение 0 в одном и том же перечислении. Идентификаторы должны быть
отличны от других идентификаторов с той же самой видимостью, включая имена
обычных переменных и идентификаторы других перечислений. Теги перечислений
должны быть отличны от тегов перечислений, тегов структур и совмещений с той же
самой видимостью. tuesday, enum day today = wednesday; В первом примере определяется
тип перечисления, поименованный day и объявляется переменная workday этого типа
перечисления. С saturday по умолчанию ассоциируется значение 0. Идентификатор
sunday явно устанавливается в 0. Оставшиеся идентификаторы по умолчанию
принимают значение от 1 до 5. Во втором примере переменной today типа enum
day присваивается значение из перечисления. Заметим, что для присваивания
используется имя константы из перечисления. Так как тип перечисления day был
предварительно объявлен, то достаточно сослаться только на тег перечисления. Синтаксис: struct[<tag>]{<member-declaration-
list>}<declarator>[,<declarator>...];
struct<tag><declarator>[,<declarator>...]; Объявление
структуры задает имя типа структуры и специфицирует последовательность
переменных величин, называемых элементами структуры, которые могут иметь
различные типы. Объявление структуры начинается с ключевого слова struct и
имеет две формы представления, как показано выше. В первой форме представления
типы и имена элементов структуры специфицируются в списке объявлений элементов
<member-declaration-list>. <tag>- это идентификатор, который именует
тип структуры, определенный в списке объявлений элементов. Каждый
<declarator> задает имя переменной типа структуры. Тип переменной в
деклараторе может быть модифицирован на указатель к структуре, на массив
структур или на функцию, возвращающую структуру. Вторая синтаксическая форма
использует тег- <tag> структуры для ссылки на тип структуры. В этой форме
объявления отсутствует список объявлений элементов, поскольку тип структуры
определен в другом месте. Определение типа структуры должно быть видимым для
тега, который используется в объявлении и определение должно предшествовать
объявлению через тег, если тег не используется для объявления указателя или
структурного типа typedef. В последних случаях объявления могут использовать тег
структуры без предварительного определения типа структуры, но все же определение
должно находиться в пределах видимости объявления. Список объявлений
элементов <member-declaration-list>- это одно или более объявлений
переменных или битовых полей. Каждая переменная, объявленная в этом списке,
называется элементом структурного типа. Объявления переменных списка имеют тот
же самый синтаксис, что и объявления переменных обсуждаемых в этой главе, за
исключением того, что объявления не могут содержать спецификаторов класса памяти
или инициализаторов. Элементы структуры могут быть любого типа: основного,
массивом, указателем, совмещением или структурой. Элемент не может иметь тип
структуры, в которой он появляется. Однако, элемент может быть объявлен, как
указатель на тип структуры, в которую он входит, позволяя создавать списочные
структуры. <type-specifier>[<identifier>]:<constant-
expression>; Битовое поле состоит из некоторого числа бит, специфицированных
константным выражением- <constant- expression>. Для битового поля
спецификатор типа <type- specifier> должен специфицировать беззнаковый
целый тип, а константное выражение должно быть неотрицательной целой величиной.
Массивы битовых полей, указатели на битовые поля и функции, возвращающие битовые
поля не допускаются. Идентификатор- <identifier> именует битовое поле.
Неименованное битовое поле, чей размер специфицируется как нулевой, имеет
специальное назначение: оно гарантирует, что память для следующей переменной
объявления будет начинаться на границе int. Идентификаторы элементов внутри
объявляемой структуры должны быть уникальными. Идентификаторы элементов внутри
разных структур могут совпадать. В пределах той же самой видимости теги структур
должны отличаться от других тегов (тегов других структур, совмещений и
перечислений). Переменные (элементы) структуры запоминаются последовательно в
том же самом порядке, в котором они объявляются: первой переменной соответствует
самый младший адрес памяти, а последнейсамый старший. Память каждой переменной
начинается на границе свойственной ее типу. Поэтому могут появляться
неименованные участки между соседними элементами. Битовые поля не
располагаются на пересечении границ, обявленных для них типов. Например, битовое
поле, объявленое с типом unsigned int, упаковывается или в пространстве,
оставшимся от предидущего unsigned int или начиная с нового unsigned int. /**************** Example 2 *****************/
/**************** Example 3 ******************/ char c; unsigned icon : 8; В
первом примере объявляется переменная с именем complex типа структура. Эта
структура состоит из двух элементов x и y типа float. Тип структуры не
поименован. Во втором примере объявляется переменная с именем temp типа
структура. Структура состоит из трех элементов с именами name, id и class.
Элемент с именем name- это массив иэ 20- ти элементов типа char. элементы с
именами id и class- это простые переменные типа int и long соответственно.
Идентификатор employee является тегом структуры. В третьем примере объявлены
три переменных типа структура с именами: student, faculty и staff. Каждая из
структур состоит из трех элементов одной и той же конструкции. Элементы
определены при объявлении типа структуры с тегом employee в предыдущем
примере. В четвертом примере объявляется переменная с именем x типа
структура. Первые два элемента структуры представлены переменной c типа char и
указателем pf на величину типа float. Третий элемент с именем next объявляются
как указатель на описываемую структуру sample. В пятом примере объявляется
двумерный массив поименованный screen, элементы которого имеют структурный тип.
Массив состоит из 2000 элементов и каждый элементэто отдельная структура,
состоящая из четырех элементов типа bit-fild с именами icon, color, underline и
blink. Синтаксис: union[<tag>]{<member-
declaration-list>}<declarator>[,<declarator>...];
union<tag><declarator>[,<declarator>...]; Объявление
совмещения определяет имя переменной совмещения и специфицирует множество
переменных, называемых элементами совмещения, которые могут быть различных
типов. Переменная с типом совмещения запоминает любую отдельную величину,
определяемую набором элементов совмещения. Объявление совмещения имеет тот же
самый синтаксис, как и объявление структуры, за исключением того, что она
начинается с ключевого слова union вместо ключевого слова struct. Для объявления
совмещения и структуры действуют одни и те же правила, за исключением того, что
в совмещении не допускаются элементы типа битовых полей. Память, которая
соответствует переменной типа совмещение, определяется величиной для размещения
любого отдельного элемента совмещения. Когда используется наименьший элемент
совмещения, то переменная типа совмещения может содержать неиспользованное
пространство. Все элементы совмещения запоминаются в одном и том же пространстве
памяти переменной, начиная с одного и того же адреса. Запомненные значения
затираются каждый раз, когда присваивается значение очередного элемента
совмещения. } number; /*************** Example 2 *******************/ } screen[25][80]; В первом примере объявляется переменная типа
совмещения, поименованная number. Список элементов совмещения состоит из двух
объявлений переменных: svar типа int и uvar типа unsigned. Это объявление
позволяет запоминать текущее значение number в знаковом или беззнаковом виде.
Тип совмещения поименован идентификатором sign. Во втором примере объявляется
переменная типа совмещения с именем jack. Список элементов объявления состоит из
трех объявлений: указателя a на величину типа char, переменной b типа char и
массива f из 20 элементов типа float. Тип совмещения не поименован. Память,
распределенная для переменной jack, равна памяти, распределенной под массив f,
поскольку f самый большой элемент совмещения. В третьем примере объявляется
двумерный массив совмещений с именем screen. Массив состоит из 2000 объектов.
Каждый объектэто отдельное совмещение из четырех элементов: window1, window2,
window3, window4, где каждый элемент- это структура. В любое заданное время
каждый объект совмещения поддерживается одним из четырех возможных элементов
типа структура. Таким образом, переменная screen- это композиция четырех
возможных"windows". Синтаксис: <type-
specifier><declarator>[<constant-expression>]; <type-
specifier><declarator>[]; Здесь квадратные скобки- это терминальные
символы. Объявление массива определяет тип массива и тип каждого элемента. Оно
может определять также число элементов в массиве. Переменная типа массив
рассматривается как указатель на элементы массива. Объявление массива может
представляться в двух синтаксических формах, указанных выше.
Декларатор<declarator> задает имя переменной. Квадратные скобки, следующие
за декларатором, модифицируют декларатор на тип массива. Константное выражение
<constant-expression>, заключенное в квадратные скобки, определяет число
элементов в массиве. Каждый элемент имеет тип, задаваемый спецификатором типа
<type-specifier>, который может специфицировать любой тип, исключая void и
тип функции. Во второй синтаксической форме опущено константное выражение в
квадратных скобках. Эта форма может быть использована только тогда, когда массив
инициализируется или объявлен как формальный параметр или объявлен как ссылка на
массив, явно определенный где-то в программе. Массив массивов или многомерный
массив определяется путем задания списка константных выражений в квадратных
скобках, следущего за декларатором: Каждое константное выражение- <constant-expression>
в квадратных скобках определяет число элементов в данном измерении массива, так
что объявление двумерного массива содержит два константных выражения,
трехмерного- три и т.д. Если многомерный массив объявляется внутри функции или
если он инициализируется либо объявляется как формальный параметр или
объявляется как ссылка на массив, явно определенный где- то в программе, то
первое константное выражение может быть опущено. Массив указателей на
величины, заданного типа, может быть определен посредством составного
декларатора, как было описано в разделе 4.3.2. Типу массив соответствует
память, которая требуется для размещения всех его элементов. Элементы массива с
первого до последнего запоминаются в последовательных возрастающих адресах
памяти. Между элементами массива в памяти разрывы отсутствуют. Элементы массива
запоминаются друг за другом построчно. Например, массив, содержащий две строки с
тремя столбцами каждая, char A[2][3] будет запомнен следующим образом. Сначала
запоминаются три столбца первой строки, затем элементы трех столбцов второй
строки. Смысл этого в том, чтобы последний индекс был более быстрым. Чтобы
сослаться на отдельный элемент массива, нужно использовать индексное выражение,
которое описано в разделе 5.2.5. /*************** Example 2
******************/ }
complex[100]; В первом примере объявляется переменная типа массив с именем
scores из 10 элементов типа int. Переменная с именем game объявлена как простая
переменная целого типа. В третьем
примере объявляется массив структур. Массив состоит из 100 объектов. Каждый
объект массива представляет собой структуру, состоящую из двух элементов. В
четвертом примере объявлен массив указателей. Массив состоит из 20-ти элементов,
каждый из которых является указателем на величину типа char. Объявление указателя определяет имя переменной типа
указатель и тип объекта, на который указывает эта переменная. Декларатор-
<declarator> определяет имя переменной с возможной модификацией ее типа.
Спецификатор типа- <type- specifier> задает тип объекта, который может
быть базового типа, типа структуры или совмещения. Переменная типа указатель
может указывать также на функции, массивы и другие указатели. Более полная
информация о типах указателей дана в разделе 4.3.2. "Составные деклараторы".
Если указатель не используется до определения типа структуры или совмещения, то
он может быть объявлен ранее этого определения. Такие объявления допускаются,
поскольку компилятору не требуется знать размера структуры или совмещения, чтобы
распределить память под переменную типа указатель. Указатель может быть объявлен
посредством использования тега структуры или совмещения (смотри ниже пример
4). Переменная, объявленная как указатель, хранит адрес памяти. Размер
памяти, требуемый для адреса, и смысл адреса зависит от данной конфигурации
машины. Указатели на различные типы не обязательно имеют одну и ту же длину.
Для некоторых реализаций используются специальные ключевые слова near, far и
huge, чтобы модифицировать размер указателя. Объявления, использующие
специальные ключевые слова, были описаны в разделе 4.3.3. Информация о смысле
ключевых слов дана в системной документации. int *pointers[10]; /* Example 2 */ int (*pointer)[10]; /* Example
3 */ struct list *next, *previous; /* Example 4 */ struct id { /*
Example 6 */ unsigned int id_no; В первом
примере объявляется переменная- указатель поименованная message. Она указывает
на величину типа char. Во втором примере объявлен массив указателей,
поименованный pointers. Массив состоит из 10 элементов. Каждый элемент- это
указатель на переменную типа int. В третьем примере объявлена переменная-
указатель, поименованная pointer. Она указывает на массив из 10 элементов.
Каждый элемент в этом массиве имеет тип int. В четвертом примере объявлены
две переменныхуказателя, которые ссылаются на величины структурного типа list
(смотри следующий пример). Определение типа с именем list должно находиться в
пределах видимости объявления. В пятом примере объявляется переменная с
именем line, структурного типа, поименованного list. Тип структуры с именем list
определяется тремя элементами. Первый элементэто указатель на величину типа
char, второй- на величину типа int, а третийэто указатель на следующую структуру
типа list. В шестом примере объявляется переменная с именем record, имеющая
тип структуры с именем id. Заметим, что третий элемент с именем pname объявлен
как указатель на другой тип структуры с именем name. Это объявление может
появиться перед объявление структуры с именем name. [<type-specifier>]<declarator>([<arg-type-
list>])[,<declarator>...]; Объявление функции определяет имя, тип
возврата функции и, возможно, типы и число ее аргументов. Объявление функции
также называется forward- объявлением. Декларатор функции объявляет имя функции,
а спецификатор типа задает тип возврата. Если спецификатор типа опущен в
объявлении функции, то предполагается, что функция возвращает величину типа
int. Список типов аргументов- <arg-type-
list> определяет число и типы аргументов функции. Синтаксис списка аргументов
следующий: Список имен типов- это список из
одного или более имен типов. Каждое имя типа отделяется от другого запятой.
Первое имя типа задает тип первого аргумента, второе имя типа задает тип второго
аргумента и т. д. Если список имен типов заканчивается запятой с многоточием
(,...), то это означает, что число аргументов функции переменно. Однако,
предполагается, что функция будет иметь не меньше аргументов, чем имен типов,
предшествующих многоточию. Если список типов аргументов- <arg-type-
list> содержит только многоточие (...), то число аргументов функции является
переменным или равно нулю. Чтобы поддержать совместимость с
программами предыдущих версий, компилятор допускает символ запятой без
многоточия в конце списка типов аргументов для обозначения их переменного числа.
Запятая может быть использована и вместо многоточия для объявления нуля или
более аргументов функции. Использование запятой поддерживается только для
совместимости. Использование многоточия рекомендуется для нового
представления. Имя типа- <type- name> для типов структуры, совмещения
или базового типа состоит из спецификатора этого типа (такого как int ). Имена
типов для указателей, массивов и функций формируются путем комбинации
спецификатора типа с "абстрактным декларатором". Абстрактный декларатор- это
декларатор без идентификатора. В разделе 4.9 "Имена типов" объясняется, каким
объразом формировать и интерпретировать абстрактные деклараторы. Для того
чтобы объявить функцию, не имеющую аргументов, может быть использовано
специальное ключевое слово void на месте списка типов аргументов. Компилятор
вырабатывает предупреждающее сообщение, если в вызове такой функции будут
специфицированы аргументы. Еще одна специальная конструкция допускается в
списке типов аргументов. Это фраза void *, которая специфицирует аргумент типа
указатель. Эта фраза может быть использована в списке типов аргументов вместо
имени типа. Список типов аргументов может быть опущен. В зтом случае скобки
после идентификатора функции все же требуются, хотя они и пусты. В этом случае в
объявлении функции не определяются ни типы, ни число аргументов в функции. Когда
эта информация опускается, то компилятор не проверяет соответствия между
формальными и фактическими параметрами при вызове функции. Более подробная
информация дана в разделе 7.4 "Вызовы функций". Функции могут
возвращать величины любого типа за исключением массивов и функций. Для этого
посредством спецификатора типа"type-specifier" в объявлении функции можно
специфицировать любой тип: основной, структуру или совмещение. Идентификатор
функции может быть модифицирован одной или несколькими звездочками (*), чтобы
объявить возвращаемую величину типа указателя. Хотя функции и не допускают
возвратов массивов или функций, но они могут возвращать указатели на массивы или
функции. Функции, которые возвращают указатели на величины типа массив или
функция, объявляются посредством модификации идентификатора функции квадратными
скобками, звездочкой и круглыми скобками, чтобы сформировать составной
декларатор. Формирование и интерпретация составных деклараторов рассматривались
в разделе 4.3.2. char *strfind(char *,...); /* Example 3 */ double (*sum(double, double)) [3]; /* Example 5 */
int (*select(void)) (int) ; /* Example 6 */ В первом примере объявляется функция, поименованная
add, которая требует два аргумента типа int и возвращает величину типа int.
Во втором примере объявляется функция, поименованная calc, которая возвращает
величину типа double. Список типов аргументов не задан. В третьем примере
объявляется функция, поименованная strfind, которая возвращает указатель на
величину типа char. Функция требует, по крайней мере один аргументуказатель на
величину типа char. Список типов аргументов заканчивается запятой с многоточием,
обозначающим, что функция может потребовать большее число аргументов. В
четвертом примере объявляется функция с типом возврата void (нет возвращаемой
величины). Список типов аргументов также void, означающий отсутствие аргументов
для этой функции. В пятом примере sum объявляется как функция, возвращающая
указатель на массив из трех величин типа double. Функция sum требует два
аргумента, каждый из которых является величиной типа double. В шестом примере
функция, поименованная select, объявлена без аргументов и возвращает указатель
на функцию. Указатель возврата ссылается на функцию, требующую один аргумент
типа int и возвращающую величину типа int. В седьмом примере объявлена
функция prt, которая требует аргумент- указатель любого типа, и которая
возвращает величину типа int. Любой указатель p или q могли бы быть использованы
как аргументы функции без выдачи при этом предупреждающего сообщения. Класс памяти переменной, которая определяет какой либо объект,
имеет глобальное или локальное время жизни. Объект с глобальным временем жизни
существует и имеет значение на протяжении всей программы. Все функции имеют
глобальное время жизни. Переменные с локальным временем жизни захватывают
новую память при каждом выполнении блока, в котором они определены. Когда
управление на выполнение передается из блока, то переменная теряет свое
значение. Хотя Си определяет два типа классов памяти, но, тем не менее,
имеется следующих четыре спецификатора классов памяти: Объекты классов auto и register имеют локальное время жизни.
Спецификаторы static и extern определяют объекты с глобальным временем жизни.
Каждый из спецификаторов класса памяти имеет определенный смысл, который влияет
на видимость функций и переменных в той же мере, как и сами классы памяти.
Термин "видимость" относится к той части программы, в которой могут ссылаться
друг на друга функции и переменные. Объекты с глобальным временем жизни
существуют на протяжении выполнения исходной программы, но они могут быть видимы
не во всех частях программы. Видимость и связанная с ней концепция времени жизни
рассмотрена в разделе 3.5. Месторасположение объявления переменной или
функции внутри исходных файлов также влияют на класс памяти и видимость.
Говорят, что объявления вне определения всех функций и переменных относятся к
внешнему уровню, а объявления внутри определений функций относятся к внутреннему
уровню. Точный смысл каждого спецификатора класса памяти зависит от того,
находится ли объявление на внешнем или внутреннем уровне и от того, объявлен ли
объект функцией или переменной. В следующем разделе описывается смысл
спецификаторов класса памяти в каждом случае объявления, а также объясняется
режим умолчания, когда спецификатор класса памяти опущен при объявлении
переменной или функции. Объявления
переменной на внешнем уровне используют спецификаторы класса памяти static и
extern или совсем опускают их. Спецификаторы класса памяти auto и register не
допускаются на внешнем уровне. Объявления переменных на внешнем уровне- это
определения переменных или ссылки на определения, сделанные в другом месте.
Объявление внешней переменной, которое инициализирует эту переменную (явно
или неявно), называется определением этой переменной. Определение на внешнем
уровне может задаваться в следующих различных формах: -переменная на внешнем
уровне может быть определена путем ее объявления со спецификатором класса памяти
static. Такая переменная может быть явно инициализирована константным
выражением. Если инициализатор отсутствует, то переменная автоматически
инициализируется нулем во время компиляции. Таким образом, объявления static int
k = 16; и static int k; оба рассматриваются как определения; -переменная
определяется, когда она явно инициализируется на внешнем уровне. Например, int j
= 3; это определение переменной. Так как переменная определяется на внешнем
уровне, то она видима в пределах остатка исходного файла, от места, где она
определена. Переменная не видима выше своего определения в том же самом исходном
файле ни в других исходных файлах программы, если не объявлена ссылка, которая
делает ее видимой. Переменная может быть определена на внешнем уровне внутри
исходного файла только один раз. Если задается спецификатор класса памяти
static, то в других исходных файлах могут быть определены переменные с тем же
именем. Так как каждое определение static видимо только в пределах своего
собственного исходного файла, то конфликта не возникнет. Спецификатор класса
памяти extern используется для объявления ссылки на переменную, определенную
где-то в другом месте. Такие объявления используются в случае, когда нужно
сделать видимым определение переменной в других исходных файлах или выше места,
где она определена в том же самом исходном файле. Так как ссылка на переменную
объявлена на внешнем уровне, то переменная видима в пределах остатка исходного
файла от места объявления ссылки. В объявлениях, которые используют
спецификатор класса памяти extern, инициализация не допускается, так как они
ссылаются на переменные, чьи величины уже определены. Переменная, на которую
делается ссылка extern, должна быть определена на внешнем уровне только один
раз. Определение может быть сделано в любом из исходных файлов, составляющих
программу. Есть одно исключение из правил, описанных выше. Можно опустить из
объявления переменной на внешнем уровне спецификатор класса памяти и
инициализатор. Например, объявление int n; будет правильным внешним объявлением.
Это объявление имеет два различных смысла в зависимости от контекста. 1. Если
где-нибудь в программе будет определена на внешнем уровне переменная с тем же
именем, то объявление является ссылкой на эту переменную, как если бы был
использован спецификатор класса памяти extern в объявлении. 2. Если нет
такого определения, то объявленной переменной распределяется память во время
линкования и переменная инициализируется нулем. Если в программе появится более
чем одно такое объявление, то память распределится для наибольшего размера из
объявленных переменных. Например, если программа содержит два
неинициализированных объявления переменной i на внешнем уровне int i; и char i;
то память во время линкования распределится под переменную i типа int.
Неинициализированные объявления переменной на внешнем уровне не рекомендуются
для файлов, которые могут быть размещены в библиотеку. SOURCE FILE ONE
*****************************************************/ printf("%d\n", i);
/* i equals 4 */ other();
*****************************************************/
printf("%d\n", i); /* i equals 6 */ Два исходных файла в совокупности
содержат три внешних объявления i. Одно объявление содержит инициализацию- int i
= 3; , где глобальная переменная i определена с начальным значением равным 3. Без объявления extern функция main не
смогла бы сослаться на глобальную переменную i. Объявление extern переменной i
во втором исходном файле делает глобальную переменную видимой в этом исходном
файле. Все три функции выполняют одну и ту же задачу: они увеличивают i на 1
и печатают получившееся значение. (Предполагается, что функция printf определена
где-то еще в программе.). Печатаются величины равные 4, 5 и 6. Если бы
переменная i не была бы инициализирована,она бы была автоматически установлена в
0 при линковании. В этом случае напечатанные значения были бы равны 1, 2 и
3. Любой из четырех
спецификаторов класса памяти может быть использован для объявления переменной на
внутреннем уровне. Если спецификатор класса памяти опускается в объявлении
переменной на внутреннем уровне, то подразумевается класс памяти auto.
Спецификатор класса памяти auto объявляет переменную с локальным временем
жизни. Переменная видима только в том блоке, где она объявлена. Объявления
переменных auto могут включать инициализаторы. Переменные класса памяти auto
автоматически не инициализируются, а инициализируются явно при объявлении или
присваивании начальных значений, посредством операторов внутри блока. Если нет
инициализации, то величина переменной auto считается неопределенной.
Спецификатор класса памяти register сообщает компилятору о том, чтобы он
распределил память под переменную в регистре, если это возможно. Использование
регистровой памяти обычно приводит к более быстрому времени доступа и к меньшему
размеру результирующего кода. Переменные, объявленные с классом памяти register
имеют ту же самую видимость, что и переменные auto. Число регистров, которое
может быть использовано под память переменных, зависит от машины. Когда
компилятор встречает спецификатор класса памяти register в объявлении, а
свободного регистра не имеется, то для переменной распределяется память класса
auto. Компилятор назначает переменным регистровую память в том порядке, в
котором появляются объявления в исходном файле. Регистровая память, если она
имеется, гарантирована только для целого и адресного типов. Переменная,
объявленная на внутреннем уровне со спецификатором класса памяти static,имеет
глобальное время жизни и имеет видимость только внутри блока, в котором она
объявлена. В отличие от переменных auto, переменные, объявленные как static,
сохраняют свое значение при завершении блока. Переменные класса памяти static
могут быть инициализированы константным выражением. Если явной инициализации
нет, то переменная класса памяти static автоматически устанавливается в 0.
Инициализация выполняетсяодин раз во время компиляции. Инициализация переменной
класса памяти static не повторяется при новом входе в блок. Переменная,
объявленная со спецификатором класса памяти extern, является ссылкой на
переменную с тем же самым именем, определенную на внешнем уровне в любом
исходном файле программы. сделать определение переменной внешнего уровня видимой внутри блока.
Внутреннее об'явление extern не изменяет видимость глобальной переменной в любой
другой части программы. /* initial value is zero; a is /* default storage class is auto */ other() a += 2; Переменная i
определяется на внешнем уровне с инициализацией 1. В функции main объявлена
ссылка extern на переменную i внешнего уровня. Переменная класса памяти static
автоматически устанавливается в 0, так как инициализатор опущен. Вызов функции
print (предполагается, что функция print определена в каком-то месте исходной
программы.) печатает величины 1, 0, 0, 0. В функции other, переменная i
переопределяется как локальная переменная с начальным значением 16. Это не
влияет на значение внешней переменной i. Переменная a объявляется как переменная
класса памяти static с начальным значением 2. Она не противоречит переменной a,
объявленной в функции main, так как видимость переменных класса памяти static на
внутреннем уровне ограничена блоком, в котором она объявлена. Значение
переменной увеличивается на 2 и становится равным 4. Если бы функция other была
вызвана снова в той же самой программе, то начальное значение a стало бы равным
4. Внутренние переменные класса памяти static сохраняют свои значения, когда
заканчивается выполнение блока, в котором они объявлены. Функции могут быть объявлены со
спецификаторами класса памяти static или extern. Функции всегда имеют глобальное
время жизни. Правила видимости для функций отличаются от правил видимости для
переменных. Объявления функций на внутреннем уровне имеют тот же самый смысл,
что и объявления на внешнем уровне. Это значит, что функции не могут иметь
блочной видимости и видимость функций не может быть вложенной. Функция
объявленная как static, видима только в пределах исходного файла, в котором она
определяется. Любая функция в том же самом исходном файле может вызвать функцию
static, но функции static из других файлов нет. Функция static с тем же самым
именем может быть объявлена в другом исходном файле. Функции, объявленные как
extern видимы в пределах всех исходных файлов, которые составляют программу.
Любая функция может вызвать функцию extern.
Инициализация В объявлении переменной может быть присвоено начальное значение
посредством инициализатора. Величина или величины инициализатора присваиваются
переменной. Могут быть инициализированы переменные любого
типа. Функции не инициализируются. Объявления, которые используют спецификатор
класса памяти extern не могут содержать инициализатора. Переменные,
объявленные на внешнем уровне, могут быть инициализированы. Если они явно не
инициализированы, то они устанавливаются в нуль во время компиляции или
линкования. Любая переменная, объявленная со спецификатором класса памяти
static, может быть инициализирована константным выражением. Инициализация
переменных класса static выполняется один раз во время компиляции. Если
отсутствует явная инициализация, то переменные класса памяти static
автоматически устанавливаются в нуль. Инициализация переменных auto и
register выполняется каждый раз при входе в блок, в котором они объявлены. Если
инициализатор опущен в объявлении переменной класса памяти auto или register, то
начальное значение переменной не определено. Инициализация составных типов auto
(массив, структура, совмещение) запрещена. Любое составное объявление класса
памяти static может быть инициализировано на внешнем уровне. Начальными
значениями для внешних объявлений переменной и для всех переменных static как
внешних так и внутренних должно быть константное выражение. Автоматические и
регистровые переменные могут быть инициализированы константными или переменными
величинами. Величина выражения присваивается переменной. Для
выражения допустимы правила преобразования.
| |
