5.5. Функции с переменным количеством аргументов

Теория

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

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

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

Такая функция всегда принимает ровно два аргумента. Но иногда нужно написать функцию, которая может принимать разное количество аргументов.

Например:

sum(3, 10, 20, 30);
sum(5, 1, 2, 3, 4, 5);
average(4, 2.5, 3.0, 7.5, 10.0);

Такие функции называются функциями с переменным количеством аргументов.

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

Пример знакомой функции

Самый известный пример функции с переменным количеством аргументов — printf.

printf("Hello\n");
printf("x = %d\n", x);
printf("x = %d, y = %d\n", x, y);
printf("%d %f %c\n", number, value, symbol);

Вызовы разные: где-то передаётся только строка формата, где-то строка формата и одно значение, где-то строка формата и несколько значений.

Первый аргумент printf — обязательный. Это строка формата. По ней функция понимает, сколько дополнительных аргументов нужно прочитать и каких они должны быть типов.

Обычная функция и функция с переменным списком

Обычная функция:

int sum2(int a, int b);

принимает строго два аргумента.

Функция с переменным количеством аргументов:

int sum(int count, ...);

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

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

Общий формат прототипа

Общий вид прототипа функции с переменным количеством аргументов:

тип_результата имя_функции(обязательные_параметры, ...);

Примеры:

int sum(int count, ...);
double average(int count, ...);
void printInts(int count, ...);
int maxInt(int count, ...);

Перед многоточием должен быть хотя бы один обычный параметр.

Правильно:

int sum(int count, ...);

Неправильно:

int sum(...);

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

Как функция узнаёт количество аргументов

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

Поэтому программист должен сам выбрать способ определения конца списка.

Обычно используют один из двух подходов:

Первый подход:

sum(3, 10, 20, 30);

Здесь 3 означает, что дальше идут три числа.

Второй подход:

sumUntilZero(10, 20, 30, 0);

Здесь 0 может использоваться как специальный признак конца.

Подключение stdarg.h

Для стандартной работы с переменным списком аргументов используется заголовочный файл stdarg.h.

#include <stdarg.h>

В нём определены:

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

Основные средства stdarg.h

Средство Назначение
va_list тип объекта для перебора переменного списка аргументов
va_start начинает обработку переменного списка
va_arg получает очередной аргумент указанного типа
va_end завершает обработку переменного списка

Типичная схема работы:

va_list args;

va_start(args, последний_обязательный_параметр);

/* чтение аргументов через va_arg */

va_end(args);

va_list

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

va_list args;

Объект args хранит внутреннее состояние перебора: где сейчас находится функция внутри переменного списка аргументов.

Программист не должен самостоятельно изменять этот объект. Для работы с ним используются только стандартные макросы: va_start, va_arg, va_end.

va_start

Макрос va_start подготавливает объект va_list к чтению переменного списка аргументов.

va_start(args, last);

Здесь:

Например, если функция объявлена так:

int sum(int count, ...)

то внутри неё нужно написать:

va_start(args, count);

Потому что count — последний обязательный параметр перед ....

va_arg

Макрос va_arg получает очередной аргумент из переменного списка.

va_arg(args, тип)

Он делает две вещи:

Например:

int value;

value = va_arg(args, int);

Эта строка читает очередной аргумент как int.

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

va_end

Макрос va_end завершает работу с переменным списком аргументов.

va_end(args);

Его нужно вызвать после окончания чтения аргументов.

После va_end объект va_list нельзя использовать для дальнейшего чтения, пока снова не будет вызван va_start.

Правильная схема:

va_list args;

va_start(args, count);

/* чтение аргументов */

va_end(args);

Пример: сумма целых чисел

#include <stdio.h>
#include <stdarg.h>

int sum(int count, ...);

int main(void)
{
    printf("%d\n", sum(3, 10, 20, 30));
    printf("%d\n", sum(5, 1, 2, 3, 4, 5));

    return 0;
}

int sum(int count, ...)
{
    int i;
    int result = 0;
    va_list args;

    va_start(args, count);

    for (i = 0; i < count; i++)
    {
        result += va_arg(args, int);
    }

    va_end(args);

    return result;
}

Вызов:

sum(3, 10, 20, 30)

означает: дальше после count идут три целых числа.

Цикл выполняется count раз. На каждой итерации va_arg(args, int) читает очередной аргумент как значение типа int.

Пример: среднее значение

#include <stdio.h>
#include <stdarg.h>

double average(int count, ...);

int main(void)
{
    printf("%.2f\n", average(3, 10.0, 20.0, 30.0));
    printf("%.2f\n", average(4, 2.5, 3.5, 4.5, 5.5));

    return 0;
}

double average(int count, ...)
{
    int i;
    double sum = 0.0;
    va_list args;

    if (count <= 0)
    {
        return 0.0;
    }

    va_start(args, count);

    for (i = 0; i < count; i++)
    {
        sum += va_arg(args, double);
    }

    va_end(args);

    return sum / count;
}

Здесь дополнительные аргументы читаются как double. Поэтому в вызове нужно передавать вещественные значения:

average(3, 10.0, 20.0, 30.0)

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

Функция сама не проверяет типы дополнительных аргументов

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

int sum2(int a, int b);

А у переменной части списка типы не указаны в прототипе.

double average(int count, ...);

Поэтому компилятор не может полностью проверить правильность дополнительных аргументов.

Например, функция ожидает double:

sum += va_arg(args, double);

Значит, при вызове нужно передавать именно значения, которые будут корректно прочитаны как double.

average(3, 1.0, 2.0, 3.0);  /* правильно */

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

Стандартные повышения типов

При передаче аргументов в переменную часть списка действуют стандартные повышения типов.

Особенно важно запомнить:

Поэтому нельзя читать float через va_arg(args, float). Нужно читать как double.

Неправильно:

float x = va_arg(args, float);

Правильно:

double x = va_arg(args, double);

Аналогично символы обычно читают как int, а затем при необходимости приводят к char.

Пример: вывод нескольких целых чисел

#include <stdio.h>
#include <stdarg.h>

void printInts(int count, ...);

int main(void)
{
    printInts(4, 10, 20, 30, 40);
    printInts(2, -5, 100);

    return 0;
}

void printInts(int count, ...)
{
    int i;
    va_list args;

    va_start(args, count);

    for (i = 0; i < count; i++)
    {
        printf("%d ", va_arg(args, int));
    }

    printf("\n");

    va_end(args);
}

Функция printInts ничего не возвращает. Она просто читает count целых чисел и выводит их.

Подход с признаком конца списка

Иногда количество аргументов заранее не передают. Вместо этого в конец списка добавляют специальное значение-признак.

Например, можно суммировать положительные числа до первого нуля:

sumUntilZero(10, 20, 30, 0);

Здесь 0 означает конец списка.

#include <stdio.h>
#include <stdarg.h>

int sumUntilZero(int first, ...);

int main(void)
{
    printf("%d\n", sumUntilZero(10, 20, 30, 0));
    printf("%d\n", sumUntilZero(5, 15, 25, 35, 0));

    return 0;
}

int sumUntilZero(int first, ...)
{
    int value;
    int result = 0;
    va_list args;

    value = first;

    va_start(args, first);

    while (value != 0)
    {
        result += value;
        value = va_arg(args, int);
    }

    va_end(args);

    return result;
}

У этого подхода есть ограничение: значение-признак не должно быть обычным допустимым значением данных. Если 0 может быть нормальным элементом списка, такой способ не подходит.

Признак конца для строк

Для списка строк часто используют признак конца NULL.

printStrings("one", "two", "three", NULL);

Пример:

#include <stdio.h>
#include <stdarg.h>

void printStrings(const char *first, ...);

int main(void)
{
    printStrings("red", "green", "blue", NULL);

    return 0;
}

void printStrings(const char *first, ...)
{
    const char *text;
    va_list args;

    text = first;

    va_start(args, first);

    while (text != NULL)
    {
        printf("%s\n", text);
        text = va_arg(args, const char *);
    }

    va_end(args);
}

Здесь функция читает строки до тех пор, пока не встретит NULL.

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

Пример: максимум из нескольких чисел

#include <stdio.h>
#include <stdarg.h>

int maxInt(int count, ...);

int main(void)
{
    printf("%d\n", maxInt(5, 4, 9, 1, 12, 3));
    printf("%d\n", maxInt(3, -10, -2, -30));

    return 0;
}

int maxInt(int count, ...)
{
    int i;
    int max;
    int value;
    va_list args;

    if (count <= 0)
    {
        return 0;
    }

    va_start(args, count);

    max = va_arg(args, int);

    for (i = 1; i < count; i++)
    {
        value = va_arg(args, int);

        if (value > max)
        {
            max = value;
        }
    }

    va_end(args);

    return max;
}

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

Пример: создание динамического массива double

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

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

double *createDoubleArray(int count, ...);

int main(void)
{
    double *array;
    int i;
    int n = 5;

    array = createDoubleArray(n, 1.0, 2.0, 3.0, 4.0, 5.0);

    if (array == NULL)
    {
        printf("Ошибка выделения памяти\n");
        return 0;
    }

    for (i = 0; i < n; i++)
    {
        printf("%.2f ", array[i]);
    }

    printf("\n");

    free(array);

    return 0;
}

double *createDoubleArray(int count, ...)
{
    int i;
    double *result;
    va_list args;

    if (count <= 0)
    {
        return NULL;
    }

    result = calloc(count, sizeof(result[0]));

    if (result == NULL)
    {
        return NULL;
    }

    va_start(args, count);

    for (i = 0; i < count; i++)
    {
        result[i] = va_arg(args, double);
    }

    va_end(args);

    return result;
}

Здесь count сообщает количество элементов. Функция выделяет память через calloc, затем последовательно читает count значений типа double.

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

Собственный простой аналог printf

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

Пусть формат содержит только символы:

#include <stdio.h>
#include <stdarg.h>

void simplePrint(const char *format, ...);

int main(void)
{
    simplePrint("idcs", 10, 3.14, 'A', "text");

    return 0;
}

void simplePrint(const char *format, ...)
{
    int i = 0;
    va_list args;

    va_start(args, format);

    while (format[i] != '\0')
    {
        if (format[i] == 'i')
        {
            printf("%d ", va_arg(args, int));
        }
        else if (format[i] == 'd')
        {
            printf("%f ", va_arg(args, double));
        }
        else if (format[i] == 'c')
        {
            printf("%c ", va_arg(args, int));
        }
        else if (format[i] == 's')
        {
            printf("%s ", va_arg(args, char *));
        }

        i++;
    }

    printf("\n");

    va_end(args);
}

Эта функция показывает общий принцип: обязательный параметр format сообщает, сколько аргументов читать и каких типов они должны быть.

Символ читается через va_arg(args, int), потому что char в переменной части аргументов повышается до int.

Почему нельзя читать аргументы два раза подряд без подготовки

Каждый вызов va_arg передвигает объект va_list к следующему аргументу.

value = va_arg(args, int);

После этой строки текущий аргумент уже прочитан, а внутреннее состояние сдвинуто дальше.

Поэтому нельзя «вернуться назад» обычным способом. Если нужно пройти список заново, нужно снова выполнить va_start после va_end.

va_start(args, count);
/* первый проход */
va_end(args);

va_start(args, count);
/* второй проход */
va_end(args);

va_copy

В современных версиях C есть макрос va_copy. Он позволяет создать копию объекта va_list, если нужно пройти по списку аргументов независимо двумя способами.

va_list args;
va_list copy;

va_start(args, count);
va_copy(copy, args);

/* работа с args */
/* работа с copy */

va_end(copy);
va_end(args);

Для начального уровня чаще достаточно va_start, va_arg и va_end. Но полезно знать, что прямое копирование через обычное присваивание может быть непереносимым, а для копии предназначен именно va_copy.

Когда стоит использовать функции с переменным количеством аргументов

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

Хорошие случаи:

Но не стоит использовать переменное количество аргументов там, где обычный массив будет проще и безопаснее.

int sumArray(const int a[], int n);

Такая функция часто лучше, чем:

int sum(int count, ...);

Массив проще проверять, передавать, хранить и обрабатывать.

Переменный список аргументов и массив

Важно различать две ситуации.

Функция с массивом:

int sumArray(const int a[], int n);

Вызов:

int numbers[] = { 10, 20, 30 };

sumArray(numbers, 3);

Функция с переменным списком:

int sum(int count, ...);

Вызов:

sum(3, 10, 20, 30);

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

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

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

Ошибка 1. Нет обязательного параметра перед многоточием

int f(...);  /* неправильно */

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

int f(int count, ...);

Ошибка 2. Не подключили stdarg.h

va_list args;

Для va_list, va_start, va_arg и va_end нужен заголовок:

#include <stdarg.h>

Ошибка 3. Не вызвали va_start

va_list args;

value = va_arg(args, int);  /* ошибка */

Перед чтением аргументов нужно выполнить:

va_start(args, count);

Ошибка 4. Не вызвали va_end

va_start(args, count);

/* чтение аргументов */

return result;  /* va_end забыли */

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

va_end(args);

Ошибка 5. Неверный последний обязательный параметр в va_start

int f(int count, int mode, ...)
{
    va_list args;

    va_start(args, count);  /* ошибка */
}

Последний обязательный параметр перед ... — это mode, поэтому правильно:

va_start(args, mode);

Ошибка 6. Неверный тип в va_arg

float x;

x = va_arg(args, float);  /* ошибка */

Значения типа float в переменной части аргументов передаются как double. Поэтому:

double x;

x = va_arg(args, double);

Ошибка 7. Неверное количество аргументов

sum(5, 10, 20);

Если первый параметр сообщает, что дальше идут пять чисел, функция попытается прочитать пять чисел. Но передано только два. Это приведёт к ошибке.

Ошибка 8. Забыли признак конца списка

printStrings("one", "two", "three");  /* NULL забыли */

Если функция ждёт NULL как конец списка, его нужно обязательно передать:

printStrings("one", "two", "three", NULL);

Ошибка 9. Использование переменного списка там, где лучше массив

sum(10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

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

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

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

Программа использует три функции с переменным количеством аргументов: сумму целых чисел, среднее значение и печать строк до NULL.

#include <stdio.h>
#include <stdarg.h>

int sumInt(int count, ...);
double averageDouble(int count, ...);
void printStrings(const char *first, ...);

int main(void)
{
    int s;
    double avg;

    s = sumInt(4, 10, 20, 30, 40);
    avg = averageDouble(3, 2.5, 3.5, 4.0);

    printf("sum = %d\n", s);
    printf("average = %.2f\n", avg);

    printStrings("red", "green", "blue", NULL);

    return 0;
}

int sumInt(int count, ...)
{
    int i;
    int sum = 0;
    va_list args;

    va_start(args, count);

    for (i = 0; i < count; i++)
    {
        sum += va_arg(args, int);
    }

    va_end(args);

    return sum;
}

double averageDouble(int count, ...)
{
    int i;
    double sum = 0.0;
    va_list args;

    if (count <= 0)
    {
        return 0.0;
    }

    va_start(args, count);

    for (i = 0; i < count; i++)
    {
        sum += va_arg(args, double);
    }

    va_end(args);

    return sum / count;
}

void printStrings(const char *first, ...)
{
    const char *text;
    va_list args;

    text = first;

    va_start(args, first);

    while (text != NULL)
    {
        printf("%s\n", text);
        text = va_arg(args, const char *);
    }

    va_end(args);
}

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

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

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

  1. Что такое функция с переменным количеством аргументов?
  2. Для чего в прототипе используется ...?
  3. Почему перед многоточием должен быть хотя бы один обязательный параметр?
  4. Почему функция сама не знает количество дополнительных аргументов?
  5. Какие два подхода можно использовать для определения конца списка аргументов?
  6. Для чего нужен заголовочный файл stdarg.h?
  7. Что такое va_list?
  8. Что делает va_start?
  9. Что указывается вторым аргументом в va_start?
  10. Что делает va_arg?
  11. Почему в va_arg нужно правильно указывать тип?
  12. Что делает va_end?
  13. Почему нельзя читать float через va_arg(args, float)?
  14. Почему для списка строк удобно использовать NULL как признак конца?
  15. Что произойдёт, если параметр count больше реального количества переданных аргументов?
  16. Когда лучше использовать обычный массив вместо переменного списка аргументов?