2.5. Функции
Теория
Зачем нужен этот пункт
До этого программы в основном записывались внутри одной функции
main. Такой подход подходит для маленьких примеров, но
в реальных задачах программа быстро становится слишком длинной
и неудобной для чтения.
Функции позволяют разделить программу на логические части. Каждая функция выполняет свою небольшую задачу: вычисляет значение, печатает результат, проверяет данные, обрабатывает массив или выполняет другое действие.
В этом пункте рассматриваются:
- назначение функций;
- определение функции;
- заголовок и тело функции;
- параметры и аргументы;
- возврат результата через
return; - прототип функции;
- вызов функции;
- функции без возвращаемого значения;
- функции с массивами в параметрах;
- типичные ошибки при работе с функциями.
Что такое функция
Функция — это самостоятельная часть программы, имеющая имя, список параметров и тело. Функция может получать данные, выполнять действия и возвращать результат.
Функцию можно понимать как подпрограмму: основной код вызывает её, передаёт ей данные, а затем получает результат или просто продолжает выполнение после завершения функции.
double square(double x)
{
return x * x;
}
Эта функция называется square. Она получает одно значение
x, вычисляет квадрат этого значения и возвращает результат.
Зачем разбивать программу на функции
Функции нужны не только для сокращения кода. Они помогают строить программу правильно.
- Читаемость. Программу легче понимать, если она разбита на небольшие именованные части.
- Повторное использование. Одну и ту же функцию можно вызвать несколько раз.
-
Упрощение отладки. Маленькую функцию легче проверить,
чем большой фрагмент кода внутри
main. - Логическое разделение. Каждая функция отвечает за одну задачу.
- Подготовка к многофайловым программам. Позже функции можно будет выносить в отдельные файлы.
Плохой стиль — писать всю программу в main, если в ней уже
есть несколько разных задач: ввод, проверка, вычисление, вывод.
Общий вид определения функции
Определение функции состоит из заголовка и тела.
тип_результата имя_функции(список_параметров)
{
тело_функции;
}
Например:
int sum(int a, int b)
{
return a + b;
}
Здесь:
intперед именем функции — тип возвращаемого результата;sum— имя функции;int a, int b— параметры функции;{ ... }— тело функции;return a + b;— возврат результата.
Заголовок функции
Заголовок функции сообщает компилятору, как называется функция, какой результат она возвращает и какие параметры принимает.
double power(double x, int n)
В этом заголовке:
double— тип возвращаемого значения;power— имя функции;double x— первый параметр;int n— второй параметр.
Имя функции выбирается по тем же правилам, что и другие идентификаторы: оно не должно совпадать со служебными словами и должно быть понятным.
Хорошие имена функций:
calculateArea
printArray
findMax
isPositive
По имени функции должно быть понятно, что она делает.
Тело функции
Тело функции записывается в фигурных скобках. Внутри тела находятся объявления локальных переменных и операторы.
double circleArea(double radius)
{
double area;
area = 3.14159 * radius * radius;
return area;
}
Переменная area объявлена внутри функции. Такая переменная
называется локальной. Она существует только во время выполнения функции
и недоступна снаружи.
В языке C нельзя определять одну функцию внутри другой. Функции определяются отдельно друг от друга.
Нельзя:
int main(void)
{
int helper(void)
{
return 1;
}
return 0;
}
Правильно:
int helper(void)
{
return 1;
}
int main(void)
{
return helper();
}
Функция main тоже является функцией
Функция main — это главная функция программы. Выполнение
программы начинается именно с неё.
int main(void)
{
return 0;
}
Но с точки зрения языка main тоже функция: у неё есть
тип возвращаемого значения, имя, список параметров и тело.
Отличие main в том, что её вызывает не программист напрямую,
а среда выполнения программы. Остальные функции обычно вызываются
из main или из других функций.
Параметры и аргументы
Параметры — это переменные, указанные в заголовке функции. Они описывают, какие данные функция ожидает получить.
int sum(int a, int b)
Здесь a и b — параметры.
Аргументы — это реальные значения, которые передаются функции при вызове.
int result = sum(10, 20);
Здесь 10 и 20 — аргументы.
При вызове функции значения аргументов передаются в соответствующие параметры.
sum(10, 20)
a получает 10
b получает 20
Вызов функции
Чтобы выполнить функцию, её нужно вызвать. Вызов функции записывается как имя функции и список аргументов в круглых скобках.
имя_функции(список_аргументов)
Пример:
int result;
result = sum(3, 4);
После вызова функция sum получает аргументы 3
и 4, вычисляет результат и возвращает его в точку вызова.
Функцию можно вызывать несколько раз:
printf("%d\n", sum(1, 2));
printf("%d\n", sum(10, 20));
printf("%d\n", sum(-5, 7));
Оператор return
Оператор return завершает выполнение функции и возвращает
управление в точку вызова.
Есть две основные формы:
return;
return выражение;
Первая форма используется в функциях, которые не возвращают значение. Вторая форма используется в функциях, которые должны вернуть результат.
int sum(int a, int b)
{
return a + b;
}
Выражение после return должно иметь тип, совместимый
с типом результата функции.
double half(int x)
{
return x / 2.0;
}
Здесь функция возвращает значение типа double.
Функции, возвращающие значение
Если функция должна вычислить и вернуть результат, перед её именем указывают тип результата.
double rectangleArea(double width, double height)
{
return width * height;
}
Такую функцию можно использовать в выражениях:
double area;
area = rectangleArea(5.0, 3.0);
printf("area = %.2f\n", area);
Вызов функции rectangleArea(5.0, 3.0) после выполнения
заменяется её результатом.
Функции без возвращаемого значения
Если функция не должна возвращать значение, перед её именем указывают
тип void.
void printLine(void)
{
printf("--------------------\n");
}
Такая функция выполняет действие, но не возвращает результат. Её вызывают как отдельный оператор:
printLine();
В функции типа void можно использовать return;
без выражения, чтобы досрочно завершить функцию.
void printPositive(int x)
{
if (x <= 0)
{
return;
}
printf("%d\n", x);
}
Функции без параметров
Если функция не принимает параметры, в скобках лучше явно писать
void.
void hello(void)
{
printf("Hello!\n");
}
Вызов такой функции:
hello();
Пустые круглые скобки при вызове всё равно обязательны. Без них имя функции не будет означать вызов.
hello; /* не вызов функции */
hello(); /* вызов функции */
Прототип функции
Перед вызовом функции компилятор должен знать её имя, тип результата и типы параметров. Для этого используется прототип функции.
Общая форма прототипа:
тип_результата имя_функции(список_типов_параметров);
Пример:
int sum(int a, int b);
Прототип похож на заголовок функции, но заканчивается точкой с запятой и не имеет тела.
Имена параметров в прототипе можно указывать, а можно опускать.
double f(int n, float x);
double f(int, float);
Эти два прототипа сообщают компилятору одно и то же: функция
f возвращает double и принимает параметры
типов 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), он уже знает
из прототипа, что функция sum существует, принимает два
значения типа int и возвращает int.
Без прототипа компилятор может не иметь достаточно информации для правильной проверки вызова.
Где размещать функции в файле
В учебной однофайловой программе удобно использовать такую структуру:
#include <stdio.h>
/* прототипы функций */
int sum(int, int);
void printResult(int);
int main(void)
{
int result;
result = sum(3, 4);
printResult(result);
return 0;
}
/* определения функций */
int sum(int a, int b)
{
return a + b;
}
void printResult(int value)
{
printf("result = %d\n", value);
}
Такая организация удобна:
- сначала подключаются заголовочные файлы;
- затем идут прототипы;
- затем функция
main; - ниже — определения вспомогательных функций.
Локальные переменные функции
Переменные, объявленные внутри функции, являются локальными. Они доступны только внутри этой функции.
int square(int x)
{
int result;
result = x * x;
return result;
}
Переменная result существует только внутри функции
square. В функции main к ней обратиться нельзя.
int main(void)
{
printf("%d\n", result); /* ошибка: result здесь не определена */
return 0;
}
Это полезно: разные функции могут иметь локальные переменные с одинаковыми именами, и они не будут мешать друг другу.
Передача параметров по значению
В языке C обычные параметры передаются в функцию по значению. Это означает, что функция получает копии переданных значений.
void change(int x)
{
x = 100;
}
int main(void)
{
int a = 10;
change(a);
printf("%d\n", a);
return 0;
}
После вызова change(a) переменная a останется
равной 10. Функция изменила только свою локальную копию
параметра x, а не исходную переменную a.
Если нужно изменить переменную вызывающей функции, позже будут использоваться указатели. В этой главе достаточно запомнить: обычные параметры не позволяют напрямую изменить исходные переменные.
Пример: функция вычисления максимума
#include <stdio.h>
int max2(int a, int b);
int main(void)
{
int x;
int y;
int m;
printf("Введите x и y: ");
scanf("%d%d", &x, &y);
m = max2(x, y);
printf("max = %d\n", m);
return 0;
}
int max2(int a, int b)
{
if (a > b)
{
return a;
}
return b;
}
Функция max2 получает два целых числа и возвращает большее.
В main она вызывается с аргументами x и y,
а результат сохраняется в переменной m.
Обрати внимание: если условие a > b истинно, выполняется
return a;, и функция сразу завершается. Если условие ложно,
выполнение доходит до return b;.
Пример: функция проверки числа
Функция может возвращать результат, который используется как условие.
#include <stdio.h>
int isEven(int number);
int main(void)
{
int x;
printf("Введите число: ");
scanf("%d", &x);
if (isEven(x))
{
printf("Число чётное\n");
}
else
{
printf("Число нечётное\n");
}
return 0;
}
int isEven(int number)
{
return number % 2 == 0;
}
Функция isEven возвращает 1, если число чётное,
и 0, если число нечётное. Такое имя функции удобно читать:
if (isEven(x)) почти читается как обычная фраза.
Пример: функция для площади треугольника
Функции удобно использовать для отдельных математических вычислений. Например, площадь треугольника по трём сторонам можно вычислить по формуле Герона.
#include <stdio.h>
#include <math.h>
double triangleArea(double a, double b, double c);
int main(void)
{
double a;
double b;
double c;
double area;
printf("Введите стороны треугольника: ");
scanf("%lf%lf%lf", &a, &b, &c);
if (a + b <= c || a + c <= b || b + c <= a)
{
printf("Треугольник построить нельзя\n");
return 0;
}
area = triangleArea(a, b, c);
printf("Площадь = %f\n", area);
return 0;
}
double triangleArea(double a, double b, double c)
{
double p;
p = (a + b + c) / 2.0;
return sqrt(p * (p - a) * (p - b) * (p - c));
}
Функция triangleArea отвечает только за вычисление площади.
Проверка корректности сторон выполняется в main. Такое
разделение делает программу понятнее.
Для функции sqrt подключается заголовочный файл
math.h.
Досрочное завершение функции
Оператор return можно использовать не только в конце функции,
но и раньше, если дальнейшее выполнение не нужно.
int safeDivide(int a, int b)
{
if (b == 0)
{
return 0;
}
return a / b;
}
Если b равно нулю, функция сразу возвращает 0
и не выполняет деление. Если b не равно нулю, выполняется
обычный расчёт.
Досрочный return часто используют для обработки ошибочных
ситуаций и проверки входных данных.
Функция exit
Иногда нужно завершить не только текущую функцию, а всю программу.
Для этого в стандартной библиотеке есть функция exit.
#include <stdlib.h>
exit(1);
Функция exit завершает выполнение программы. Её прототип
находится в заголовочном файле stdlib.h.
В простых учебных программах чаще достаточно использовать
return из функции main. Но если ошибка обнаружена
глубоко внутри вспомогательной функции, exit может быть
способом аварийно завершить всю программу.
#include <stdio.h>
#include <stdlib.h>
double checkedSqrt(double x)
{
if (x < 0.0)
{
printf("Ошибка: отрицательное подкоренное выражение\n");
exit(1);
}
return sqrt(x);
}
На начальном этапе не стоит злоупотреблять exit. Часто лучше
вернуть код ошибки и обработать его в вызывающей функции.
Функции и массивы
Функция может получать массив в качестве параметра. Это удобно, если нужно вынести обработку массива в отдельную часть программы.
Например, функция для вычисления суммы элементов массива:
int arraySum(int a[], int n)
{
int i;
int sum = 0;
for (i = 0; i < n; i++)
{
sum += a[i];
}
return sum;
}
Здесь:
a[]— параметр-массив;n— количество используемых элементов;- цикл проходит по элементам от
0доn - 1; - функция возвращает сумму.
Размер массива обычно передают отдельным параметром, потому что внутри функции нужно знать, сколько элементов нужно обработать.
Пример: сумма массива через функцию
#include <stdio.h>
int arraySum(int a[], int n);
int main(void)
{
int numbers[100];
int n;
int i;
int sum;
printf("Введите n: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
printf("numbers[%d] = ", i);
scanf("%d", &numbers[i]);
}
sum = arraySum(numbers, n);
printf("Сумма = %d\n", sum);
return 0;
}
int arraySum(int a[], int n)
{
int i;
int sum = 0;
for (i = 0; i < n; i++)
{
sum += a[i];
}
return sum;
}
В main выполняется ввод данных и вывод результата.
Функция arraySum отвечает только за вычисление суммы.
Такое разделение делает программу аккуратнее.
Скалярное произведение векторов
Скалярное произведение двух векторов одинаковой размерности вычисляется как сумма произведений соответствующих координат.
a[0] * b[0] + a[1] * b[1] + ... + a[n - 1] * b[n - 1]
Функция для вычисления скалярного произведения:
double scalarProduct(int n, double a[], double b[])
{
int i;
double result = 0.0;
for (i = 0; i < n; i++)
{
result += a[i] * b[i];
}
return result;
}
Использование функции:
#include <stdio.h>
#define MAX_SIZE 100
double scalarProduct(int n, double a[], double b[]);
int main(void)
{
int n;
int i;
double x[MAX_SIZE];
double y[MAX_SIZE];
double result;
printf("Введите размерность векторов: ");
scanf("%d", &n);
if (n < 1 || n > MAX_SIZE)
{
printf("Ошибка в данных\n");
return 0;
}
printf("Введите координаты первого вектора:\n");
for (i = 0; i < n; i++)
{
scanf("%lf", &x[i]);
}
printf("Введите координаты второго вектора:\n");
for (i = 0; i < n; i++)
{
scanf("%lf", &y[i]);
}
result = scalarProduct(n, x, y);
printf("Скалярное произведение = %.3f\n", result);
return 0;
}
double scalarProduct(int n, double a[], double b[])
{
int i;
double result = 0.0;
for (i = 0; i < n; i++)
{
result += a[i] * b[i];
}
return result;
}
Здесь массивы x и y передаются в функцию
scalarProduct. Размерность n передаётся отдельно.
Что важно знать о массивах в параметрах
Когда массив передаётся в функцию, функция получает доступ к его элементам. Поэтому внутри функции можно читать элементы массива.
int firstElement(int a[])
{
return a[0];
}
Также функция может изменить элементы массива.
void fillZero(int a[], int n)
{
int i;
for (i = 0; i < n; i++)
{
a[i] = 0;
}
}
После вызова fillZero(numbers, n) элементы массива
numbers в функции main действительно станут нулевыми.
Это отличается от обычной передачи переменных типа int,
double и других базовых типов, где функция получает копию
значения.
Функция для вывода массива
Вывод массива — хорошая задача для отдельной функции.
void printArray(int a[], int n)
{
int i;
for (i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
Тогда в main можно писать коротко:
printArray(numbers, n);
Это особенно удобно, если массив нужно выводить несколько раз: до обработки, после обработки, после сортировки и так далее.
Функция для поиска максимума в массиве
int maxElement(int a[], int n)
{
int i;
int max = a[0];
for (i = 1; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
}
return max;
}
Перед вызовом такой функции нужно убедиться, что n > 0.
Иначе обращение к a[0] будет ошибочным.
if (n > 0)
{
printf("max = %d\n", maxElement(a, n));
}
Разделение программы на функции
Хорошая программа строится из функций, каждая из которых имеет одну понятную задачу.
Например, программу обработки массива можно разделить так:
readArray— ввод элементов массива;printArray— вывод массива;arraySum— вычисление суммы;maxElement— поиск максимума;main— общий порядок работы программы.
int readArray(int a[], int maxSize);
void printArray(int a[], int n);
int arraySum(int a[], int n);
int maxElement(int a[], int n);
Такой подход делает программу более структурированной: функция
main не содержит всех деталей сразу, а только управляет
последовательностью действий.
Пример структурированной программы
#include <stdio.h>
#define MAX_SIZE 100
int readArray(int a[], int maxSize);
void printArray(int a[], int n);
int arraySum(int a[], int n);
int maxElement(int a[], int n);
int main(void)
{
int a[MAX_SIZE];
int n;
n = readArray(a, MAX_SIZE);
if (n == 0)
{
printf("Нет данных для обработки\n");
return 0;
}
printf("Массив: ");
printArray(a, n);
printf("Сумма = %d\n", arraySum(a, n));
printf("Максимум = %d\n", maxElement(a, n));
return 0;
}
int readArray(int a[], int maxSize)
{
int n;
int i;
printf("Введите n: ");
scanf("%d", &n);
if (n < 1 || n > maxSize)
{
return 0;
}
for (i = 0; i < n; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
return n;
}
void printArray(int a[], int n)
{
int i;
for (i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int arraySum(int a[], int n)
{
int i;
int sum = 0;
for (i = 0; i < n; i++)
{
sum += a[i];
}
return sum;
}
int maxElement(int a[], int n)
{
int i;
int max = a[0];
for (i = 1; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
}
return max;
}
В этом примере каждая функция отвечает за свою часть работы. Программа стала длиннее по количеству строк, но логически она стала проще: каждую часть можно читать и проверять отдельно.
Функции и повторное использование кода
Если один и тот же фрагмент программы нужен несколько раз, его часто стоит оформить как функцию.
Плохой вариант:
printf("--------------------\n");
printf("Раздел 1\n");
printf("--------------------\n");
printf("--------------------\n");
printf("Раздел 2\n");
printf("--------------------\n");
Лучше:
void printSeparator(void)
{
printf("--------------------\n");
}
printSeparator();
printf("Раздел 1\n");
printSeparator();
printSeparator();
printf("Раздел 2\n");
printSeparator();
Если способ вывода разделителя изменится, достаточно изменить одну функцию, а не искать одинаковые фрагменты по всей программе.
Как выбирать, что выносить в функцию
В функцию стоит выносить фрагмент кода, если:
- он выполняет одну понятную задачу;
- он повторяется в программе;
- он слишком загромождает
main; - его удобно проверить отдельно;
- его можно назвать понятным именем.
Не стоит создавать функцию ради одной строки, если от этого программа становится только сложнее. Функция должна улучшать структуру программы, а не просто увеличивать количество имён.
Типичные ошибки
Ошибка 1. Нет прототипа перед вызовом
int main(void)
{
int result = 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. Попытка изменить обычный параметр
void change(int x)
{
x = 100;
}
Такая функция изменяет только локальную копию. Исходная переменная в вызывающей функции не изменится.
Ошибка 5. Неправильное количество аргументов
int sum(int a, int b)
{
return a + b;
}
int x = sum(10); /* ошибка */
Функция ожидает два аргумента, а передан только один.
Ошибка 6. Вложенное определение функции
int main(void)
{
int helper(void)
{
return 1;
}
return 0;
}
В C нельзя определять функцию внутри другой функции.
Ошибка 7. Массив передали, но не передали размер
int arraySum(int a[])
{
int i;
int sum = 0;
for (i = 0; i < 100; i++)
{
sum += a[i];
}
return sum;
}
Функция не знает, сколько элементов действительно нужно обработать. Лучше передавать размер отдельным параметром:
int arraySum(int a[], int n)
Практические рекомендации
- Давайте функциям имена, которые описывают действие.
- Одна функция должна выполнять одну основную задачу.
- Перед
mainразмещайте прототипы вспомогательных функций. - Следите, чтобы прототип и определение функции совпадали.
- Если функция возвращает значение, обязательно возвращайте его через
return. - Для функции без результата используйте
void. - Не определяйте функции внутри других функций.
- Для массивов передавайте не только сам массив, но и количество элементов.
- Не делайте
mainслишком длинной: выносите отдельные задачи в функции. - Не создавайте функцию, если она не улучшает читаемость и структуру программы.
Мини-разбор программы
Программа вводит два числа, вычисляет максимум и среднее значение с помощью функций.
#include <stdio.h>
int max2(int a, int b);
double average2(int a, int b);
void printResult(int maxValue, double averageValue);
int main(void)
{
int x;
int y;
int maxValue;
double averageValue;
printf("Введите два целых числа: ");
scanf("%d%d", &x, &y);
maxValue = max2(x, y);
averageValue = average2(x, y);
printResult(maxValue, averageValue);
return 0;
}
int max2(int a, int b)
{
if (a > b)
{
return a;
}
return b;
}
double average2(int a, int b)
{
return (a + b) / 2.0;
}
void printResult(int maxValue, double averageValue)
{
printf("Максимум = %d\n", maxValue);
printf("Среднее = %.2f\n", averageValue);
}
Разберём программу:
max2возвращает большее из двух чисел;average2возвращает среднее значение;printResultвыводит результаты и ничего не возвращает;- перед
mainразмещены прототипы всех вспомогательных функций; mainуправляет общей последовательностью действий.
Что нужно запомнить
- Функция — это именованная часть программы, выполняющая отдельную задачу.
- Определение функции состоит из заголовка и тела.
- Заголовок функции содержит тип результата, имя и параметры.
- Тело функции записывается в фигурных скобках.
- В C нельзя определять функцию внутри другой функции.
- Параметры указываются в заголовке функции, аргументы передаются при вызове.
- Обычные параметры передаются по значению, то есть функция получает копии.
returnзавершает функцию и может вернуть результат.- Функции типа
voidне возвращают значение. - Прототип сообщает компилятору сведения о функции до её вызова.
- Прототип может не содержать имён параметров, но должен содержать их типы.
- Массивы можно передавать в функции как параметры.
- При передаче массива обычно нужно отдельно передавать количество элементов.
- Функции помогают сделать программу структурированной и читаемой.
Самопроверка перед переходом дальше
- Что такое функция?
- Зачем программу разбивают на функции?
- Из каких частей состоит определение функции?
- Что такое заголовок функции?
- Что такое тело функции?
- Чем параметр отличается от аргумента?
- Что делает оператор
return? - Что означает тип результата
void? - Что такое прототип функции?
- Почему прототип должен быть известен до вызова функции?
- Можно ли определить функцию внутри функции
main? - Почему обычный параметр функции нельзя использовать для изменения исходной переменной?
- Зачем при передаче массива в функцию передавать ещё и его размер?
- Какие части программы удобно выносить в отдельные функции?