Область видимости переменных.

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

Переменные по области видимости делятся на два типа:

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

• глобальные, когда переменная объявляется вне всех функций, в таком случае она доступна ото всюду[1][неавторитетный источник?].

Область видимости переменной может задаваться с помощью классов памяти или пространства имён.

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

Первый вариант – глобальная переменная. Глобальная переменная объявляется один раз и действует по всей программе

Код C++ Глобальная переменная

#include <conio.h>

#include <iostream.h>

void main(); //Прототип функции main

void sum(); //Прототип функции sum

//Обратите внимание, что переменные объявляются вне функций

int i=100; //Глобальная переменная i. При объявлении запоминаем в i некоторое значение

int a; //Глобальная переменная a

void main()

{

clrscr();

a=200;//так как a была объявлена вне функции - она глобальная и значит доступна по всему коду

sum(); //Вызываем некоторую функцию

return;

}

void sum()

{

cout<<i<<endl; //Выводим значение переменной i на экран = 100

cout<<a<<endl;//Выводим значение переменной a на экран = 200. Значение 200 было записано в main

cout<<i+a<<endl; //Выводим значение i+a на экран = 300

getch();

return;

}

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

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

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

Код C++ Локальная переменная

#include <conio.h>

#include <iostream.h>

void main(); //Прототип функции main

void sum(); //Прототип функции sum

void main()

{

int a; //Объявили переменную внутри main, т.е. объявили локально

a=200; //Переменная объявленная внутри main доступна только и только внутри main

return;

}

void sum()

{

int i;//Объявили переменную i внутри sum. Другими словами объявили локальную переменную i

cout<<i<<endl; //Выводим на экран i

cout<<a<<endl; //Тут должна быть ошибка

cout<<i+a<<endl;

getch();

return;

}

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

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

Код C++ Локальная переменная затеняет глобальную

#include <conio.h>

#include <iostream.h>

void main(); //Прототип функции main

void sum(); //Прототип функции sum

void new_fun(); //Прототип функции new_fun

int i=100; //Глобальная переменная i

void main()

{

cout<<i<<endl; //В этом случае i глобальная, т.к. внутри main i объявлено не было i=100;

sum(); //Вызывам некоторую функцию

new_fun(); //Вызываем некоторую функцию

getch();

return;

}

void sum()

{

int i=20;//Переменная i локальная т.к. объявлена внутри sum. Действует только внутри sum

cout<<i<<endl; //Выводим на экран i. Локальная i затенила глобальную (действующая i=20). Глобальная i висит в памяти

return;

}

void new_fun() //Внутри new_fun переменных не объявлено, значит для new_fun существуют только глобальные переменные

{

cout<<i<<endl; //Выводм на экран глобальную i (i=100)

return;

}

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

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

Код C++ Глобальный оператор разрешения

#include <conio.h>

#include <iostream.h>

int i=100;//Глобальная переменная i

void main()

{

clrscr();

int i=50; //Локальная переменная i

cout<<i<<endl; //Обращение к локальной переменной (i=50)

cout<<::i<<endl; //Обращение к глобальной переменной (i=100) Использован глобальный оператор разрешения

getch();

return;

}

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

• Локальная переменная – такая переменная, которая объявляется внутри функции и действует она только внутри своей функции (видима только своей функции)

• Глобальная переменная – такая переменная, которая объявлена вне функции и доступна она для окончания работы программы (видима всей программе)

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

Не нашли, что искали? Воспользуйтесь поиском: