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

 

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

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

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

 

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

 

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

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

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

 

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

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

 

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

 

Эта инструкция принимает переменную myValue и передает ее в качестве аргумента функции cube(), возвращаемое значение которой (куб числа) передается в качестве аргумента функции square(). После этого возвращаемое значение функции square() (квадрат числа), в свою очередь, передается в качестве аргумента функции triple(). Затем значение возврата функции triple() (утроенное число) передается как аргумент функции double(). Наконец, значение возврата функции double() (удвоенное число) присваивается переменной 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.

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

1: // Листинг 5.5. Передача параметров как значений

2:

3: #include <iostream.h>

4:

5: void swap(int x, int у);

6:

7: int main()

8: {

9: int x = 5, у = 10;

10:

11: cout << "Main. Before swap, x: " << x << " у: " << у << "\n";

12: swap(x,y);

13: cout << "Main. After swap, x: " << x << " у: " << у << "\n";

14: return 0;

15: }

16:

17: void swap (int x, int у)

18: {

19: int temp;

20:

21: cout << "Swap. Before swap, x: " << x << " у: " << у << "\n";

22:

23: temp = x;

24: x = у;

25: у = temp;

26:

27: cout << "Swap. After swap, x: " << x << " у: и << у << "\n";

28:

29: }

 

Результат:

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(), а затем их значения передаются в функцию swap(), которая, казалось бы, должна поменять их значения. Однако после повторной проверки этих переменных в функции main() оказывается, что они не изменились.

Эти переменные инициализируются в строке 9, а отображение их значений на эк­ране выполняется в строке 11. Затем вызывается функция swap(), и эти переменные передаются ей в качестве аргументов.

Выполнение программы переносится в функцию swap(), где в строке 21 снова выводятся значения тех же, уже знакомых нам переменных. Как и ожидалось, их значения от передачи в функцию не изменились. В строках 23—25 переменные ме­няются своими значениями, что подтверждается очередной проверкой в строке 27. Но это положение сохраняется лишь до тех пор, пока программа не вышла из функции swap().

Затем управление программой передается строке 13, принадлежащей функции main(), которая показывает, что переменные получили назад свои исходные значения и все изменения, произошедшие в функции, аннулированы!

Напомним, что в данном случае переменные передаются в функцию swap() как значения, т.е. в функции swap() были созданы копии этих значений, которые являют­ся локальными по отношению к этой функции. Обмен значениями, выполненный в строках 23—25, был реализован на этих локальных переменных, но это никак не по­влияло на переменные, оставшиеся в функции main().

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

 

---

Дата добавления: 2019-02-12; просмотров: 227; Мы поможем в написании вашей работы!

Поделиться с друзьями:

---

---

Мы поможем в написании ваших работ!