Урок №15. Локальная область видимости

Из предыдущих уроков мы знаем, что при выполнении процессором оператора int х; создается переменная. Возникает вопрос: "Когда происходит уничтожение этой переменной?".

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

Давайте изучим следующий код:

#include

int add ( int a , int b ) // здесь создаются переменные a и b

{

// a и b можно видеть/использовать только внутри этой функции

return a + b ;

} // здесь a и b выходят из области видимости и уничтожаются

int main ( )

{

int x = 7 ; // здесь создается и инициализируется переменная x

int y = 8 ; // здесь создается и инициализируется переменная y

// x и y можно использовать только внутри функции main()

std :: cout << add ( x , y ) << std :: endl ; // вызов функции add() с a = x и b = y

return 0 ;

} // здесь x и y выходят из области видимости и уничтожаются

При вызове функции add() создаются параметры a и b, которые используются и уничтожаются внутри этой функции после ее выполнения.

Локальные переменные x и y, объявленные в функции main(), существуют только в пределах этой функции и уничтожаются после ее завершения.

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

Всё закончено!

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

Локальная область видимости предотвращает возникновение конфликтов имен

Как видно из данного примера, переменные x и y имеют свои особенности, которые отличают их от переменных a и b.

Давайте теперь изучим следующий код:

#include

int add ( int a , int b ) // здесь создаются переменные a и b функции add()

{

return a + b ;

} // здесь a и b функции add() выходят из области видимости и уничтожаются

int main ( )

{

int a = 7 ; // здесь создается переменная a функции main()

int b = 8 ; // здесь создается переменная b функции main()

std :: cout << add ( a , b ) << std :: endl ; // значения переменных a и b функции main() копируются в переменные a и b функции add()

return 0 ;

} // здесь a и b функции main() выходят из области видимости и уничтожаются

В данном случае были изменены наименования переменных x и y в функции main() на a и b. Программа продолжает работать правильно, несмотря на то, что функция add() также использует переменные a и b. Почему же здесь нет конфликта имен? Все дело в том, что переменные a и b, принадлежащие функции main(), являются локальными и не видны функции add(), так же как переменные a и b из функции add() не видны функции main(). Ни add(), ни main() не осведомлены о том, что у них есть переменные с одинаковыми именами!

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

Соглашение: Идентификаторы, применяемые внутри функции (включая аргументы), ограничены доступом только в пределах данной функции.

Тест

#include

void doMath ( int a )

{

int b = 5 ;

std :: cout << "doMath: a = " << a << " and b = " << b << std :: endl ;

a = 4 ;

std :: cout << "doMath: a = " << a << " and b = " << b << std :: endl ;

}

int main ( )

{

int a = 6 ;

int b = 7 ;

std :: cout << "main: a = " << a << " and b = " << b << std :: endl ;

doMath ( a ) ;

std :: cout << "main: a = " << a << " and b = " << b << std :: endl ;

return 0 ;

}