Исполняемые доки C: функции

Q: Почему main возвращает int в C?

Возвращаемое значение main — это код завершения программы, который могут прочитать операционная система и скрипты оболочки. return 0; означает успех, любое ненулевое значение — неудачу. Начиная с C99, достижение конца main без return неявно возвращает 0.

Q: Может ли функция C вернуть больше одного значения?

Напрямую нет — return даёт ровно одно значение. Обычные обходные пути: вернуть структуру с несколькими полями либо передать указатели параметрами и записать дополнительные результаты через них.

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

Всё до сих пор жило внутри main. Это работает, пока программа делает одно дело, а затем сразу приходят три проблемы: один и тот же блок кода копируется в три места, main разрастается больше, чем кто-либо способен удержать в голове, и нет способа назвать, для чего нужен кусок кода.

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

#include <stdio.h>

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

int main(void) {
    printf("%d\n", square(4));
    printf("%d\n", square(9));
    printf("%d\n", square(square(2)));
    return 0;
}

square написана один раз и вызвана трижды, в том числе один раз на собственном результате. Вы уже вызывали функции — printf одна из них, и main тоже.

Анатомия функции

returnType name(parameterList) {
    // тело
    return value;
}

Четыре части:

Тип возвращаемого значения — тип значения, которое функция отдаёт обратно. int, double, char, тип указателя или void для «ничего».
Имя — подчиняется тем же правилам, что и имя переменной, и должно говорить, что функция делает или производит.
Список параметров — входные данные, каждый со своим типом, через запятую. (void) означает, что параметров нет.
Тело — инструкции в фигурных скобках, завершающиеся return, если тип возвращаемого значения не void.

#include <stdio.h>

/* принимает два int, производит один int */
int add(int a, int b) {
    return a + b;
}

/* ничего не принимает, производит double */
double pi(void) {
    return 3.14159265358979;
}

/* принимает int, ничего не производит */
void printBanner(int width) {
    for (int i = 0; i < width; i++) {
        printf("=");
    }
    printf("\n");
}

int main(void) {
    printBanner(20);
    printf("2 + 3 = %d\n", add(2, 3));
    printf("пи     = %f\n", pi());
    printBanner(20);
    return 0;
}

Обратите внимание, что pi() всё равно нужны пустые скобки в месте вызова — именно они делают это вызовом, а не упоминанием имени. А printBanner(20); — самостоятельная инструкция, потому что она не производит значения, которое можно было бы использовать.

Для функции без параметров пишите (void), а не (). В C это разные вещи, и () — более слабый вариант; подробнее об этом чуть ниже.

Вызов и возврат

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

#include <stdio.h>

int larger(int a, int b) {
    if (a > b) {
        return a;      /* немедленно покидает функцию */
    }
    return b;
}

int main(void) {
    int x = larger(17, 42);
    printf("larger(17, 42) = %d\n", x);
    printf("вложенный вызов: %d\n", larger(larger(3, 9), 5));
    return 0;
}

return делает две вещи сразу: отдаёт значение и завершает функцию на месте. Всё, что идёт после return на том же пути, никогда не выполняется — именно это позволяет работать стилю раннего возврата в larger: else не нужен, потому что достижение последней строки уже означает, что a > b было ложно.

У функции может быть несколько return. Но за один вызов выполнится только один из них.

Функции void

Функция, которая существует ради эффекта, а не ради значения, имеет тип void: вывод, изменение чего-то через указатель, рисование.

#include <stdio.h>

void printTable(int n, int upTo) {
    for (int i = 1; i <= upTo; i++) {
        printf("%d x %d = %d\n", n, i, n * i);
    }
}

void warn(const char *message, int enabled) {
    if (!enabled) {
        return;            /* голый return: просто выйти раньше */
    }
    printf("ВНИМАНИЕ: %s\n", message);
}

int main(void) {
    printTable(7, 5);
    warn("мало места на диске", 1);
    warn("а это сообщение подавлено", 0);
    return 0;
}

Внутри функции void инструкция return; без значения завершает её раньше. return someValue; там — ошибка компиляции, как и использование вызова в выражении: int x = printTable(7, 5); не скомпилируется, и это система типов делает свою работу.

Декомпозиция: настоящий смысл

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

#include <stdio.h>

double average(const int values[], int count) {
    if (count == 0) {
        return 0.0;
    }
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += values[i];
    }
    return (double) total / count;
}

int highest(const int values[], int count) {
    int best = values[0];
    for (int i = 1; i < count; i++) {
        if (values[i] > best) {
            best = values[i];
        }
    }
    return best;
}

int countAbove(const int values[], int count, int threshold) {
    int n = 0;
    for (int i = 0; i < count; i++) {
        if (values[i] > threshold) {
            n++;
        }
    }
    return n;
}

int main(void) {
    int scores[] = {88, 92, 75, 60, 100, 47, 83};
    int n = sizeof(scores) / sizeof(scores[0]);

    double avg = average(scores, n);

    printf("Количество:       %d\n", n);
    printf("Среднее:          %.2f\n", avg);
    printf("Максимум:         %d\n", highest(scores, n));
    printf("Выше среднего:    %d\n", countAbove(scores, n, (int) avg));
    return 0;
}

Теперь main — это четыре строки вывода и одно вычисление. Каждая вспомогательная функция делает одно дело, носит имя, которое говорит, какое именно, и может быть протестирована отдельно. Обратите внимание, что длина массива путешествует вторым параметром: как только массив передан в функцию, трюк с sizeof там уже не работает, потому что массив низводится до указателя.

Три практических правила разбиения работы на функции:

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

Функции, вызывающие функции

Функция может вызывать любую уже объявленную функцию, включая написанные вами:

#include <stdio.h>

int isEven(int n) {
    return n % 2 == 0;
}

int sumEvens(const int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        if (isEven(a[i])) {
            total += a[i];
        }
    }
    return total;
}

void report(const int a[], int n) {
    printf("Сумма чётных значений: %d\n", sumEvens(a, n));
}

int main(void) {
    int data[] = {3, 8, 12, 5, 7, 20};
    report(data, sizeof(data) / sizeof(data[0]));
    return 0;
}

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

Определения выше идут в порядке зависимостей — isEven перед sumEvens, sumEvens перед report, — потому что C требует, чтобы функция была объявлена до вызова. Вызовите ту, что расположена ниже по файлу, и компилятор пожалуется на неявное объявление. Общее решение — прототип в начале файла, который позволяет располагать определения в любом порядке. Функция, вызывающая саму себя, тоже законна и полезна; это рекурсия.

main — это функция

main — обычная функция, которую за вас вызывает среда выполнения. Её тип int — это код завершения программы: 0 означает успех, ненулевое — неудачу, и его читают скрипты оболочки и инструменты сборки.

int main(void) {
    /* ... */
    return 0;
}

Начиная с C99, выход за конец main без return неявно возвращает 0 — особое правило, действующее только для main. Любая другая не-void функция, завершившаяся без возврата значения, порождает неопределённое поведение, когда вызывающий использует результат.

Другая стандартная форма — int main(int argc, char *argv[]), которая принимает аргументы командной строки. Обе корректны; void main() — нет, что бы ни говорили старые учебники.

Распространённые ошибки

Забытый return в не-void функции. Вызывающий тогда читает мусорное значение. gcc -Wall предупреждает.
Объявление внутри тела переменной с именем параметра. Она затеняет параметр, и присваивание, которое вы хотели сделать входному значению, уходит в никуда.
Ожидание, что функция изменит свои аргументы. C передаёт всё по значению, поэтому функция получает копии. void reset(int x) { x = 0; } ничего не меняет в месте вызова — тема следующей страницы.
Пропуск скобок при вызове. printBanner; — законное выражение, которое вычисляет адрес функции и отбрасывает его. Оно компилируется, ничего не делает, и -Wall на него указывает.
Запись () вместо (void). Законно, но в старых диалектах C это отключает проверку аргументов.

Часто задаваемые вопросы

Как объявить функцию в C?

Напишите тип возвращаемого значения, имя и список параметров в круглых скобках, затем тело в фигурных скобках: int add(int a, int b) { return a + b; }. Функция, которая ничего не принимает, использует (void), а та, что ничего не возвращает, имеет тип void.

Что делает return в функции C?

Он немедленно завершает функцию и передаёт значение вызывающему коду. Тип значения должен совпадать с объявленным типом возвращаемого значения. В функции void можно написать голый return;, чтобы выйти раньше, либо не писать его вовсе и дать функции закончиться на закрывающей скобке.

Почему main возвращает int в C?

Возвращаемое значение main — это код завершения программы, который могут прочитать операционная система и скрипты оболочки. return 0; означает успех, любое ненулевое значение — неудачу. Начиная с C99, достижение конца main без return неявно возвращает 0.

Может ли функция C вернуть больше одного значения?

Напрямую нет — return даёт ровно одно значение. Обычные обходные пути: вернуть структуру с несколькими полями либо передать указатели параметрами и записать дополнительные результаты через них.

Связанные концепции