Функции в C: практические примеры рекурсии и встроенных (inline) функций

Что такое функция в C?

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

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

В этом уроке вы узнаете:

• Библиотечные vs. пользовательские функции
• Объявление функции
• Определение функции
• Вызов функции
• Аргументы функции
• Область видимости переменных
• Статические переменные
• Рекурсивные функции
• Встроенные (inline) функции

Библиотечные vs. пользовательские функции

Каждая программа на «C» имеет хотя бы одну функцию — это функция main, но программа может иметь любое количество функций. Функция main() в C — точка входа программы.

В программировании на «C» функции делятся на два типа:

1. Библиотечные функции
2. Пользовательские функции

Разница между библиотечными и пользовательскими функциями в C заключается в том, что нам не нужно писать код для библиотечной функции. Она уже присутствует внутри заголовочного файла, который мы всегда подключаем в начале программы. Вы просто пишете имя функции и используете ее с правильным синтаксисом. Printf, scanf — примеры библиотечной функции.

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

Пользовательская функция в C всегда пишется пользователем, но позже она может стать частью библиотеки «C». Это главное преимущество программирования на «C».

Функции программирования на C делятся на три действия, такие как:

1. Объявление функции
2. Определение функции
3. Вызов функции

Объявление функции

Объявление функции означает написание имени программы. Это обязательная часть для использования функций в коде. В объявлении функции мы просто указываем имя функции, которую собираемся использовать в нашей программе, как при объявлении переменной. Мы не можем использовать функцию, если она не объявлена в программе. Объявление функции также называется «Функциональный прототип».

Объявления функций (называемые прототипами) обычно делаются выше функции main() и имеют общую форму:

return_data_type function_name (data_type arguments);

• return_data_type: тип данных значения, которое функция возвращает обратно в вызывающий оператор.
• function_name: следует за скобками
• Arguments имена с объявлениями их типов данных опционально помещаются внутри скобок.

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

#include <stdio.h> /*Function declaration*/ int add(int a,b); /*End of Function declaration*/ int main() {

Имейте в виду, что функция не обязательно возвращает значение. В этом случае используется ключевое слово void.

Например, объявление функции output_message указывает, что функция не возвращает значение: void output_message();

Определение функции

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

int add(int a,int b) //function body { int c; c=a+b; return c; }

Вызов функции

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

 result = add(4,5);

Вот полный код:

#include <stdio.h> int add(int a, int b); //function declaration int main() { int a=10,b=20; int c=add(10,20); //function call printf("Addition:%d\n",c); getch(); } int add(int a,int b) //function body { int c; c=a+b; return c; }

Вывод:

Addition:30

Аргументы функции

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

По умолчанию аргументы передаются по значению, при этом копия данных передается в вызываемую функцию. Фактически переданная переменная не изменится.

Рассмотрим следующую программу, демонстрирующую параметры, переданные по значению:

int add (int x, int y); int main() { int a, b, result; a = 5; b = 10; result = add(a, b); printf("%d + %d\ = %d\n", a, b, result); return 0;} int add (int x, int y) { x += y; return(x);}

Вывод программы:

5 + 10 = 15

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

Область видимости переменных

Область видимости переменной означает видимость переменных в коде программы.

В C переменные, объявленные внутри функции, локальны для этого блока кода и не могут быть обращены извне функции. Однако переменные, объявленные вне всех функций, являются глобальными и доступны из всей программы. Константы, объявленные с #define в начале программы, доступны из всей программы. Рассмотрим следующую программу, которая печатает значение глобальной переменной из main и пользовательской функции:

#include <stdio.h> int global = 1348; void test(); int main() { printf("from the main function : global =%d \n", global); test () ; return 0;} void test (){ printf("from user defined function : global =%d \n", global);}

Результат:

from the main function : global =1348 from user defined function : global =1348

Обсудим детали программы:

1. Мы объявляем целочисленную глобальную переменную с начальным значением 1348.
2. Мы объявляем и определяем функцию test(), которая не принимает аргументов и не возвращает значение. Эта функция только печатает значение глобальной переменной, чтобы продемонстрировать, что глобальные переменные доступны где угодно в программе.
3. Мы печатаем глобальную переменную внутри функции main.
4. Мы вызываем функцию test, чтобы напечатать значение глобальной переменной.

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

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

Статические переменные

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

Следующая программа использует статическую переменную:

#include <stdio.h> void say_hi(); int main() { int i; for (i = 0; i < 5; i++) { say_hi();} return 0;} void say_hi() { static int calls_number = 1; printf("Hi number %d\n", calls_number); calls_number ++; }

Программа отображает:

Hi number 1 Hi number 2 Hi number 3 Hi number 4 Hi number 5 

Рекурсивные функции

Рассмотрим факториал числа, который вычисляется так: 6! = 6 * 5 * 4 * 3 * 2 * 1.

Это вычисление делается как повторное вычисление fact * (fact - 1) до тех пор, пока fact не станет равным 1.

Рекурсивная функция — это функция, которая вызывает саму себя и включает условие выхода для завершения рекурсивных вызовов. В случае вычисления факториала числа условием выхода является fact, равное 1. Рекурсия работает за счет «накопления» вызовов до тех пор, пока условие выхода не станет истинным.

Например:

#include <stdio.h> int factorial(int number); int main() { int x = 6; printf("The factorial of %d is %d\n", x, factorial(x)); return 0;} int factorial(int number) { if (number == 1) return (1); /* условие выхода */ else return (number * factorial(number - 1)); }

Программа отображает:

 The factorial of 6 is 720

Здесь мы обсуждаем детали программы:

1. Мы объявляем нашу рекурсивную функцию factorial, которая принимает целочисленный параметр и возвращает факториал этого параметра. Эта функция будет вызывать саму себя и уменьшать число, пока не будет достигнуто условие выхода, или базовое условие. Когда условие истинно, ранее сгенерированные значения будут перемножены друг на друга, и итоговое значение факториала будет возвращено.
2. Мы объявляем и инициализируем целочисленную переменную со значением «6» и затем печатаем ее факториал, вызывая нашу функцию factorial.

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

Встроенные (inline) функции

Функция в программировании на C используется для хранения наиболее часто используемых инструкций. Она используется для модуляризации программы.

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

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

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

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

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

inline function_name () { //function definition }

Напишем программу для реализации встроенной функции.

inline int add(int a, int b) //inline function declaration { return(a+b); } int main() { int c=add(10,20); printf("Addition:%d\n",c); getch(); }

Вывод:

Addition: 30

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

Резюме

• Функция — это мини-программа или подпрограмма.
• Функции используются для модуляризации программы.
• Библиотечные и пользовательские — два типа функций.
• Функция состоит из объявления, тела функции и части вызова функции.
• Объявление функции и тело обязательны.
• Вызов функции может быть опционален в программе.
• Программа на C имеет хотя бы одну функцию; это функция main().
• У каждой функции есть имя, тип данных возвращаемого значения или void, параметры.
• Каждая функция должна быть определена и объявлена в вашей программе на C.
• Имейте в виду, что обычные переменные в функции C уничтожаются, как только мы выходим из вызова функции.
• Аргументы, переданные в функцию, не будут изменены, потому что они передаются по значению, а не по адресу.
• Область видимости переменной относится к видимости переменных в программе
• В программировании на C есть глобальные и локальные переменные