Переменные, которые объявлены внутри функции, называются внутренними переменными или локальными. Эти переменные могут использоваться только в тех функциях, где они объявлены, и никакие другие функции доступа к ним не имеют.
Каждая локальная переменная функции возникает только в момент обращения к этой функции и исчезает после выхода из нее. Такие переменные называются автоматическими, т. к. они образуются и исчезают одновременно с входом в функцию и выходом из нее; они не сохраняют своих значений от вызова к вызову.
Таким образом, локальные переменные по умолчанию относятся к классу памяти «автоматические» (auto).
Чтобы переменная не только сохраняла свои значения в течение работы программы, но и чтобы ею могли пользоваться другие функции, она должна быть не внутренней, а внешней (глобальной) переменной. Внешние переменные доступны повсеместно. Их можно использовать в любом месте программы, в любой функции. Кроме того, поскольку внешние переменные существуют постоянно, а не возникают и не исчезают на период выполнения функции, свои значения они сохраняют и после возврата из функций, их установивших.
Внешняя переменная должна быть объявлена вне тела любой функциии только один раз; в этом случае ей будет выделена память. Обычно внешние переменные объявляются в начале программы, после директив перед главной функцией main ().
Поскольку внешние переменные доступны всюду, их можно использовать в качестве связующих данных между функциями как альтернативу связей через аргументы и возвращаемые значения.
Рассмотрим, как это делается, путем введения внешних переменных в программу вычисления суммы квадратов с использованием функции, производящей возведение числа в квадрат (см. стр. 5).
#include<iostream>
using namespace std;
void square (); // объявление функции
int a, b; // объявление внешних переменных
Intmain ()
{
a = 3;
square ();
z = b;
a = 4;
square ();
z = z+b;
cout<< '' sum = ''<< z <<endl;
return 0;
}
Void square ()
{
b =a*a;
}
Т. к. связь между функциями осуществляется через внешние переменные, то в функцию square() ничего не передаётся и она ничего не возвращает. В главной функции main () присваивается значение переменной а и вызывается функция square (), которая вычисляет а2 и присваивает его внешней переменной b. Что будет выведено на экран?
Рассмотрим ещё один пример. В программе три функции, которые используют одну глобальную переменную.
#include <iostream>
using namespace std;
float global=0;
Void first(float loc)
{
global=loc+36.6;
cout<<"global after first = "<<global<<'\n';
}
Float second(float x, float y)
{
global=global-x;
cout<<"global after second = "<<global<<'\n';
y=y-global;
if(x>y && y>0)
{
cout<<"returns x";
return x;
}
Else
{
cout<<"returns y";
return y;
}
}
Int main()
{
float a,b,c,d;
cout<<"Insert 3 floats: ";
cin>>a>>b>>c;
cout<<"Insert global: ";
cin>>global;
first(a);
d=second(b,c);
cout<<" = "<<d<<'\n';
global=a+b+c+d;
cout<<"global in main = "<<global<<'\n';
return 0;
}
На экране:
Чтобы локальная переменная могла сохранять свои значения от вызова к вызову функции, необходимо переменную отнести к классу памяти static (статические). Такие переменные не исчезают при выходе из функции. Рассмотрим показательный пример.
#include<iostream>
using namespace std;
Void par (int i)
{
static int p= 21;
cout<<'' i =''<<i<< ''p = ''<< p <<endl;
p++;
}
Int main ()
{
inti;
for (i=1; i<4; i++)
par (i);
return 0;
}
В функции par () объявлена статическая переменная p. Функция сначала выводит на экран значения переменных i и p, а затем дает приращение переменной р. Статическая переменная p инициализируется один раз при первом вызове par(), а затем сохраняет своё измененное значение до следующего вызова.
Результатом выполнения программы будет:
i = 1 p = 21
i = 2 p = 22
i = 3 p = 23.
Если из объявления переменной p убрать слово static, то на экран выведется:
i = 1 p = 21
i = 2 p = 21
i = 3 p = 21.
Исходя из примера видно, что статическая переменная является собственной постоянной памятью функции, т. к. значение статической переменной будет сохраняться до очередного вызова функции.
Внешние переменные в определенных случаях удобны и эффективны, но пользоваться ими необходимо в меру. Не критичное использование внешних переменных ухудшает структуру программы и приводит к слишком большому числу связей между функциями по данным, которые не всегда предсказуемы.
Области видимости
Область видимости переменной (функции) – это часть программы, в которой этой переменной можно пользоваться. Для локальных переменных – это функция, где они объявлены. Область действия внешней переменной простирается от точки программы, где она объявлена, до конца файла.
Рассмотрим схематичный пример.
Int main()
{... }
int sp=0;
Double val[10];
void func1() {... }
intfunc2 (intb) {... }
В данном примере область видимости переменных sp и val[10] распространяется на функции func1() и func2(). В функции main() они не видны.