Существует два основных вида области видимости: локальная область видимости и глобальная область видимости.
Переменная, объявленная внутри какой-либо функции, является локальной. Область видимости локальной переменной ограничена пределами функции, внутри которой она объявлена. Локальная переменная может быть проинициализирована при помощи любого выражения. Инициализация локальной переменной производится каждый раз при вызове соответствующей функции. Локальные переменные располагаются во временной области памяти соответствующей функции.
Область действия (или область видимости) переменной – это часть программы, в которой на переменную можно сослаться. Переменные, объявленные внутри блока (на внутреннем уровне), имеют областью действия блок. Область действия блок начинается объявлением переменной и заканчивается конечной правой фигурной скобкой.
Локальные переменные, объявленные в начале функции, имеют область действия блок так же, как и параметры функции, являющиеся локальными переменными. Любой блок может содержать объявления переменных. Если блоки вложены и идентификатор во внешнем блоке имеет такое же имя, как идентификатор во внутреннем блоке, идентификатор внешнего блока «невидим» (скрыт) до момента завершения работы внутреннего блока.
38 Область видимости. Локальная, глобальная и встроенная области видимости Python
Глобальные переменные создаются путем размещения их объявлений вне описания какой-либо функции. Глобальные переменные определяются на том же уровне, что и функции, т. е. не локальны ни в каком блоке.
Область видимости глобальных переменных — вся программа, глобальные переменные доступны из всех функций, определенных в программе. Инициализируются нулем, если явно не задано другое начальное значение. Глобальная переменная может быть проинициализирована только соответствующей ее типу константой либо константным выражением.
Инициализация глобальных переменных производится однократно сразу после загрузки программы в память клиентского терминала.
Переменная, объявленная вне всех функций, помещается в глобальную область видимости. Доступ к таким переменным может осуществляться из любого места программы. Такие переменные располагаются в глобальном пуле памяти, поэтому время их жизни совпадает со временем жизни программы.
Переменная, объявленная внутри блока (часть кода, заключенная в фигурные скобки), принадлежит локальной области видимости. Такая переменная не видна (поэтому и недоступна) за пределами блока, в котором она объявлена. Самый распространенный случай локального объявления – переменная, объявленная внутри функции. Переменная, объявленная локально, располагается на стеке, и время жизни такой переменной совпадает со временем жизни функции.
Так как областью видимости локальной переменной является блок, в котором она объявлена, то существует возможность объявлять переменные с именем, совпадающим с именами переменных, объявленных в других блоках; а также объявленных на более верхних уровнях, вплоть до глобального.
Ее область видимости – только цикл for, за пределами этого цикла действует другая переменная с тем же именем, объявленная в начале функции. Кроме того, в теле цикла объявлена переменная k, областью видимости которой является тело цикла.
Область видимости. Глобальные переменные и локальные переменные. C++ для начинающих. Урок #37
Локальные переменные можно объявлять со спецификатором доступа static. В этом случае компилятор располагает такую переменную в глобальном пуле памяти. Поэтому, время жизни статической переменной совпадает со временем жизни программы. При этом область видимости такой переменной ограничивается пределами блока, в котором она объявлена.
Источник: studfile.net
Переменные область видимости которых распространяется на всю программу называются
Каждая переменная имеет определенную область видимости (scope). Область видимости представляет участок программы, в рамках которого можно использовать переменную.
Переменные бывают глобальными и локальными или автоматическими.
Локальные автоматические переменные
Локальные переменные определяются внутри блока кода (например, внутри функции) и существуют только в рамках этого блока. Эти переменные характеризуются автоматическим временем жизни: при входе в блок для этих переменных выделяется память (которую еще называют автоматическая память), а после завершения работы этого блока, выделенная память освобождается, а объекты удаляются.
#include void printn() < int n = 63; printf(«n=%d n», n); >int main(void) < int a = 2; printn(); // n=63 //n++; так сделать нельзя, так как n определена в функции printn printf(«a=%d n», a); // a=2 return 0; >
Здесь в функции printn определена автоматическая переменная n. В функции main определена автоматическая переменная a. При вне своих функций переменные недоступны. Например, мы не можем использовать переменную n в функции main, так как ее область видимости ограничена функцией printn.
То же самое касается переменных, которые определены во вложенных блоках кода, например, условных конструкциях if..else, switch..case, циклах for,while, do..while. Например:
void printn() < < int n = 20; // локальная переменная printf(«%d n», n); >printf(«%d n», n); // Ошибка — здесь переменная n не видна >
Здесь переменная n по прежнему является локальной и автоматической. Но она определена не просто в функции, а в блоке кода внутри функции. И вне этого блока кода даже внутри функции ее нельзя использовать, потому что после завершения блока кода она удаляется.
Глобальные переменные
Глобальные переменные определены в файле программы вне любой из функций и могут использоваться любой функцией из этого файла.
#include int n = 5; void printn() < n++; printf(«n=%d n», n); >int main(void) < printn(); // n=6 n++; printf(«n=%d n», n); // n=7 return 0; >
Здесь переменная n является глобальной и доступна из любой функции. При этом любая функция может изменить ее значение.
Сокрытие переменных
Автоматические переменные, определенные внутри блока кода, могут скрывать внешние переменные с тем же именем:
#include int n = 5; int main(void) < int n = 10; printf(«n=%d n», n); // n=10 < int n = 20; printf(«n=%d n», n); // n=20 >return 0; >
Здесь определено три переменных с именем n . Автоматическая переменная n, определенная на уровне функции main ( int n = 10; ) скрывает глобальную переменную n. А переменная n, определенная на уровне блока, скрывает переменную, определенную на уровне функции main.
Статические переменные
Кроме глобальных и автоматических есть особый тип переменных — статические переменные . Они определяются на уровне функций с помощью ключевого слово static . Если автоматические переменные определяются и инициализируются при каждом входе в функцию, то статические переменные инициализируются только один раз, а при последующих вызовах функции используется старое значение статической переменной.
Например, пусть у нас будет функция со стандартной автоматической переменной:
#include void display() < int i = 0; i++; printf(«i=%d n», i); >int main(void)
Функция display вызывается три раза, и при каждом вызове программа повторно будет выделять память для переменной i, которая определена в функции. А после завершения работы display, память для переменной i будет освобождаться. Соответственно ее значение при каждом вызове будет неизменно:
i=1 i=1 i=1
Теперь сделаем переменную i статической:
#include void display() < static int i = 0; i++; printf(«i=%d n», i); >int main(void)
К переменной был добавлено ключевое слово static, поэтому при завершении работы функции display переменная не уничтожается, ее память не очищается, наоборот, она сохраняется в памяти. И соответственно результат работы программы будет иным:
i=1 i=2 i=3
Регистровые переменные
Регистровые переменные фактически являются также автоматическими переменные, но при их определении используется ключевое слово register . Это слово сообщает компилятору, что данная переменная будет интенсивно использоваться в приложении, поэтому ее желательно поместить в регистр процессора, что увеличит быстродействие.
Ключевое слово register применяется к переменным:
register int x = 8;
И к параметрам функции:
void display(register int a)
Однако использование слова register еще не является гарантией, что переменная действительно будет помещена в регистр, так как много зависит от аппаратной части компьютера и установленных для нее ограничений. В то же время если аппаратные возможности не поддерживают регистровых переменных, то слово register просто будет игнорироваться, и его использование не вызовет ошибку.
Источник: metanit.com
# Статические и динамические области видимости
Область видимости переменной x это область программы в которой использование имени x ссылается на объявление этой переменной. Одна из причин использование областей видимости — сохранить переменные в разных частях программы отличными друг от друга. Количество коротких имён для переменных ограничено и программисты используют общепринятые имена (например i для индекса массива). В любой программе среднего размера одинаковые названия переменных используются в разных частях программы.
Области видимости делятся на два вида: статические и динамические.
# Статические области видимости
Статические области видимости (Static scoping) так же называются лексическими областями видимости (Lexical scoping). В этих областях видимости имена переменных всегда ссылаются на окружение более верхнего уровня. Это свойство текста программы и не связано со стеком вызовов во время выполнения. Статические области видимости упрощают написание модульного кода, так как программист вычисляет область видимости просто смотря на код. В отличии от этого, динамические области видимости требуют от разработчика учитывать все возможные варианты динамического контекста.
В большинстве языков программирования, включая C, C++ и Java, используются статические области видимости: привязка переменных может быть определена по тексту программы и не зависит от стека вызовов функций во время выполнения.
Для примера рассмотрим программу написанную ниже. Программа выводит 10, так как значение возвращаемое f() не зависит от того откуда вызвана функция ( g() вызывает её и имеет свою переменную x со значением 20). f() всегда возвращает значение глобальной переменной x .
// программа на C демонстрирующая статические области видимости #include int x = 10; // Вызывается из g() int f() < return x; >// g() содержит переменную с именем x и вызывает f() int g() < int x = 20; return f(); >int main() < printf(«%d», g()); // 10 printf(«n»); return 0; >
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
В примере компилятор сначала ищет переменную в текущем блоке, затем в глобальных переменных.
# Динамические области видимости
Динамическими области видимости необычны для современных языков программирования: каждый идентификатор имеет глобальный стек привязок и при поиске значения используется самая последняя привязка. Другими словами, сначала компилятор ищет имя в текущем блоке, а затем последовательно во всех вызвавших текущий блок функциях.
// Так как динамические области видимости необычны // мы рассмотрим следующий псевдокод. Он выведет 20 // на языке с динамическими областями видимости int x = 10; // Called by g() int f() < return x; >// g() содержит переменную с именем x и вызывает f() int g() < int x = 20; return f(); >main() < printf(g()); // 20 >
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Статические vs динамические
В большинстве языков программирования используются статические области видимости: код легче понимать, достаточно посмотреть на текст программы чтобы понять область видимости переменной.
При использовании динамических областей видимости недостаточно знать где написан код, нужно знать как он запускается. Каждый раз при запуске функции создаётся новая область видимости.
Perl поддерживает как статические так и динамические области видимости. Ключевое слово my определяет статическую область видимости локальной переменной, а ключевое слово local динамическую область видимости локальной переменной.
# Код на Perl демонстрирующий динамическую область видимости $x = 10; sub f < return $x; >sub g < # Так как используется local, переменная x в динамической области видимости local $x = 20; return f(); >print g().»n»; # 20
Источник: way23.ru