# C default arguments

## The Question :

289 people think this question is useful

Is there a way to specify default arguments to a function in C?

• just want a slightly better C, not C++. think C+ . with a variety of small improvements lifted from C++, but not the big mess. And, please, no different link-loader. should be just another preprocessor-like step. standardized. everywhere…
• Related question that I didn’t see listed in the side bar.
• I’d say stop being a barbarian and learn to use C++(11, …) well – jk! /me puts out flames… but… you will come to love it… hahaha i can’t help myself, sorry.
• Possible duplicate of Default values on arguments in C functions and function overloading in C

156 people think this answer is useful

Not really. The only way would be to write a varargs function and manually fill in default values for arguments which the caller doesn’t pass.

287 people think this answer is useful

Wow, everybody is such a pessimist around here. The answer is yes.

It ain’t trivial: by the end, we’ll have the core function, a supporting struct, a wrapper function, and a macro around the wrapper function. In my work I have a set of macros to automate all this; once you understand the flow it’ll be easy for you to do the same.

I’ve written this up elsewhere, so here’s a detailed external link to supplement the summary here: http://modelingwithdata.org/arch/00000022.htm

We’d like to turn

double f(int i, double x)



into a function that takes defaults (i=8, x=3.14). Define a companion struct:

typedef struct {
int i;
double x;
} f_args;



Rename your function f_base, and define a wrapper function that sets defaults and calls the 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);
}



Now add a macro, using C’s variadic macros. This way users don’t have to know they’re actually populating a f_args struct and think they’re doing the usual:

#define f(...) var_f((f_args){__VA_ARGS__});



OK, now all of the following would work:

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



Check the rules on how compound initializers set defaults for the exact rules.

One thing that won’t work: f(0), because we can’t distinguish between a missing value and zero. In my experience, this is something to watch out for, but can be taken care of as the need arises—half the time your default really is zero.

I went through the trouble of writing this up because I think named arguments and defaults really do make coding in C easier and even more fun. And C is awesome for being so simple and still having enough there to make all this possible.

165 people think this answer is useful

Yes. 🙂 But not in a way you would expect.

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



Unfortunately, C doesn’t allow you to overload methods so you’d end up with two different functions. Still, by calling f2, you’d actually be calling f1 with a default value. This is a “Don’t Repeat Yourself” solution, which helps you to avoid copying/pasting existing code.

41 people think this answer is useful

We can create functions which use named parameters (only) for default values. This is a continuation of bk.’s answer.

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



The C99 standard defines that later names in the initialization override previous items. We can also have some standard positional parameters as well, just change the macro and function signature accordingly. The default value parameters can only be used in named parameter style.

Program output:

1 2 3 4 5 6 7 8 9 10
2 3 4
1 3 5 7 9



25 people think this answer is useful

OpenCV uses something like:

/* 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));



If the user doesn’t know what he should write, this trick can be helpful:

19 people think this answer is useful

No.

Not even the very latest C99 standard supports this.

18 people think this answer is useful

No, that’s a C++ language feature.

14 people think this answer is useful

Slightly longer answer: There is an old, old workaround where you pass a string that you parse for optional arguments:

int f(int arg1, double arg2, char* name, char *opt);



where opt may include “name=value” pair or something, and which you would call like

n = f(2,3.0,"foo","plot=yes save=no");



Obviously this is only occasionally useful. Generally when you want a single interface to a family of functionality.

You still find this approach in particle physics codes that are written by professional programs in c++ (like for instance ROOT). It’s main advantage is that it may be extended almost indefinitely while maintaining back compatibility.

13 people think this answer is useful

Probably the best way to do this (which may or may not be possible in your case depending on your situation) is to move to C++ and use it as ‘a better C’. You can use C++ without using classes, templates, operator overloading or other advanced features.

This will give you a variant of C with function overloading and default parameters (and whatever other features you chose to use). You just have to be a little disciplined if you’re really serious about using only a restricted subset of C++.

A lot of people will say it’s a terrible idea to use C++ in this way, and they might have a point. But’s it’s just an opinion; I think it’s valid to use features of C++ that you’re comfortable with without having to buy into the whole thing. I think a significant part of the reason for the sucess of C++ is that it got used by an awful lot of programmers in it’s early days in exactly this way.

13 people think this answer is useful

Yet another option uses 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, &amp;opts);

// set some arguments
opts.arg3 = 3;
opts.arg2 = "Yes";
func(3, &amp;opts);



10 people think this answer is useful

No.

7 people think this answer is useful

Another trick using macros:

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



If only one argument is passed, b receives the default value (in this case 15)

4 people think this answer is useful

No, but you might consider using a set of functions (or macros) to approximate using default 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
}



4 people think this answer is useful

Yes, with features of C99 you may do this. This works without defining new data structures or so and without the function having to decide at runtime how it was called, and without any computational overhead.

For a detailed explanation see my post at

http://gustedt.wordpress.com/2010/06/03/default-arguments-for-c99/

Jens

3 people think this answer is useful

Generally no, but in gcc You may make the last parameter of funcA() optional with a macro.

In funcB() i use a special value (-1) to signal that i need the default value for the ‘b’ parameter.

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



2 people think this answer is useful

YES

Through macros

3 Parameters:

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



If you want 4th argument, then an extra my_func3 needs to be added. Notice the changes in VAR_FUNC, my_func2 and my_func

4 Parameters:

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



Only exception that float variables cannot be given default values (unless if it is the last argument as in the 3 parameters case), because they need period (‘.’), which is not accepted within macro arguments. But can figure out a work around as seen in my_func2 macro (of 4 parameters case)

Program

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



Output:

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



1 people think this answer is useful

I improved Jens Gustedt’s answer so that:

1. inline functions aren’t employed
2. defaults are computed during preprocessing
3. modular reuseable macros
4. possible to set compiler error that meaningfully matches the case of insufficient arguments for the allowed defaults
5. the defaults aren’t required to form the tail of the parameter list if the argument types will remain unambiguous
6. interopts with C11 _Generic
7. vary the function name by the number of arguments!

#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__)

// Vary function name by number of arguments supplied
#define VARIADIC_NAME(name, num_args) name ## _ ## num_args ## _name ()

#endif



Simplified usage scenario:

const uint32*
uint32_frombytes(uint32* out, const uint8* in, size_t bytes);

/*
The output buffer defaults to NULL if not provided.
*/

#define uint32_frombytes_2(   b, c) NULL, b, c
#define uint32_frombytes_3(a, b, c)    a, b, c



And with _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.
*/

#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   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   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__))



And with variadic function name selection, which can’t be combined with _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



0 people think this answer is useful

Yes you can do somthing simulair, here you have to know the different argument lists you can get but you have the same function to handle then all.

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