5.1. Общие сведения о функциях

Теория

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

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

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

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

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

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

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

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

С одной стороны, функция является производным типом языка C. С другой стороны, функция — это минимальный исполняемый модуль программы: отдельный фрагмент кода, который можно вызвать из другого места программы.

Зачем нужны функции

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

Функции помогают:

Хорошая функция обычно выполняет одну основную задачу.

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

Определение функции в C имеет общий вид:

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

Пример:

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)

Здесь:

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

Функция без параметров

Если функция не принимает параметры, в скобках лучше явно писать 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);

При таком вызове:

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

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

имя_функции(список_аргументов)

Пример:

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 не изменилась.

Что происходит при передаче по значению

При вызове функции выполняются следующие действия:

  1. вычисляются значения аргументов;
  2. для параметров функции создаются внутренние объекты;
  3. значения аргументов записываются в параметры;
  4. тело функции работает с этими внутренними параметрами;
  5. после завершения функции параметры исчезают;
  6. исходные переменные вызывающей функции не меняются.

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

Локальность параметров

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

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, в которой смешаны ввод, проверки, вычисления и вывод.

Лучше разделять программу на функции:

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 функции не определяются внутри других функций.

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

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

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

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

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

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

  1. Что такое функция?
  2. Зачем программу разбивают на функции?
  3. Каков общий формат определения функции?
  4. Что входит в заголовок функции?
  5. Что находится в теле функции?
  6. Можно ли определить функцию внутри другой функции?
  7. Что такое тип возвращаемого значения?
  8. Что означает тип void?
  9. Чем параметр отличается от аргумента?
  10. Как устанавливается соответствие между параметрами и аргументами?
  11. Что такое прототип функции?
  12. Чем прототип отличается от определения функции?
  13. Почему прототип обычно размещают перед main?
  14. Что делает оператор return?
  15. Что означает передача параметров по значению?
  16. Почему функция change(int x) не меняет исходную переменную?
  17. Почему не стоит писать вызовы вида f(i++, i++)?