С аргументами по умолчанию
есть ли способ указать аргументы по умолчанию для функции в C?
19 ответов
Не совсем так. Единственный способ-это напишите функцию varargs и вручную заполнить значения по умолчанию для аргументов, которые абонент не проходит.
Вау, здесь все такие пессимисты. Ответ-да.
это не тривиально: к концу у нас будет основная функция, поддерживающая структура, функция-оболочка и макрос вокруг функции обертки. В моей работе у меня есть набор макросов для автоматизации всего этого; раз вам будет легко сделать то же самое.
я написал это в другом месте, поэтому вот подробная внешняя ссылка для дополнения резюме здесь: http://modelingwithdata.org/arch/00000022.htm
мы хотели бы повернуть
double f(int i, double x)
в функцию, которая принимает значения по умолчанию (i=8, x=3.14). Определите структуру компаньона:
typedef struct {
int i;
double x;
} f_args;
переименовать функцию f_base, и определить функцию-оболочку, которая устанавливает значения по умолчанию и вызовы
база:
double var_f(f_args in){
int i_out = in.i ? in.i : 8;
double x_out = in.x ? in.x : 3.14;
return f_base(i_out, x_out);
}
теперь добавьте макрос, используя переменные макросы C. Таким образом, пользователи не должны знать, что они
на самом деле заполнение f_args struct и думаю они делают как обычно:--9-->
#define f(...) var_f((f_args){__VA_ARGS__});
ОК, теперь все следующее будет работать:
f(3, 8); //i=3, x=8
f(.i=1, 2.3); //i=1, x=2.3
f(2); //i=2, x=3.14
f(.x=9.2); //i=8, x=9.2
Проверьте правила о том, как составные инициализаторы устанавливают значения по умолчанию для точных правил.
одна вещь, которая не работает: f(0), потому что мы не можем различать пропущенное значение и
нуль. По моему опыту, это то, что нужно остерегаться, но можно позаботиться о том, как
возникает необходимость - - - половина времени по умолчанию действительно равна нулю.
Я прошел через проблема написания этого, потому что я думаю, что именованные аргументы и значения по умолчанию действительно сделать кодирование в C проще и даже веселее. И C потрясающе для того, чтобы быть настолько простым и все еще иметь достаточно, чтобы сделать все это возможным.
да. :- ) Но не так, как можно было бы ожидать.
int f1(int arg1, double arg2, char* name, char *opt);
int f2(int arg1, double arg2, char* name)
{
return f1(arg1, arg2, name, "Some option");
}
к сожалению, C не позволяет перегружать методы, поэтому вы получите две разные функции. Тем не менее, вызывая f2, вы фактически вызываете f1 со значением по умолчанию. Это решение "не повторяйтесь", которое поможет вам избежать копирования / вставки существующего кода.
мы можем создавать функции, которые используют именованные параметры (только) для значений по умолчанию. Это продолжение bk.ответ.
#include <stdio.h>
struct range { int from; int to; int step; };
#define range(...) range((struct range){.from=1,.to=10,.step=1, __VA_ARGS__})
/* use parentheses to avoid macro subst */
void (range)(struct range r) {
for (int i = r.from; i <= r.to; i += r.step)
printf("%d ", i);
puts("");
}
int main() {
range();
range(.from=2, .to=4);
range(.step=2);
}
стандарт C99 определяет, что более поздние имена в инициализации переопределяют предыдущие элементы. Мы можем также иметь некоторые стандартные позиционные параметры также, как раз изменяем подпись макроса и функции соответственно. Параметры значения по умолчанию можно использовать только в стиле именованных параметров.
программа:
1 2 3 4 5 6 7 8 9 10
2 3 4
1 3 5 7 9
OpenCV использует что-то вроде:
/* in the header file */
#ifdef __cplusplus
/* in case the compiler is a C++ compiler */
#define DEFAULT_VALUE(value) = value
#else
/* otherwise, C compiler, do nothing */
#define DEFAULT_VALUE(value)
#endif
void window_set_size(unsigned int width DEFAULT_VALUE(640),
unsigned int height DEFAULT_VALUE(400));
если пользователь не знает, что он должен написать, этот трюк может быть полезен:
короткий ответ: нет.
чуть более подробный ответ: есть старый, старый обходной путь, где вы передаете строку, что вы анализировать для необязательных аргументов:
int f(int arg1, double arg2, char* name, char *opt);
где opt может включать пару" name=value " или что-то еще, и что вы бы назвали
n = f(2,3.0,"foo","plot=yes save=no");
очевидно, что это только иногда полезно. Обычно, когда вы хотите один интерфейс для семейства функциональность.
вы все еще находите этот подход в кодах физики частиц, написанных профессиональными программами на c++ (например, ROOT). Главное преимущество что оно может быть продлен почти неопределенно пока поддерживающ назад совместимость.
еще один вариант использует structs:
struct func_opts {
int arg1;
char * arg2;
int arg3;
};
void func(int arg, struct func_opts *opts)
{
int arg1 = 0, arg3 = 0;
char *arg2 = "Default";
if(opts)
{
if(opts->arg1)
arg1 = opts->arg1;
if(opts->arg2)
arg2 = opts->arg2;
if(opts->arg3)
arg3 = opts->arg3;
}
// do stuff
}
// call with defaults
func(3, NULL);
// also call with defaults
struct func_opts opts = {0};
func(3, &opts);
// set some arguments
opts.arg3 = 3;
opts.arg2 = "Yes";
func(3, &opts);
вероятно, лучший способ сделать это (что может быть или не быть возможным в вашем случае в зависимости от вашей ситуации) - перейти на C++ и использовать его как "лучший C". Вы можете использовать C++ без использования классов, шаблонов, перегрузки операторов или других дополнительных функций.
Это даст вам вариант C с перегрузкой функций и параметрами по умолчанию (и любыми другими функциями, которые вы решили использовать). Вам просто нужно быть немного дисциплинированным, если вы действительно серьезно относитесь к использованию только ограниченное подмножество C++.
многие люди скажут, что это ужасная идея использовать C++ таким образом, и они могут иметь смысл. Но это просто мнение; я думаю, что правильно использовать функции C++, с которыми вам удобно, без необходимости покупать все это. Я думаю, что значительная часть причины успеха C++ заключается в том, что он использовался очень многими программистами в первые дни именно таким образом.
да, с функциями C99 вы можете это сделать. Это работает без определения новых структур данных или около того и без функции, которая должна решить во время выполнения, как она была вызвана, и без каких-либо вычислительных мощностей.
для подробного объяснения см. мой пост в
http://gustedt.wordpress.com/2010/06/03/default-arguments-for-c99/
Йенс
нет, но вы можете использовать set функций (или макросов) для приближения с помощью args по умолчанию:
// No default args
int foo3(int a, int b, int c)
{
return ...;
}
// Default 3rd arg
int foo2(int a, int b)
{
return foo3(a, b, 0); // default c
}
// Default 2nd and 3rd args
int foo1(int a)
{
return foo3(a, 1, 0); // default b and c
}
обычно нет, но в gcc вы можете сделать последний параметр funcA() необязательным с макросом.
в funcB () я использую специальное значение (-1), чтобы сигнализировать, что мне нужно значение по умолчанию для параметра 'b'.
#include <stdio.h>
int funcA( int a, int b, ... ){ return a+b; }
#define funcA( a, ... ) funcA( a, ##__VA_ARGS__, 8 )
int funcB( int a, int b ){
if( b == -1 ) b = 8;
return a+b;
}
int main(void){
printf("funcA(1,2): %i\n", funcA(1,2) );
printf("funcA(1): %i\n", funcA(1) );
printf("funcB(1, 2): %i\n", funcB(1, 2) );
printf("funcB(1,-1): %i\n", funcB(1,-1) );
}
я улучшил ответ так что:
- inline функции не работают
- значения по умолчанию вычисляются во время предварительной обработки
- модульные повторно используемые макросы
- можно установить ошибка компилятора, осмысленно соответствует случае нехватки аргументов принимает значения
- значения по умолчанию не требуются для формирования хвоста списка параметров, если типы аргументов останутся однозначно
- interopts с С11 _Generic
- измените имя функции на количество аргументов!
variadic.h:
#ifndef VARIADIC
#define _NARG2(_0, _1, _2, ...) _2
#define NUMARG2(...) _NARG2(__VA_ARGS__, 2, 1, 0)
#define _NARG3(_0, _1, _2, _3, ...) _3
#define NUMARG3(...) _NARG3(__VA_ARGS__, 3, 2, 1, 0)
#define _NARG4(_0, _1, _2, _3, _4, ...) _4
#define NUMARG4(...) _NARG4(__VA_ARGS__, 4, 3, 2, 1, 0)
#define _NARG5(_0, _1, _2, _3, _4, _5, ...) _5
#define NUMARG5(...) _NARG5(__VA_ARGS__, 5, 4, 3, 2, 1, 0)
#define _NARG6(_0, _1, _2, _3, _4, _5, _6, ...) _6
#define NUMARG6(...) _NARG6(__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0)
#define _NARG7(_0, _1, _2, _3, _4, _5, _6, _7, ...) _7
#define NUMARG7(...) _NARG7(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0)
#define _NARG8(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) _8
#define NUMARG8(...) _NARG8(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define _NARG9(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _9
#define NUMARG9(...) _NARG9(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define __VARIADIC(name, num_args, ...) name ## _ ## num_args (__VA_ARGS__)
#define _VARIADIC(name, num_args, ...) name (__VARIADIC(name, num_args, __VA_ARGS__))
#define VARIADIC(name, num_args, ...) _VARIADIC(name, num_args, __VA_ARGS__)
#define VARIADIC2(name, num_args, ...) __VARIADIC(name, num_args, __VA_ARGS__)
// Vary function name by number of arguments supplied
#define VARIADIC_NAME(name, num_args) name ## _ ## num_args ## _name ()
#define NVARIADIC(name, num_args, ...) _VARIADIC(VARIADIC_NAME(name, num_args), num_args, __VA_ARGS__)
#endif
упрощенный сценарий использования:
const uint32*
uint32_frombytes(uint32* out, const uint8* in, size_t bytes);
/*
The output buffer defaults to NULL if not provided.
*/
#include "variadic.h"
#define uint32_frombytes_2( b, c) NULL, b, c
#define uint32_frombytes_3(a, b, c) a, b, c
#define uint32_frombytes(...) VARIADIC(uint32_frombytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)
и с _Generic:
const uint8*
uint16_tobytes(const uint16* in, uint8* out, size_t bytes);
const uint16*
uint16_frombytes(uint16* out, const uint8* in, size_t bytes);
const uint8*
uint32_tobytes(const uint32* in, uint8* out, size_t bytes);
const uint32*
uint32_frombytes(uint32* out, const uint8* in, size_t bytes);
/*
The output buffer defaults to NULL if not provided.
Generic function name supported on the non-uint8 type, except where said type
is unavailable because the argument for output buffer was not provided.
*/
#include "variadic.h"
#define uint16_tobytes_2(a, c) a, NULL, c
#define uint16_tobytes_3(a, b, c) a, b, c
#define uint16_tobytes(...) VARIADIC( uint16_tobytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)
#define uint16_frombytes_2( b, c) NULL, b, c
#define uint16_frombytes_3(a, b, c) a, b, c
#define uint16_frombytes(...) VARIADIC(uint16_frombytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)
#define uint32_tobytes_2(a, c) a, NULL, c
#define uint32_tobytes_3(a, b, c) a, b, c
#define uint32_tobytes(...) VARIADIC( uint32_tobytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)
#define uint32_frombytes_2( b, c) NULL, b, c
#define uint32_frombytes_3(a, b, c) a, b, c
#define uint32_frombytes(...) VARIADIC(uint32_frombytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)
#define tobytes(a, ...) _Generic((a), \
const uint16*: uint16_tobytes, \
const uint32*: uint32_tobytes) (VARIADIC2( uint32_tobytes, NUMARG3(a, __VA_ARGS__), a, __VA_ARGS__))
#define frombytes(a, ...) _Generic((a), \
uint16*: uint16_frombytes, \
uint32*: uint32_frombytes)(VARIADIC2(uint32_frombytes, NUMARG3(a, __VA_ARGS__), a, __VA_ARGS__))
и с функцией с переменным числом аргументов выбора имени, которая не может быть объединена с _Generic:
// winternitz() with 5 arguments is replaced with merkle_lamport() on those 5 arguments.
#define merkle_lamport_5(a, b, c, d, e) a, b, c, d, e
#define winternitz_7(a, b, c, d, e, f, g) a, b, c, d, e, f, g
#define winternitz_5_name() merkle_lamport
#define winternitz_7_name() winternitz
#define winternitz(...) NVARIADIC(winternitz, NUMARG7(__VA_ARGS__), __VA_ARGS__)
еще один трюк с использованием макросов:
#include <stdio.h>
#define func(...) FUNC(__VA_ARGS__, 15, 0)
#define FUNC(a, b, ...) func(a, b)
int (func)(int a, int b)
{
return a + b;
}
int main(void)
{
printf("%d\n", func(1));
printf("%d\n", func(1, 2));
return 0;
}
Если передается только один аргумент, b получает значение по умолчанию (в данном случае 15)
Да, вы можете сделать что-то simulair, здесь вы должны знать разные списки аргументов, которые вы можете получить, но у вас есть та же функция для обработки всех.
typedef enum { my_input_set1 = 0, my_input_set2, my_input_set3} INPUT_SET;
typedef struct{
INPUT_SET type;
char* text;
} input_set1;
typedef struct{
INPUT_SET type;
char* text;
int var;
} input_set2;
typedef struct{
INPUT_SET type;
int text;
} input_set3;
typedef union
{
INPUT_SET type;
input_set1 set1;
input_set2 set2;
input_set3 set3;
} MY_INPUT;
void my_func(MY_INPUT input)
{
switch(input.type)
{
case my_input_set1:
break;
case my_input_set2:
break;
case my_input_set3:
break;
default:
// unknown input
break;
}
}
да
через макрос
3 параметров:
#define my_func2(...) my_func3(__VA_ARGS__, 0.5)
#define my_func1(...) my_func2(__VA_ARGS__, 10)
#define VAR_FUNC(_1, _2, _3, NAME, ...) NAME
#define my_func(...) VAR_FUNC(__VA_ARGS__, my_func3, my_func2, my_func1)(__VA_ARGS__)
void my_func3(char a, int b, float c) // b=10, c=0.5
{
printf("a=%c; b=%d; c=%f\n", a, b, c);
}
если вы хотите 4-й аргумент, то необходимо добавить дополнительный my_func3. Обратите внимание на изменения в VAR_FUNC, my_func2 и my_func
4 параметры:
#define my_func3(...) my_func4(__VA_ARGS__, "default") // <== New function added
#define my_func2(...) my_func3(__VA_ARGS__, (float)1/2)
#define my_func1(...) my_func2(__VA_ARGS__, 10)
#define VAR_FUNC(_1, _2, _3, _4, NAME, ...) NAME
#define my_func(...) VAR_FUNC(__VA_ARGS__, my_func4, my_func3, my_func2, my_func1)(__VA_ARGS__)
void my_func4(char a, int b, float c, const char* d) // b=10, c=0.5, d="default"
{
printf("a=%c; b=%d; c=%f; d=%s\n", a, b, c, d);
}
единственное исключение, что float переменные не могут быть заданы значения по умолчанию (если это последний аргумент, как в случае 3 параметра), поскольку им нужен период ('.'), который не принимается в рамках аргументов макросов. Но может выяснить работу вокруг, как видно из макроса my_func2 (из 4 параметров case)
программа
int main(void)
{
my_func('a');
my_func('b', 20);
my_func('c', 200, 10.5);
my_func('d', 2000, 100.5, "hello");
return 0;
}
выход:
a=a; b=10; c=0.500000; d=default
a=b; b=20; c=0.500000; d=default
a=c; b=200; c=10.500000; d=default
a=d; b=2000; c=100.500000; d=hello
Почему мы не можем сделать этого.
дайте необязательному аргументу значение по умолчанию. Таким образом, вызывающий функцию не обязательно должен передавать значение аргумента. Аргумент принимает значение по умолчанию. И этот аргумент легко становится необязательным для клиента.
, например,
void foo(int a, int b = 0);
здесь b является необязательным аргументом.