2.5. Функции

Теория

Зачем нужен этот пункт

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

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

В этом пункте рассматриваются:

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

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

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

double square(double x)
{
    return x * x;
}

Эта функция называется square. Она получает одно значение x, вычисляет квадрат этого значения и возвращает результат.

Зачем разбивать программу на функции

Функции нужны не только для сокращения кода. Они помогают строить программу правильно.

Плохой стиль — писать всю программу в main, если в ней уже есть несколько разных задач: ввод, проверка, вычисление, вывод.

Общий вид определения функции

Определение функции состоит из заголовка и тела.

тип_результата имя_функции(список_параметров)
{
    тело_функции;
}

Например:

int sum(int a, int b)
{
    return a + b;
}

Здесь:

Заголовок функции

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

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);
}

Такая организация удобна:

Локальные переменные функции

Переменные, объявленные внутри функции, являются локальными. Они доступны только внутри этой функции.

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;
}

Здесь:

Размер массива обычно передают отдельным параметром, потому что внутри функции нужно знать, сколько элементов нужно обработать.

Пример: сумма массива через функцию

#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));
}

Разделение программы на функции

Хорошая программа строится из функций, каждая из которых имеет одну понятную задачу.

Например, программу обработки массива можно разделить так:

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();

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

Как выбирать, что выносить в функцию

В функцию стоит выносить фрагмент кода, если:

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

Типичные ошибки

Ошибка 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)

Практические рекомендации

Мини-разбор программы

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

#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);
}

Разберём программу:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Что такое функция?
  2. Зачем программу разбивают на функции?
  3. Из каких частей состоит определение функции?
  4. Что такое заголовок функции?
  5. Что такое тело функции?
  6. Чем параметр отличается от аргумента?
  7. Что делает оператор return?
  8. Что означает тип результата void?
  9. Что такое прототип функции?
  10. Почему прототип должен быть известен до вызова функции?
  11. Можно ли определить функцию внутри функции main?
  12. Почему обычный параметр функции нельзя использовать для изменения исходной переменной?
  13. Зачем при передаче массива в функцию передавать ещё и его размер?
  14. Какие части программы удобно выносить в отдельные функции?