Локальные переменные

Локальные переменные объявлены внутри функций и видны только в них самих:

void f1 ()

{

int a; // объявление переменной

f2();

}

void f2 ()

{

a = 3; // ошибка, отсутствует объявление переменной

}

У каждой функции есть своя область видимости. В область видимости функции входят все глобальные переменные и переменные объявленные в этой функции.

Механизм передачи значений через аргументы и return предназначен как раз для локальных переменных:

int x; // глобальная переменная

void f1 ()

{

int a = 5;

int b = 3;

int t = 1;

x = 5;

int c = f2(b,a);

}

int f2(int a, int t)

{

int b = 1;

return a+t+x;

}

Обе функции видят переменную x, т.к. она глобальная.

У каждой функции свои переменные a,b,t. У f1 a=5,b=3,t=1, а у f2 a=3,t=5,b=1. Несмотря на то, что у этих функций есть переменные с одинаковыми идентификаторами, это всё-таки совершенно разные переменные. Будьте бдительны!

Переменной c будет присвоено значение 13.

Статические локальные переменные

Обычные локальные переменные, когда функция завершается, уничтожаются. И при каждом выполнении функции, они создаются заново:

void simple_function ()

{

int a = 0;

a = a + 1;

}

В данном примере, сколько бы раз не вызывалась функция, переменная a никогда не станет больше единицы.

Статические переменные определяются только один раз - когда функция вызывается в первый раз. Когда функция заканчивает выполнение операторов, статические переменные остаются в памяти. Когда функция снова вызывается, она продолжает их использовать:

int simple_function()

{

static int a = 0;

a = a + 1;

return a;

}

int main ()

{

int a = 0;

a = simple_function();

cout << a; // 1

a = simple_function();

cout << a; // 2

a = simple_function();

cout << a; // 3

return 0;

}

Передача аргументов по значению (pass-by-value)

Рассмотрим пример:

int simple_function(int); // прототип ф-ии

int main()

{

int x = 4; // переменная x в вызывающем окружении

int y;

y = simple_function(x); // возвращаемое значение ф-ии присваивается переменной y

cout << x; // 4

return 0;

}

int simple_function(int x) // переменная x в функции

{

x = x + 5;

return x;

}

В main мы объявляем две переменные, одной присваиваем значение. Затем вызываем функцию и передаём ей переменную x. Управление передаётся функции и начинается выполнение тела ф-ии.

Обратите внимание, что в заголовке и теле функции используется переменная x. Но это не та переменная, которая объявлена в вызывающем окружении.

Когда после вызова функции мы выводим значение x, на экране появляется 4, а не 9.

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

Запомните, две переменные: переменная-аргумент из вызывающего окружения и переменная-параметр функции - две совершенно разные переменные, хранящиеся в разных участках памяти. Если вы измените переменную в функции, то это не значит что изменится и переменная из вызывающего окружения.

Вот этот механизм и называется передачей по значению (pass-by-value). Мы передаём не саму переменную, а её значение. При этом происходит создание ещё одной переменной того же типа и в неё помещается такое же значение.

Тут вот на какой момент стоит обратить внимание: внутри функции мы не можем работать с внешними переменными (за исключением глобальных), они не видны из функции! Мы можем работать только со значениями тех, которые мы передали в функцию в виде аргументов.