2.3. Локальные и глобальные переменные
На первый взгляд применение функций должно привести возникновению дополнительных проблем с именами переменных. В самом деле, можно случайно назвать разные переменные в разных функции одинаковыми именами. При этом изменение одной должно вести к изменению другой, что является источником ошибок. На самом деле ничего подобного не происходит. Переменные с одинаковыми именами в разных функциях рассматриваются компилятором как разные переменные.
Переменные объявленные в функции называются локальными. Остальные функции, включая main() их просто не видят. Кстати сказать, что в функции main() наряду с другими переменными тоже есть локальные переменные. Принято говорить, что область видимости таких переменных распространяется на данную функцию.
Приведем пример программы в которой в разных функциях используются одноименные переменные n и m. Программа запоминает наибольшее положительное число, введенное с клавиатуры.
//Нахождение максимального числа
#include <iostream.h>
int max(int n, int m); //прототип функции
void main(){
int n=-2147483648,m,k;
while(true){
cout <<endl<<"m=";
cin >>m; //ввод числа подлежащего сравнению
n=max(m,n); //максимальное значение присваивается n
cout <<"\nmax="<<n;
}
}
int max(int n, int m){
if (n>m) m=n; /*сравнение введенного числа с наибольшим из введенных ранее. Максимальное значение присваивается m */
return m;
}
Программа вводит число m и обращается к функции max(), которая сравнивает его с наибольшим числом n введенным ранее. Но в функции этим числа даны противоположные имена, т.е. вместо n используется имя m и наоборот. Тем не менее, программа работает нормально.
После того как мы узнали об ограниченной области видимости локальных переменных, сразу возникает вопрос, а есть ли переменные, которые видны из всех функций. Ответ положительный. Переменные доступные из всех функций программы называются глобальными. Объявление глобальных переменных должно быть осуществлено в начале программы, за пределами тел функций, напримр, сразу после директив компилчтору.
То же самое можно сказать о константах, которые разделяются на локальные и глобальные. Единственное отличие от переменных состоит в том, что они должны быть помечены зарезервированным словом const.
Вообще говоря каждая функция локальна в том блоке где она объявлена.
#include <iostream.h>
int n=0; //Объявлена глобальная переменная
void main(){
int n=1; cout<<endl<<"n="<<n; //Главный блок
{int n=2; cout<<endl<<"n="<<n; /*Вложенный блок, n новая
переменная*/
{int n=3; cout<<endl<<"n="<<n; /*Второй вложенный блок и вновь
новая переменная n*/
}
}
}
Итак, если в блоке видна только локальная переменная, то сразу возникает вопрос: как обратиться к глобальной переменной? Это просто сделать, применив новый оператор, который называется оператором расширения области видимости. Обозначается этот оператор двойным двоеточием :: .
Рассмотрим предыдущий пример, но в каждом блоке применим оператор расширения области видимости.
#include <iostream.h>
int n=0;
void main(){
int n=1; cout<<endl<<"n="<<n;
cout<<endl<<"n="<<::n;
{int n=2; cout<<endl<<"n="<<n;
cout<<endl<<"n="<<::n;
{int n=3; cout<<endl<<"n="<<n;
cout<<endl<<"n="<<::n<<endl;
}
}
}
Действие этого оператора распространяется только на одну переменную стоящую после оператора видимости.
Есть еще один интересный вопрос. Он касается времени жизни переменной. Представьте себе, что имеется несколько вложенных блоков, например,
int i=1, j=2, k=3;
{int i=10,j=20,k=30; //видны переменные только этого блока
. . . . . . . .
{int i=100, j=200, k=300; //видны переменные только этого блока
. . . . . . . .
}
}
Время жизни переменной определяется временем выполнения блока. После выхода их блока переменная перестает существовать.При повторном вхождении в блок она вновь создается. Таким образом переменная не может сохранять значение в промежутках между выходомиз блока и повторным входом. С одной стороны это полезное свойство помогает освобождать память, но иногда оно начинает мешать. В таких случаях желательно продлить время жизни переменной, и, конечно, в С++ такой механизм предусмотрен. Для того, чтобы снять ограничение на время жизни нужно объявить переменную как статическую. Делается это достаточно просто в момент объявления, например,
{static int i=100, j=200, k=300;
}
Статические переменные после их объявления существуют до завершения программы, т.е. объявляются один раз. В таких переменных можно накапливать информацию, например определять количество обращений к блоку. Здесь уместно уточнить, что статическая переменная по-прежнему остается видимой только в соем блоке.
И еще одно замечание. Выделение нового вида статических переменных требует как то называть старые переменные. Они называются автоматическими. Для того чтобы подчеркнуть их отличие от статических в программах при их объявлении можно записывать ключевое слово auto, например,
{ auto int i=100, j=200, k=300;}
хотя никто так не поступает.