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);
Такие функции называются функциями с переменным количеством аргументов.
В этом пункте рассматриваются:
- что такое функция с переменным количеством аргументов;
- как записывается многоточие
...; - почему у такой функции должен быть хотя бы один обязательный параметр;
- как функция узнаёт количество дополнительных аргументов;
- как использовать заголовочный файл
stdarg.h; - что такое
va_list; - как работают
va_start,va_arg,va_end; - почему важно правильно указывать типы аргументов;
- какие ошибки чаще всего возникают при работе с переменным списком аргументов.
Пример знакомой функции
Самый известный пример функции с переменным количеством аргументов —
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>
В нём определены:
- тип
va_list; - макрос
va_start; - макрос
va_arg; - макрос
va_end.
Эти средства позволяют последовательно читать аргументы из переменного списка стандартным способом, не привязываясь к конкретной архитектуре компьютера или особенностям компилятора.
Основные средства 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);
Здесь:
args— объект типаva_list;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); /* правильно */
Ошибки типов в переменной части аргументов могут привести к неправильным значениям и неопределённому поведению.
Стандартные повышения типов
При передаче аргументов в переменную часть списка действуют стандартные повышения типов.
Особенно важно запомнить:
charиshortобычно передаются какint;floatпередаётся какdouble.
Поэтому нельзя читать 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
Для понимания идеи можно написать очень упрощённую функцию, которая печатает значения по строке формата.
Пусть формат содержит только символы:
i— вывестиint;d— вывестиdouble;c— вывести символ;s— вывести строку.
#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.
Когда стоит использовать функции с переменным количеством аргументов
Такие функции полезны, когда количество однотипных или управляемых форматом аргументов действительно может меняться.
Хорошие случаи:
- функция печати по формату;
- функция логирования;
- сумма или среднее для переменного числа значений;
- создание массива из заданного набора значений;
- обработка списка строк до
NULL.
Но не стоит использовать переменное количество аргументов там, где обычный массив будет проще и безопаснее.
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);
Если данные уже хранятся в массиве или их много, удобнее и безопаснее написать функцию обработки массива.
Практические рекомендации
- Используй функции с переменным количеством аргументов только там, где это действительно упрощает вызов.
- Всегда подключай
stdarg.h. - Перед многоточием должен быть хотя бы один обязательный параметр.
- Перед чтением аргументов вызывай
va_start. - После чтения аргументов вызывай
va_end. - В
va_startуказывай последний обязательный параметр перед.... - Заранее продумывай, как функция узнает количество и типы дополнительных аргументов.
- Для количества аргументов удобно использовать параметр
count. - Для строковых списков часто используют завершающий
NULL. - Не читай
floatчерезva_arg(args, float); используйdouble. - Не читай
charнапрямую; помни о повышении доint. - Не пытайся автоматически определить длину переменного списка: такой информации там нет.
- Если данные можно передать массивом, массив часто будет проще и безопаснее.
Мини-разбор программы
Программа использует три функции с переменным количеством аргументов:
сумму целых чисел, среднее значение и печать строк до 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);
}
Разберём программу:
sumIntиспользует первый параметрcount, чтобы знать количество целых чисел;averageDoubleчитает дополнительные аргументы какdouble;printStringsиспользует не количество, а признак конца спискаNULL;- в каждой функции объявляется объект
va_list; - перед чтением вызывается
va_start; - каждый дополнительный аргумент читается через
va_arg; - после окончания обработки вызывается
va_end.
Что нужно запомнить
- Функция с переменным количеством аргументов может принимать разное число аргументов.
- В прототипе и определении такой функции используется многоточие
.... - Перед
...должен быть хотя бы один обязательный параметр. - Функция сама не знает количество дополнительных аргументов.
- Количество аргументов можно передать отдельным параметром, например
count. - Конец списка можно обозначить специальным значением, например
NULLдля строк. - Для работы с переменным списком подключают
stdarg.h. va_listхранит состояние перебора аргументов.va_startначинает обработку переменного списка.va_argполучает очередной аргумент указанного типа.va_endзавершает обработку списка.- Тип в
va_argдолжен соответствовать фактически переданному аргументу с учётом повышений типов. floatв переменной части аргументов читается какdouble.charиshortобычно читаются какint.- Если данные уже лежат в массиве, обычная функция с массивом часто безопаснее.
Самопроверка перед переходом дальше
- Что такое функция с переменным количеством аргументов?
- Для чего в прототипе используется
...? - Почему перед многоточием должен быть хотя бы один обязательный параметр?
- Почему функция сама не знает количество дополнительных аргументов?
- Какие два подхода можно использовать для определения конца списка аргументов?
- Для чего нужен заголовочный файл
stdarg.h? - Что такое
va_list? - Что делает
va_start? - Что указывается вторым аргументом в
va_start? - Что делает
va_arg? - Почему в
va_argнужно правильно указывать тип? - Что делает
va_end? - Почему нельзя читать
floatчерезva_arg(args, float)? - Почему для списка строк удобно использовать
NULLкак признак конца? - Что произойдёт, если параметр
countбольше реального количества переданных аргументов? - Когда лучше использовать обычный массив вместо переменного списка аргументов?