Функции
Функция – это самостоятельная единица программы, которая спроектирована для реализации конкретной подзадачи. Функция может быть многократно вызвана из другого участка программы, это позволяет исключить повтор одних и тех же действий. Функции также помогают логически выстроить программу.
Функция определяется таким образом:
1. Тип возвращаемого значения;
2. Имя функции;
3. Информация о формальных аргументах;
4. Тело функции.
Формальный аргумент — это переменная в вызываемой функции.
Общая форма записи функции:
(тип1 agr1, тип2 agr2, . ) <
Тело функции;
>
Оператором возврата из функции в точку ее вызова является оператор return.
Давайте посмотри пример функции:
Функция SUM принимает два значения типа int и возвращает их сумму. a, b — формальные аргументы, а sum — локальная переменная.
Чтобы вызвать функцию, нужно указать ее имя и перечислить в скобках передаваемые фактические аргументы.
Фактический аргумент — это величина, которая присваивается формальному аргументу при вызове функции.
Пример вызова функции SUM:
В переменную s будет записано значение, которое вернет функция SUM.
Между формальными и фактическими параметрами при вызове функции должны соблюдаться правила соответствия по последовательности и по типам.
При передаче аргументов происходит их копирование. Это значит, что любые изменения, которые функция производит над переменными, имеют место быть только внутри функции. Чтобы изменить фактические значения, нужно передать указатель на этот элемент.
Например, функция sqr возвращает квадрат числа и изменяет фактическую переменную x на 5:
Функции могут и не возвращать значения, а просто выполнять некоторые вычисления. В этом случае указывается пустой тип возвращаемого значения void, а оператор return может либо отсутствовать, либо не возвращать никакого значения (return;):
Передача массива в функцию
Так как имя массива — это указатель, поэтому передача массива в функцию равна передачи указателя.
Пример передачи массива в функцию:
Так как мы передали указатель, то все изменения в функции будут распространяться и вне её. Аналогично и с двумерным массивом
Чтобы передать функции двумерный массив, необходимо четко указать размеры массива:
Если двумерным массив был выделен динамически, то в функцию нужно передать указатель на указатель:
Передача структуры в функцию
Передать структуру в функцию можно как по значению (тогда произойдет копирование структуры в функции), так и по адресу. Передавать адрес в функцию бывает гораздо выгодней по памяти. Дело в том, что размер указателя может быть намного меньше размера структурной переменной.
Если мы хотим передать структуру по значению, то изменяем строку 17 на F(P), а функцию так:
Передача массива структур полностью совпадает с передачей обычного массива:
При динамическом выделение памяти под структуру изменения не происходят.
Рекурсивные функции
Функция, которая вызывает сама себя, называется рекурсивной функцией.
Для рекурсивной функции обязательно нужно указать условие выхода из рекурсии, иначе функция будет бесконечно себя вызывать. Всё решение сводится к нахождению условия выхода.
При каждом вызове для формальных аргументов и локальных переменных выделяется новая область памяти, так что их значения из предыдущих вызовов не теряются, но в каждый момент времени доступны только значения текущего вызова (кроме указателей). Число рекурсивных вызовов ограничивается только ресурсом памяти компьютера и при слишком большом числе рекурсивных вызовов может произойти переполнение стека.
Когда выполняется условие выхода, то функция перестает вызывать себя и возвращает какое-то значение, в том числе и пустое. После возврата мы попадаем на предыдущий уровень рекурсии вместо последнего вызова функции.
Задача: дано натуральное число n > 1. Выведите все простые множители этого числа в порядке неубывания с учетом кратности.
Код на Си:
Чтобы подробнее разобраться с действием рекурсии, можно посмотреть как используется рекурсия в DFS — обход графа в глубину.
Как передавать массив в функцию си
При рассмотрении передачи параметров в функцию указывалось, что параметры передаются в функцию по значению. То есть функция не изменяет значения передаваемых аргументов. Однако, используя в качестве параметров указатели, мы можем получить доступ к значению аргумента и изменить его.
Например, пусть у нас будет простейшая функция, которая увеличивает число на единицу:
Здесь переменная n передается в качестве аргумента для параметра x. Передача происходит по значению, поэтому любое изменение параметра x в функции increment никак не скажется на значении переменной n. Что мы можем увидеть, запустим программу:
Теперь изменим функцию increment, использовав в качестве параметра указатель:
Теперь в функции increment разыменовываем указатель, получаем его значение и увеличиваем его на единицу.
Это изменяет значение, которое находится по адресу, хранимому в указателе x.
Поскольку теперь функция в качестве параметра принимает указатель, то при ее вызове необходимо передать адрес переменной: increment(&n); .
В итоге изменение параметра x также повлияет на переменную n:
Еще один показательный пример применения указателей в параметрах — функция обмена значений:
Функция swap() в качестве параметров принимает два указателя. Посредством переменной temp происходит обмен значениями.
При вызове функции swap в нее передаются адреса переменных x и y, и в итоге их значения будут изменены.
Константые параметры
Если необходимо запретить изменять значение параметра-указателя внутри функции, то можно определить такой параметра как константный:
Фактически такой константный параметр будет работать как указатель на константу — мы не сможем изменить его значение внутри функции.
Массивы в параметрах
Если функция принимает в качестве параметра массив, то фактически в эту функцию передается только адрес начала массива. То есть как и в случае с указателями нам доступен адрес, по которому мы можем менять значения. В отличие от параметров примитивных типов, которые передаются по значению.
Например, определим функцию для увеличения элементов массива в два раза:
Функция twice в качестве параметров принимает массив и число его элементов и в цикле увеличивает их в два раза.
В функции main передаем массив в функцию twice и затем выводим его на консоль. В результате мы увидим, что массив nums был изменен:
Так как передача массива в функцию фактически представляет передачу адреса первого элемента, то массивы в параметрах мы можем заменить указателями:
В итоге в данном случае не будет большой разницы, какой тип имеет параметр — массив или указатель.
Передача массива в функцию и возврат из функции
Особенность передачи массивов в функции в языке Си в том, что передается не сам массив, а адрес массива, который хранится в локальном указателе на него.
Это можно сделать по-разному, но результат будет одинаковый:
- void some_function(int array[]);
- void some_function(int *array);
При этом обязательно нужно указать тип элемента массива.
Размер массива в функцию автоматически не передается, поэтому если размер массива заранее (на этапе компиляции) не оговорен, то нужно передать параметр, который содержит количество элементов в массиве, например number_of_elements:
void some_function(int array[], int number_of_elements);
Следующая программа передает массивы в функцию show_array, которая использует цикл for для вывода значений массивов:
show_array.c
void show_array (int array [], int number_of_elements)
<
for ( int i = 0; i < number_of_elements; i++) <
printf(«%d\t», array[i]);
>
printf(«\n»);
>
int main()
<
int little_numbers[5] = <1, 2, 3, 4, 5>;
int big_numbers[3] = <1000, 2000, 3000>;
show_array(little_numbers, 5);
show_array(big_numbers, 3);
>
Массив просто передается в функцию по имени (а его имя — это адрес первого элемента), а также указывает параметр, который сообщает функции количество элементов, содержащихся в массиве:
Изменение массива из функции
Возможно ли поменять значения элементов из функции?
Ответ положительный — да, это возможно, причем ничего дополнительно для этого указывать не нужно, так как в функцию передается адрес массива, а не сами значения, то и доступ происходит к тем же самым элементам, а не к их копиям.
Следующая программа использует функцию get_values, чтобы присвоить три значения массиву numbers:
values_from_keyboard.c
#include <stdio.h>
void read_array(int array[], int number_of_elements)
<
for(int i = 0; i < number_of_elements; i++)
<
printf(«Введите значение №%d: «, i);
scanf(«%d», &array[i]);
>
>
int main()
<
int numbers[3] = <0, 0, 0>;
read_array (numbers, 3); //массив будет изменен!
printf(» Значения массива\n»);
for (int i = 0; i < 3; i++) <
printf(» numbers [%d] \n», i);
>
Как видите, программа передает массив в функцию по имени, а функция присваивает массиву элементы.
Таким образом, функция может изменить элементы массива, если ей это нужно.
Массивы и функции
Массивы, также как остальные переменные, можно передавать в функции в качестве аргументов. Рассмотрим такую программу:
В теле функции main() объявляется массив, состоящий из 10 элементов. Далее вызывается функция arr_make() , которой передаются в качестве аргументов имя массива и два целых числа.
Если посмотреть на функцию arr_make() , то можно заметить, что ее первый параметр выглядит немного странно. Функция принимает массив неизвестно какого размера. Если предположить, что массивы передаются по значению, т.е. передаются их копии, то как при компиляции будет вычислен необходимый объем памяти для функции arr_make() , если неизвестно какого размера будет один из ее параметров?
На прошлом уроке мы выяснили, что имя массива — это константный указатель на первый элемент массива; т.е. имя массива содержит адрес. Выходит, что мы передаем в функцию копию адреса, а не копию значения. Как мы уже знаем, передача адреса приводит к возможности изменения локальных переменных в вызывающей функции из вызываемой. Ведь на одну и ту же ячейку памяти могут ссылаться множество переменных, и изменение значения в этой ячейке с помощью одной переменной неминуемо отражается на значениях других переменных.
Описание вида arr[] в параметрах функций говорит о том, что в качестве значения мы получаем указатель на массив, а не обычную (скалярную) переменную типа int, char, float и т.п.
Продолжим рассуждения. Если в функцию передается только адрес массива, то в теле функции никакого массива не существует, и когда там выполняется выражение типа arr[i] , то на самом деле arr — это не имя массива, а переменная-указатель, к которой прибавляется смещение. Поэтому цикл в функции arr_make() можно переписать на такой:
В теле цикла результат выражения справа от знака присваивания записывается по адресу, на который указывает arr. За это отвечает выражение *arr . Затем указатель arr начинает указывать на следующую ячейку памяти, т.к. к нему прибавляется единица ( arr++ ). Еще раз: сначала выполняется выражение записи значения по адресу, который содержится в arr; после чего изменяется адрес, содержащийся в указателе (сдвигается на одну ячейку памяти определенного размера).
Поскольку мы можем изменять arr, это доказывает, что arr — обычный указатель, а не имя массива. Тогда зачем в заголовке функции такой гламур, как arr[] ? Действительно, чаще используют просто переменную-указатель:
Хотя в таком случае становится не очевидно, что принимает функция — указатель на обычную переменную или все-таки на массив. В любом случае она будет работать.
Часто при передаче в функцию массивов туда же передают и количество его элементов в виде отдельного параметра. В примере выше N является глобальной константой, поэтому ее значение доступно как из функции main() , так и arr_make() . Иначе, более грамотно было бы написать функцию arr_make() так:
В данном случае параметр n — это количество обрабатываемых элементов массива.
Следует еще раз обратить внимание на то, что при передачи имени массива в функцию, последняя может его изменять. Однако такой эффект не всегда является желательным. Конечно, можно просто не менять значения элементов массива внутри функции, как в данном примере, где вычисляется сумма элементов массива; при этом сами элементы никак не изменяются:
Но если вы хотите написать более надежную программу, в которой большинство функций не должны менять значения элементов массивов, то лучше в заголовках этих функций объявлять параметр-указатель как константу, например:
В этом случае, любая попытка изменить значение по адресу, содержащемуся в таком константном указателе, будет приводить к ошибке и программист будет знать, что функция пытается изменить массив.
Усовершенствуем программу, которая была приведена в начале этого урока:
Теперь у пользователя запрашивается минимум и максимум, затем создается массив из элементов, значения которых лежат в указанном диапазоне. Массив выводится на экран с помощью функции arr_print() . Далее у пользователя запрашивается знак + или -. Вызывается функция arr_inc_dec() , которая в зависимости от введенного знака увеличивает или уменьшает на единицу значения элементов массива.
В функциях arr_make() и arr_print() используется нотация указателей. Причем в теле функций значения указателей меняются: они указывают сначала на первый элемент массива, затем на второй и т.д. В функции arr_inc_dec() используется вид обращения к элементам массива. При этом значение указателя не меняется: к arr прибавляется смещение, которое увеличивается на каждой итерации цикла. Ведь на самом деле запись arr[i] означает *(arr+i) .
При использовании нотации обращения к элементам массива программы получаются более ясные, а при использовании записи с помощью указателей они компилируются чуть быстрее. Это связано с тем, что когда компилятор встречает выражение типа arr[i] , то он тратит время на преобразование его к виду *(arr+i) . Однако лучше потратить лишнюю секунду при компиляции, но получить более читаемый код.