M. УЭИТ - Язык Си - руководство для начинающих
{
extern int units;
printf (" He повезло, дружок. Попытайся снова.n");
scanf (" %d" , &units);
}
Вот полученный результат:
Сколько фунтов масла находится в бочонке?
14
Не повезло, дружок. Попытайся снова.
56
Вы должны поискать в справочнике!
(Мы сделали это.)
Обратите внимание, что второе значение units было прочитано функцией critic( ), однако main() также "узнала" это новое значение, когда оно вышло из цикла while.
Мы сделали переменную units внешней, описав ее вне любого определения функции. Далее, внутри функций, использующих эту переменную, мы объявляем ее внешней при помощи ключевого слова extern, предшествующего спецификации типа переменной. Слово extern предлагает компьютеру искать определение этой переменной вне функции. Если бы мы опустили ключевое слово extern в функции critic( ), то компилятор создал бы в функции critic новую переменную и тоже назвал бы ее units. Тогда другая переменная units() [которая находится в main()] никогда не получила бы нового значения.
Каждая переменная, как мы знаем, имеет тип. Кроме того, каждая переменная принадлежит к некоторому классу памяти. Есть четыре ключевых слова, используемые для описания классов памяти: extern (для внешнего), auto (для автоматического), static и register. До сих пор мы не обращали внимание на классы памяти, так как переменные, описанные внутри функции, считались относящимися к классу auto, если они не описывались иначе (по умолчанию они относились к классу auto).
Определение класса памяти переменной зависит oт того, где переменная описана и какое ключевое слово (если оно есть) используется.
Класс памяти позволяет установить два факта. Во-первых, определить, какие функции имеют доступ к переменной. (Пределы, до которых переменная доступна, характеризуют ее "область действия".) Во-вторых, определить, как долго переменная находится в памяти. Теперь перейдем к свойствам каждого типа.
Автоматические переменные
По умолчанию переменные, описанные внутри функции, являются автоматическими. Можно, однако, это подчеркнуть явно с помощью ключевого слова auto:
main( )
{
auto int plox;
Так поступают, если хотят, например, показать, что определение переменной не нужно искать вне функции.
Автоматические переменные имеют локальную область действия. Только функция, в которой переменная определена, "знает" ее. (Конечно, можно использовать аргументы для связи значения и адреса переменной с другой функцией, однако это частичное и косвенное "знание".) Другие функции могут использовать переменные с тем же самым именем, но это должны быть независимые переменные, находящиеся в разных ячейках памяти.
Автоматическая переменная начинает существовать при вызове функции, содержащей ее. Когда функция завершает свою работу и возвращает управление туда, откуда ее вызвали, автоматическая переменная исчезает. Ячейка памяти может снова использоваться для чего-нибудь другого.
Следует еще сказать об области действия автоматической переменной: область действия ограничена блоком ({ }), в котором переменная описана. Мы всегда должны описывать наши переменные в начале тела функции (блока), так что областью действия их является вся функция. Однако в принципе можно было бы описать переменную внутри подблока. Тогда переменная будет известна только в этой части функции. Обычно при создании программы, программисты редко принимают во внимание упомянутое свойство. Но иногда торопливые программисты пользуются такой возможностью, особенно когда пытаются быстрее внести коррективы.
Внешние переменные
Переменная, описанная вне функции, является внешней. Внешнюю переменную можно также описать в функции, которая использует ее, при помощи ключевого слова extern. Описания могут выглядеть примерно так:
int errupt; /* Три переменные, описанные вне функции */
char coal;
double up;
main( )
{
extern int errupt; /* объявлено, что 3 переменные */
extern char coal; /* являются внешними */
extern double up;
Группу extern-описаний можно совсем опустить, если исходные определения переменных появляются в том же файле и перед функцией, которая их использует. Включение ключевого слова extern позволяет функции использовать внешнюю переменную, даже если она определяется позже в этом или другом файле. (Оба файла, конечно, должны быть скомпилированы, связаны или собраны в одно и то же время.)
Если слово extern не включено в описание внутри функции, то под этим именем создается новая автоматическая переменная. Вы можете пометить вторую переменную как "автоматическую" с помощью слова auto и тем самым показать, что это ваше намерение, а не оплошность. Три примера демонстрируют четыре возможных комбинация описаний:
/* Пример1 */
int hocus;
main( ) {
extern int hocus; /* hocus описана внешней */
...
}
magic( ) {
extern int hocus;
...
}
Здесь есть одна внешняя переменная hocus, и она известна обеим функциям main( ) и magic( ).
/* Пример2 */
int hocus ;
main( )
{
extern int hocus; /* hocus описана внешней */
...
}
magic( )
{
/* hocus не описана совсем */
...
}
Снова есть одна внешняя переменная hocus, известная обеим функциям. На этот раз она известна функцииmagic( ) по умолчанию.
/* Пример3 */
int hocus;
main( )
{
int hocus; /* hocus описана и
является автоматической по умолчанию */
...
}
magic( )
{
auto int hocus; /* hocus описана автоматической */
...
}
В этом примере созданы три разные переменные с одинаковым именем. Переменная hocusв функции main( )является автоматической по умолчанию и локальной для main( ), в функции magic( )она явно описана автоматической и известна только для magic( ). Внешняя переменная hocus неизвестна ни main( ), ни magic( ), но обычно известна любой другой функции в файле, которая не имеет своей собственной локальной переменной hocus.
Эти примеры иллюстрируют область действия внешних переменных. Они существуют, пока работает программа, и так как эти переменные доступны любой функции, они не исчезнут, если какая-нибудь одна функция закончит свою работу.
Статические переменные
Название раздела не следует понимать буквально, т. е. считать, что такие переменные не могут изменяться. В действительности слово "статические" здесь означает, что переменные остаются в работе. Они имеют такую же область действия, как автоматические переменные, но они не исчезают, когда содержащая их функция закончит свою работу. Компилятор хранит их значения от одного вызова функции до другого. Следующий пример иллюстрирует это и показывает, как описать статическую переменную.
/* статическая переменная */
main( )
{
int count;
for (count = 1; count <= 3; count++)
{
printf(" Итерация %d:n", count);
trystat( );
}
}
trystat( )
{
int fade = 1;
static int stay; = 1;
printf("fade = %d и stay = %dn", fade++, stay++);
}
Заметим, что функция trystat( ) увеличивает каждую переменную после печати ее значения. Работа этой программы даст следующие результаты:
Итерация 1:
fade = 1 и staly = 1
Итерация 2:
fade = 1 и stay = 2
Итерация 3:
fade = 1 и stay = 3
Статическая переменная stay"помнит", что ее значение было увеличено на 1, в то время как для переменной fade начальное значение устанавливается каждый раз заново. Это указывает на разницу в инициализации: fade инициализируется каждый раз, когда вызывается trystat( ), в то время как stay инициализируется только один раз при компиляции функции trystat( ).
