5.1. Общие сведения о функциях
Теория
Зачем нужен этот пункт
Функции уже встречались раньше, но теперь эта тема рассматривается подробнее и строже. В языке C функция — это не просто удобный способ сократить программу, а один из основных элементов построения кода.
Функция позволяет выделить отдельную задачу в самостоятельный блок: вычислить значение, вывести данные, проверить условие, обработать массив, выполнить часть алгоритма.
В этом пункте рассматриваются:
- что такое функция в языке C;
- общий формат определения функции;
- заголовок и тело функции;
- тип возвращаемого значения;
- параметры и аргументы;
- прототип функции;
- вызов функции;
- оператор
return; - функции типа
void; - передача параметров по значению;
- типичные ошибки при создании и вызове функций.
Что такое функция
Функция — это именованная часть программы, которая может получать данные, выполнять действия и возвращать результат.
int square(int x)
{
return x * x;
}
В этом примере функция square получает целое число
x, вычисляет его квадрат и возвращает результат.
С одной стороны, функция является производным типом языка C. С другой стороны, функция — это минимальный исполняемый модуль программы: отдельный фрагмент кода, который можно вызвать из другого места программы.
Зачем нужны функции
Функции нужны для структурирования программы. Без функций вся логика
оказалась бы внутри main, и программа быстро стала бы
длинной, запутанной и трудной для проверки.
Функции помогают:
- разделить программу на понятные части;
- избежать повторения одинакового кода;
- проверять отдельные части программы отдельно;
- делать
mainкороче и понятнее; - переиспользовать один и тот же алгоритм в разных местах;
- готовить программу к многофайловой организации.
Хорошая функция обычно выполняет одну основную задачу.
Общий формат определения функции
Определение функции в C имеет общий вид:
тип_результата имя_функции(спецификация_параметров)
{
тело_функции
}
Пример:
int sum(int a, int b)
{
return a + b;
}
Здесь:
int— тип возвращаемого значения;sum— имя функции;int a, int b— спецификация параметров;{ ... }— тело функции;return a + b;— возврат результата.
Заголовок функции
Первая строка определения функции называется заголовком функции.
double average(double a, double b)
Заголовок сообщает:
- какой тип значения возвращает функция;
- как называется функция;
- какие параметры она принимает;
- каких типов должны быть эти параметры.
Например:
double average(double a, double b)
означает: функция average принимает два параметра типа
double и возвращает значение типа double.
Тело функции
Тело функции записывается в фигурных скобках. Внутри тела находятся объявления локальных переменных и операторы.
double average(double a, double b)
{
double result;
result = (a + b) / 2.0;
return result;
}
Переменная result объявлена внутри функции. Она является
локальной и доступна только внутри функции average.
В C нельзя определить одну функцию внутри другой.
Нельзя:
int main(void)
{
int helper(void)
{
return 1;
}
return 0;
}
Правильно:
int helper(void)
{
return 1;
}
int main(void)
{
return helper();
}
Тип возвращаемого значения
Перед именем функции указывается тип значения, которое функция возвращает в точку вызова.
int max2(int a, int b)
{
if (a > b)
{
return a;
}
return b;
}
Эта функция возвращает значение типа int.
Функция может возвращать значения разных типов:
int count(void);
double area(double radius);
char getGrade(int mark);
Если функция не должна возвращать значение, используется тип
void.
void printLine(void)
{
printf("--------------------\n");
}
Функции типа void
Функция типа void выполняет действие, но не возвращает
результат.
void printMessage(void)
{
printf("Hello\n");
}
Такую функцию вызывают как отдельный оператор:
printMessage();
В функции типа void можно использовать оператор
return; без выражения.
void printPositive(int x)
{
if (x <= 0)
{
return;
}
printf("%d\n", x);
}
Здесь return; досрочно завершает функцию, если число
не является положительным.
Параметры функции
Параметры — это переменные, указанные в заголовке функции. Они нужны для передачи данных внутрь функции.
int sum(int a, int b)
Здесь a и b — параметры функции.
Каждый параметр имеет тип и имя:
double power(double x, int n)
Здесь:
double x— первый параметр;int n— второй параметр.
Внутри функции параметры используются как обычные локальные переменные.
Функция без параметров
Если функция не принимает параметры, в скобках лучше явно писать
void.
void hello(void)
{
printf("Hello\n");
}
Вызов:
hello();
Пустые скобки при вызове обязательны. Без них функция не вызывается.
hello; /* не вызов */
hello(); /* вызов */
Аргументы функции
Аргументы — это конкретные значения или выражения, которые передаются функции при вызове.
int result;
result = sum(10, 20);
Здесь 10 и 20 — аргументы.
Соответствие между параметрами и аргументами устанавливается по порядку.
int sum(int a, int b);
sum(10, 20);
При таком вызове:
aполучает значение10;bполучает значение20.
Вызов функции
Для обращения к функции используется её имя и список аргументов в круглых скобках.
имя_функции(список_аргументов)
Пример:
int x;
x = sum(3, 4);
Вызов функции является выражением. Если функция возвращает значение, этот вызов можно использовать:
- в правой части присваивания;
- в выражении;
- в условии;
- в аргументе другой функции.
printf("%d\n", sum(3, 4));
if (max2(a, b) > 10)
{
printf("Больше 10\n");
}
Оператор return
Оператор return завершает выполнение функции и возвращает
управление в точку вызова.
Есть две формы:
return;
return выражение;
Форма return; используется в функциях типа void.
void stopIfNegative(int x)
{
if (x < 0)
{
return;
}
printf("%d\n", x);
}
Форма return выражение; используется в функциях,
возвращающих значение.
int square(int x)
{
return x * x;
}
Выражение после return должно быть совместимо с типом
возвращаемого значения функции.
Прототип функции
До вызова функции компилятор должен знать её тип результата, имя и типы параметров. Для этого используется прототип функции.
тип_результата имя_функции(спецификация_параметров);
Пример:
int sum(int a, int b);
Прототип похож на заголовок функции, но:
- заканчивается точкой с запятой;
- не имеет тела;
- может не содержать имён параметров.
Эти два прототипа эквивалентны:
double f(int n, float x);
double f(int, float);
Зачем нужен прототип
Прототип позволяет вызвать функцию до того, как в файле будет записано её полное определение.
#include <stdio.h>
int sum(int, int);
int main(void)
{
int result;
result = sum(10, 20);
printf("result = %d\n", result);
return 0;
}
int sum(int a, int b)
{
return a + b;
}
Когда компилятор встречает вызов sum(10, 20), он уже знает
из прототипа, что функция принимает два int и возвращает
int.
Определение функции и прототип — не одно и то же
Прототип только сообщает компилятору сведения о функции. Определение функции содержит настоящий код, который будет выполняться.
Прототип:
int max2(int a, int b);
Определение:
int max2(int a, int b)
{
if (a > b)
{
return a;
}
return b;
}
Прототип обычно размещают перед main, а определения
вспомогательных функций — после main.
Типы аргументов и параметры
При вызове функции типы аргументов должны соответствовать типам параметров.
int g(int a, long b);
g(10, 20L);
Если тип аргумента отличается, компилятор может выполнить автоматическое преобразование, если такое преобразование допустимо.
int g(int, long);
double x = 3.7;
g(x, 6.4e2);
По смыслу компилятор может преобразовать аргументы примерно так:
g((int)x, (long)6.4e2);
Но на такие преобразования нельзя бездумно полагаться. Например,
при преобразовании double к int дробная часть
будет потеряна.
Возвращаемое значение тоже приводится к типу функции
Если функция объявлена как возвращающая определённый тип, значение
в return должно быть совместимо с этим типом.
float ft(double x, int n)
{
if (x < n)
{
return x;
}
return n;
}
Функция возвращает float. Поэтому значения x
и n при возврате будут приведены к типу float.
Лучше сразу писать функции так, чтобы тип результата был выбран осознанно.
Передача параметров по значению
В языке C обычные параметры передаются в функцию по значению. Это означает, что функция получает копии значений аргументов.
#include <stdio.h>
void change(int x)
{
x = 100;
}
int main(void)
{
int a = 10;
change(a);
printf("%d\n", a);
return 0;
}
Программа выведет:
10
Функция change изменила свой локальный параметр
x, но переменная a в функции main
не изменилась.
Что происходит при передаче по значению
При вызове функции выполняются следующие действия:
- вычисляются значения аргументов;
- для параметров функции создаются внутренние объекты;
- значения аргументов записываются в параметры;
- тело функции работает с этими внутренними параметрами;
- после завершения функции параметры исчезают;
- исходные переменные вызывающей функции не меняются.
Поэтому обычная функция не может напрямую изменить переменную, переданную как аргумент. Для изменения внешних объектов используются указатели, которые будут подробно рассматриваться в следующем пункте.
Локальность параметров
Параметры функции являются локальными объектами этой функции. Они существуют только во время выполнения функции.
int square(int x)
{
return x * x;
}
Параметр x доступен только внутри функции
square. В функции main этого параметра нет.
int main(void)
{
printf("%d\n", x); /* ошибка: x здесь не определён */
return 0;
}
Порядок вычисления аргументов
При вызове функции не следует полагаться на конкретный порядок вычисления аргументов.
f(i++, i++);
Такая запись плоха: она изменяет одну и ту же переменную несколько раз в одном вызове, а порядок вычисления аргументов не стоит использовать как часть логики программы.
Лучше записать явно:
int a;
int b;
a = i;
i++;
b = i;
i++;
f(a, b);
Такой код длиннее, но он понятнее и не зависит от особенностей вычисления аргументов.
Функция main
Функция main — главная функция программы.
С неё начинается выполнение.
int main(void)
{
return 0;
}
Но с точки зрения синтаксиса main тоже является функцией:
у неё есть тип результата, имя, список параметров и тело.
Обычно функция main организует общий порядок работы
программы, а вспомогательные функции выполняют отдельные задачи.
Пример: функция для вычисления площади прямоугольника
#include <stdio.h>
double rectangleArea(double width, double height);
int main(void)
{
double width;
double height;
double area;
printf("Введите ширину и высоту: ");
scanf("%lf%lf", &width, &height);
area = rectangleArea(width, height);
printf("Площадь = %.2f\n", area);
return 0;
}
double rectangleArea(double width, double height)
{
return width * height;
}
Здесь функция rectangleArea отвечает только за вычисление
площади. Ввод и вывод находятся в main.
Пример: функция проверки числа
#include <stdio.h>
int isEven(int x);
int main(void)
{
int number;
printf("Введите число: ");
scanf("%d", &number);
if (isEven(number))
{
printf("Число чётное\n");
}
else
{
printf("Число нечётное\n");
}
return 0;
}
int isEven(int x)
{
return x % 2 == 0;
}
Функция isEven возвращает 1, если число чётное,
и 0, если число нечётное.
Пример: функция без возвращаемого значения
#include <stdio.h>
void printDate(int year, int month, int day);
int main(void)
{
printDate(2026, 5, 20);
return 0;
}
void printDate(int year, int month, int day)
{
printf("Год: %d, месяц: %d, день: %d\n", year, month, day);
}
Функция printDate выводит дату, но не возвращает значение.
Поэтому её тип результата — void.
Пример: функция без параметров
#include <stdio.h>
void printSeparator(void);
int main(void)
{
printSeparator();
printf("Раздел 1\n");
printSeparator();
return 0;
}
void printSeparator(void)
{
printf("--------------------\n");
}
Функция printSeparator не принимает параметры и ничего
не возвращает. Она просто выполняет действие — выводит разделитель.
Рекомендуемая структура однофайловой программы
В учебной программе удобно соблюдать такой порядок:
#include <stdio.h>
/* прототипы функций */
int sum(int, int);
void printResult(int);
int main(void)
{
int result;
result = sum(10, 20);
printResult(result);
return 0;
}
/* определения функций */
int sum(int a, int b)
{
return a + b;
}
void printResult(int value)
{
printf("result = %d\n", value);
}
Такой порядок помогает читать программу сверху вниз:
- сначала подключаются заголовочные файлы;
- затем идут прототипы;
- затем находится
main; - ниже расположены определения вспомогательных функций.
Функция как способ уменьшить main
Плохой признак — слишком длинная функция main, в которой
смешаны ввод, проверки, вычисления и вывод.
Лучше разделять программу на функции:
int readNumber(void);
int square(int x);
void printResult(int value);
Тогда main может выглядеть как краткое описание алгоритма:
int main(void)
{
int number;
int result;
number = readNumber();
result = square(number);
printResult(result);
return 0;
}
Такой код легче читать, потому что общий порядок действий виден сразу.
Типичные ошибки
Ошибка 1. Нет прототипа перед вызовом
int main(void)
{
printf("%d\n", sum(1, 2));
return 0;
}
int sum(int a, int b)
{
return a + b;
}
Лучше добавить прототип перед main:
int sum(int, int);
Ошибка 2. Прототип не совпадает с определением
double average(int, int);
int average(int a, int b)
{
return (a + b) / 2;
}
В прототипе указан результат double, а в определении —
int. Так делать нельзя.
Ошибка 3. Функция возвращает значение, но нет return
int sum(int a, int b)
{
int result = a + b;
}
Правильно:
int sum(int a, int b)
{
return a + b;
}
Ошибка 4. return с выражением в функции void
void printNumber(int x)
{
return x; /* ошибка */
}
Функция типа void не возвращает значение.
Ошибка 5. Ожидание, что обычный параметр изменит аргумент
void change(int x)
{
x = 100;
}
Эта функция изменяет только копию значения. Исходная переменная в вызывающей функции не изменится.
Ошибка 6. Неправильное количество аргументов
int sum(int a, int b);
sum(10); /* ошибка */
sum(1, 2, 3); /* ошибка */
Количество аргументов должно соответствовать количеству параметров, если функция не является функцией с переменным числом аргументов.
Ошибка 7. Вложенное определение функции
int main(void)
{
int helper(void)
{
return 1;
}
return 0;
}
В языке C функции не определяются внутри других функций.
Практические рекомендации
- Давай функциям понятные имена:
calculateArea,printArray,readNumber. - Одна функция должна выполнять одну основную задачу.
- Перед
mainразмещай прототипы вспомогательных функций. - Следи, чтобы прототип и определение функции совпадали.
- Если функция возвращает значение, обязательно используй
return выражение;. - Если функция ничего не возвращает, используй тип
void. - Не определяй функции внутри других функций.
- Не жди, что обычный параметр изменит переменную-аргумент.
- Не передавай в один вызов сложные выражения с несколькими изменениями одной переменной.
- Не делай
mainслишком длинной: выноси отдельные задачи в функции.
Мини-разбор программы
#include <stdio.h>
int readNumber(void);
int square(int x);
void printResult(int value);
int main(void)
{
int number;
int result;
number = readNumber();
result = square(number);
printResult(result);
return 0;
}
int readNumber(void)
{
int x;
printf("Введите число: ");
scanf("%d", &x);
return x;
}
int square(int x)
{
return x * x;
}
void printResult(int value)
{
printf("Результат = %d\n", value);
}
Разберём программу:
readNumberвводит число и возвращает его;squareполучает число и возвращает его квадрат;printResultвыводит результат и ничего не возвращает;- перед
mainзаписаны прототипы всех функций; mainпоказывает общий порядок работы программы.
Что нужно запомнить
- Функция — это именованная часть программы, выполняющая отдельную задачу.
- Определение функции состоит из заголовка и тела.
- Заголовок содержит тип результата, имя функции и параметры.
- Тело функции записывается в фигурных скобках.
- В C нельзя определять функцию внутри другой функции.
- Параметры указаны в заголовке функции.
- Аргументы передаются при вызове функции.
- Соответствие параметров и аргументов устанавливается по порядку.
- Вызов функции является выражением.
returnзавершает функцию и может вернуть значение.- Функция типа
voidне возвращает значение. - Прототип сообщает компилятору сведения о функции до её вызова.
- Прототип заканчивается точкой с запятой.
- Имена параметров в прототипе можно не указывать.
- В C параметры передаются по значению.
- Изменение обычного параметра внутри функции не изменяет аргумент вызывающей функции.
Самопроверка перед переходом дальше
- Что такое функция?
- Зачем программу разбивают на функции?
- Каков общий формат определения функции?
- Что входит в заголовок функции?
- Что находится в теле функции?
- Можно ли определить функцию внутри другой функции?
- Что такое тип возвращаемого значения?
- Что означает тип
void? - Чем параметр отличается от аргумента?
- Как устанавливается соответствие между параметрами и аргументами?
- Что такое прототип функции?
- Чем прототип отличается от определения функции?
- Почему прототип обычно размещают перед
main? - Что делает оператор
return? - Что означает передача параметров по значению?
- Почему функция
change(int x)не меняет исходную переменную? - Почему не стоит писать вызовы вида
f(i++, i++)?