Джесс Либерти - Освой самостоятельно С++ за 21 день.

После вызова функции Convert() программа продолжает выполнение с первого выражения в теле этой функции, представленного строкой 19, где объявляется локальная переменная, также названная TempCel. Обратите внимание, что эта локальная переменная — не та же самая переменная TempCel, которая объявлена в строке 7. Эта переменная существует только внутри функции Convert(). Значение, переданное в качестве параметра TempFer, также является лишь переданной из функции main() локальной копией одноименной переменной.

В функции Convert() можно было бы задать параметр FerTemp и локальную переменную CelTemp, что не повлияло бы на работу программы. Чтобы убедиться в этом, можете ввести новые имена и перекомпилировать программу.

Локальной переменной TempCel присваивается значение, которое получается в результате выполнения следующих действий: вычитания числа 32 из параметра TempFer, умножения этой разности на число 5 с последующим делением на число 9. Результат вычислений затем возвращается в качестве значения возврата функции, и в строке 11 оно присваивается переменной TempCel функции main(). В строке 13 это значение выводится на экран.

В нашем примере программа запускалась трижды. В первый раз вводится значение 212, чтобы убедиться в том, что точка кипения воды по Фаренгейту (212) сгенерирует правильный ответ в градусах Цельсия (100). При втором испытании вводится значение точки замерзания воды. В третий раз — случайное число, выбранное для получения дробного результата.

В качестве примера попробуйте запустить программу снова с другими именами переменных, как показано ниже.

Должен получиться тот же результат.

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

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

1: #include

2:

3: float Convert(float);

4: int main()

5: {

6: float TempFer;

7: float TempCel;

8:

9: cout << "Please enter the temperature in Fahrenheit: ";

10: cin >> TempFer;

11: TempCel = Convert(TempFer);

12: cout << "\nHere's the temperature in Celsius: ";

13: cout << TempCel << endl;

14: return 0;

15: }

16:

17: float Convert(float Fer)

18: {

19; float Cel;

20; Cel = ((Fer - 32) * 5) / 9;

21: return Cel;

22: }

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

Переменные, определенные вне тела какой-либо функции, имеют глобальную область видимости и доступны из любой функции в программе, включая main().

Локальные переменные, имена которых совпадают с именами глобальных переменных, не изменяют значений последних. Однако такая локальная переменная скрывает глобальную переменную. Если в функции есть переменная с тем же именем, что и у глобальной, то при использовании внутри функции это имя относится к локальной переменной, а не к глобальной. Это проиллюстрировано в листинге 5.3.

Листинг 5.3. Демонстрация использования ело глобальных и локальных переменных

1: #include

2: void myFunction(); // прототип

3:

4: int x = 5, у = 7; // глобальные переменные

5: int main()

6: {

7:

8: cout << "x from main: " << x << "\n";

9: cout << "у from main; " << у << "\n\n";

10: myFunction();

11: cout << "Back from myFunction!\n\n";

12: cout << "x from main: " << x << '\n";

13: cout << "y from main: " << y << "\n";

14: return 0;

15: }

16:

17: void myFunction()

18: {

19: int y = 10;

20:

21: cout << "x from myFunction: " << x << "\n";

22: cout << "y from myFunction: " << y << "\n\n";

23: }

Результат:

x from main: 5

y from main: 7

x from myFunction: 5

y from myFunction: 10

Back from myFunction!

x from main: 5

y from main: 7

Анализ:Эта простая программа иллюстрирует несколько ключевых моментов, связанных с использованием локальных и глобальных переменных, на которых часто спотыкаются начинающие программисты. В строке 4 объявляются две глобальные переменные — x и у. Глобальная переменная x инициализируется значением 5, глобальная переменная у — значением 7.

В строках 8 и 9 в функции main() эти значения выводятся на экран. Обратите внимание, что хотя эти переменные не объявляются в функции main(), они и так доступны, будучи глобальными.

При вызове в строке 10 функции myFunction() выполнение программы продолжается со строки 18, а в строке 19 объявляется локальная переменная у, которая инициализируется значением 10. В строке 21 функция myFunction() выводит значение переменной x. При этом используется глобальная переменная x, как и в функции main(). Однако в строке 22 при обращении к переменной у на экран выводится значение локальной переменной у, в то время как глобальная переменная с таким же именем оказывается скрытой.

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

Следует отметить, что в C++ глобальные переменные почти никогда не используются. Язык C++ вырос из С, где использование глобальных переменных всегда было чревато возникновением ошибок, хотя обойтись без их применения также было не возможно. Глобальные переменные необходимы в тех случаях, когда программисту нужно сделать данные доступными для многих функций, а передавать данные из функции в функцию как параметры проблематично.

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

На занятии 14 вы познакомитесь с мощной альтернативой использованию глобальных переменных, которая предусмотрена в C++, но недоступна в языке С.

О переменных, объявленных внутри функции, говорят, что они имеют локальную область видимости. Это означает, как упоминалось выше, что они видимы и пригодны для использования только в пределах той функции, в которой определены. Фактически в C++ можно определять переменные в любом месте внутри функции, а не только в ее начале. Областью видимости переменной является блок, в котором она определена. Таким образом, если в теле функции будет блок, выделенный парой фигурных скобок, и в этом блоке объявляется переменная, то она будет доступна только в пределах блока, а не во всей функции, как показано в листинге 5.4.