28 29 30 31 32 33 34

int X = 9:

cout \ nVery local x: << x;

cout << \ nOut of block, in myFunc, x: << x << endl;

In main X is; 5

In myFunc, local x: 8

In block in myFunc, x is; В Very local x; 9 Out of block, in myFunc, x; 8 Back in main, x is; 5

Эта профамма начинается с инициализации локальной переменной х в функции mainO (сфока 10). Выведенное в сфоке И значение переменной х позволяет убедиться, что переменная х действительно была инициализирована числом 5.

Затем в профамме вызывается функция MyFuncO, в теле которой в строке 22 объявляется локальная переменная с тем же именем х и инициализируется значением 8. Это значение выводится на экран в строке 23.

Блок, заключенный в фигурные скобки, начинается в строке 25, и в строке 26 снова выводится значение локальной переменной х. Но в строке 28 создается новая переменная с таким же именем х, которая является локальной по отношению к данному блоку. Эта переменная тут же инициализируется значением 9.

Значение последней созданной переменной х выводится на экран в строке 30. Локальный блок завершается строкой 31, и переменная, созданная в строке 28, выходит за пределы видимости и удаляется из памяти.

В строке 33 на экран выводится значение той переменной х, которая была объявлена в строке 22. На нее никоим образом не повлияло определение новой переменной X в сфоке 28, и ее значение по-прежнему равно В.

В строке 34 заканчивается область видимости функции MyFuncO и ее локальная переменная X становится недоступной. Управление программой возвращается к строке 15, в которой выводится значение локальной переменной х, созданной в строке 10. Вы сами можете убедиться в том, что на нее не повлияла ни одна из одноименных переменных, определенных в функции MyFuncC).

Нужно ли специально говорить о том, что эта профамма была бы гораздо менее путаной, если бы все три переменные имели уникальные имена!

Операторы, используемые в функциях

Фактически на количество или типы операторов, используемых в функциях, никаких офаничений не накладывается. И хотя внутри функции нельзя определить другую функцию, но из одной функции можно вызывать сколько угодно других функций; именно этим и занимается функция main() почти в каждой профамме С++. Более того, функции могут вызывать даже самих себя (эта ситуация рассматривается в разделе, посвященном рекурсии).

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

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

Подробнее об аргументах функции

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

Аргументом функции может быть любое действительное выражение С++, включающее константы, математические и логические выражения и другие функции, которые возвращают некоторое значение.

Использование функций о качвствв оарамвтров функций

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

В качестве примера предположим, что у вас есть функции doubleO, triple(), squareO и cube(), возвращающие некоторое значение. Вы могли бы записать следующую инструкцию:

Answer = (double(triple(square(cube(myValue)))));

Эта инструкция принимает переменную myValue и передает ее в качестве аргумента функции cubeO, возвращаемое значение которой (куб числа) передается в качестве аргумента функции square(). После этого возвращаемое значение функции squareO (квадрат числа), в свою очередь, передается в качестве аргумента функции triple(). Затем значение возврата функции tripleO (утроенное число) передается как аргумент функции doubleO. Наконец, значение возврата функции doubleO (удвоенное число) присваивается переменной Answer.

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

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

unsigned long myValue = 2;

unsigned long cubed = cube(myValue); 2 в кубе = 8

unsigned long squared = square(cubed); 8 в квадрате = 64

unsigned long tripled = triple(squared); 64 3 = 192

unsigned long Answer = double(tripled); 192 2 = 384

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

Параметры - это локальные переменные

/фгументы, переданные функции, локальны по отношению к данной функции. Изменения, внесенные в аргументы во время выполнения функции, не влияют на переменные, значения которых передаются в функцию. Этот способ передачи параметров известен как передача как значения, т.е. локальная копия каждого аргумента создается в самой функции. Такие локальные копии внешних переменных обрабатываются так же, как и любые другие локальные переменные функции. Эта идея иллюстрируется в листинге 5.5.

Аистииг б.б. Передача параметров как зивчеиай

2 3 4 5 6 7 8 9

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Листинг 5,5. Передача параметров как значений

#include <iostream.h>

void swap(int x, int y);

int mainO {

int X = 5, у = 10;

cout Main, Before swap, x; x y; у \ n swap(x,y);

cout Main. After swap, x: x y: у \ n ; return 0;

void swap (int x, int y) {

int temp;

cout Swap. Before swap, x; x y: у \ n

temp = x; X = y; у = temp;

cout Swap. After swap, x: x y: у \ n ;

Main, Before swap, x; 5 y; 10

Swap. Before swap, x: 5 y; 10

Swap. After swap, x; 10 y: 5

Main. After swap, x; 5 y; 10

. В профамме инициализируются две переменные в функции main(), а затем

! ... значения передаются в функцию swapO, которая, казалось бы, должна

поменять их значения. Однако после повторной проверки этих переменных в функции main() оказывается, что они не изменились.