Optional Parameters with C++ Macros

Is there some way of getting optional parameters with C++ Macros? Some sort of overloading would be nice too. It doesnt seem as if there is? I couldnt find any method anyway.

Thanks in advance!

Where are C11 optional feature macros?

In the C11 standard is written that compilers should provide some macros to test for optional feature presence. In what headers do I find them? For example where is located __STDC_NO_VLA__? With GCC,

Enterprise Architect: C# Optional parameters?

Any option to get Enterprise Architect to recognize optional parameters in C#? I have attempted to import existing code and get the following error: There was an error parsing C:/MyProject/FooBar.cs

mixing optional parameters and params keyword in c# [duplicate]

This question already has an answer here: C# 4.0, optional parameters and params do not work together 3 answers I am trying to mix optional parameters and variable length parameters (using para

C# functions and optional parameters

I know that in C# it is possible to define optional parameters. My question is directed at how flexible this is. Let f be a function as below, with a mandatory and b, c optional : class Test { public

C# 5.0 optional parameters versus method overloads [closed]

In which situations in C# 5.0 would you use one over the other: optional parameters versus method overloads?

Optional Function Parameters C

I am currently developing a function in C to find the last char occurrence of a given string. I want it to use a certain method (my own) if the length of the string is not given, otherwise it will jus

Named/Optional parameters in C# 3.0?

Is there a way to add optional parameters to C# 3.0 like there will be in C# 4.0? I gotta have this feature, I just can’t wait! Edit: If you know a work-around/hack to accomplish this, post it also. T

C# Optional Parameters or Method Overload? [duplicate]

This question already has an answer here: method overloading vs optional parameter in C# 4.0 [duplicate] 11 answers Since C# added optional parameters is it considered a better practice to use

Java optional parameters

How do I use optional parameters in Java? What specification supports optional parameters?

How to pass optional parameters to a method in C++?

How to pass optional parameters to a method in C++ ? Any code snippet…

Answers

gcc/g++ supports varargs macros but I don’t think this is standard, so use it at your own risk.

C++ macros haven’t changed from C. Since C didn’t have overloading and default arguments for functions, it certainly didn’t have them for macros. So to answer your question: no, those features don’t exist for macros. Your only option is to define multiple macros with different names (or not use macros at all).

As a sidenote: In C++ it’s generally considered good practice to move away from macros as much as possible. If you need features like this, there’s a good chance you’re overusing macros.

Depending on what you need, you could do it with var args with macros. Now, optional parameters or macro overloading, there is no such thing.

That’s not really what the preprocessor is designed for.

That said, if you want to enter into the area of seriously challenging macro programming with a modicum of readability, you should take a look at the Boost preprocessor library. After all, it wouldn’t be C++ if there weren’t three completely Turing compatible levels of programming (preprocessor, template metaprogramming, and base level C++)!

#define MY_MACRO_3(X,Y,Z) ...
#define MY_MACRO_2(X,Y) MY_MACRO(X,Y,5)
#define MY_MACRO_1(X) MY_MACRO(X,42,5)

You know at the point of call how many args you’re going to pass in so there’s really no need for overloading.

Here’s one way to do it. It uses the list of arguments twice, first to form the name of the helper macro, and then to pass the arguments to that helper macro. It uses a standard trick to count the number of arguments to a macro.

enum
{
    plain = 0,
    bold = 1,
    italic = 2
};

void PrintString(const char* message, int size, int style)
{
}

#define PRINT_STRING_1_ARGS(message)              PrintString(message, 0, 0)
#define PRINT_STRING_2_ARGS(message, size)        PrintString(message, size, 0)
#define PRINT_STRING_3_ARGS(message, size, style) PrintString(message, size, style)

#define GET_4TH_ARG(arg1, arg2, arg3, arg4, ...) arg4
#define PRINT_STRING_MACRO_CHOOSER(...) /
    GET_4TH_ARG(__VA_ARGS__, PRINT_STRING_3_ARGS, /
                PRINT_STRING_2_ARGS, PRINT_STRING_1_ARGS, )

#define PRINT_STRING(...) PRINT_STRING_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)

int main(int argc, char * const argv[])
{
    PRINT_STRING("Hello, World!");
    PRINT_STRING("Hello, World!", 18);
    PRINT_STRING("Hello, World!", 18, bold);

    return 0;
}

This makes it easier for the caller of the macro, but not the writer.

#include <stdio.h>

#define PP_NARG(...) /
    PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) /
    PP_ARG_N(__VA_ARGS__)
#define PP_ARG_N( /
    _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, / 
    _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, /
    _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, /
    _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, /
    _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, /
    _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, /
    _61,_62,_63,N,...) N
#define PP_RSEQ_N() /
    63,62,61,60,                   /
    59,58,57,56,55,54,53,52,51,50, /
    49,48,47,46,45,44,43,42,41,40, /
    39,38,37,36,35,34,33,32,31,30, /
    29,28,27,26,25,24,23,22,21,20, /
    19,18,17,16,15,14,13,12,11,10, /
    9,8,7,6,5,4,3,2,1,0

#define PP_CONCAT(a,b) PP_CONCAT_(a,b)
#define PP_CONCAT_(a,b) a ## b

#define THINK(...) PP_CONCAT(THINK_, PP_NARG(__VA_ARGS__))(__VA_ARGS__)
#define THINK_0() THINK_1("sector zz9 plural z alpha")
#define THINK_1(location) THINK_2(location, 42)
#define THINK_2(location,answer) THINK_3(location, answer, "deep thought")
#define THINK_3(location,answer,computer) /
  printf ("The answer is %d. This was calculated by %s, and a computer to figure out what this"
          " actually means will be build in %s/n", (answer), (computer), (location))

int
main (int argc, char *argv[])
{
  THINK (); /* On compilers other than GCC you have to call with least one non-default argument */
}

DISCLAIMER: Mostly harmless.

With great respect to Derek Ledbetter for his answer — and with apologies for reviving an old question.

Getting an understanding of what it was doing and picking up elsewhere on the ability to preceed the __VA_ARGS__ with ## allowed me to come up with a variation…

// The multiple macros that you would need anyway [as per: Crazy Eddie]
#define XXX_0()                     <code for no arguments> 
#define XXX_1(A)                    <code for one argument> 
#define XXX_2(A,B)                  <code for two arguments> 
#define XXX_3(A,B,C)                <code for three arguments> 
#define XXX_4(A,B,C,D)              <code for four arguments>  

// The interim macro that simply strips the excess and ends up with the required macro
#define XXX_X(x,A,B,C,D,FUNC, ...)  FUNC  

// The macro that the programmer uses 
#define XXX(...)                    XXX_X(,##__VA_ARGS__,/
                                          XXX_4(__VA_ARGS__),/
                                          XXX_3(__VA_ARGS__),/
                                          XXX_2(__VA_ARGS__),/
                                          XXX_1(__VA_ARGS__),/
                                          XXX_0(__VA_ARGS__)/
                                         ) 

For non-experts like me who stumble upon the answer, but can’t quite see how it works, I’ll step through the actual processing, starting with the following code…

XXX();
XXX(1); 
XXX(1,2); 
XXX(1,2,3); 
XXX(1,2,3,4); 
XXX(1,2,3,4,5);      // Not actually valid, but included to show the process 

Becomes…

XXX_X(, XXX_4(), XXX_3(), XXX_2(), XXX_1(), XXX_0() );
XXX_X(,1, XXX_4(1), XXX_3(1), XXX_2(1), XXX_1(1), XXX_0(1) );
XXX_X(,1,2, XXX_4(1,2), XXX_3(1,2), XXX_2(1,2), XXX_1(1,2), XXX_0(1,2) );
XXX_X(,1,2,3, XXX_4(1,2,3), XXX_3(1,2,3), XXX_2(1,2,3), XXX_1(1,2,3), XXX_0(1,2,3) );
XXX_X(,1,2,3,4, XXX_4(1,2,3,4), XXX_3(1,2,3,4), XXX_2(1,2,3,4), XXX_1(1,2,3,4), XXX_0(1,2,3,4) );
XXX_X(,1,2,3,4,5, XXX_4(1,2,3,4,5), XXX_3(1,2,3,4,5), XXX_2(1,2,3,4,5), XXX_1(1,2,3,4,5), XXX_0(1,2,3,4,5) );

Which becomes just the sixth argument…

XXX_0(); 
XXX_1(1); 
XXX_2(1,2); 
XXX_3(1,2,3); 
XXX_4(1,2,3,4); 
5; 

PS: Remove the #define for XXX_0 to get a compile error [ie: if a no-argument option is not allowed].

PPS: Would be nice to have the invalid situations (eg: 5) be something that gives a clearer compilation error to the programmer!

PPPS: I’m not an expert, so I’m very happy to hear comments (good, bad or other)!

None of the above examples (from Derek Ledbetter, David Sorkovsky, and Joe D) to count arguments with macros worked for me using Microsoft VCC 10. The __VA_ARGS__ argument is always considered as a single argument (token-izing it with ## or not), so the argument shifting in which those examples rely doesn’t work.

So, short answer, as stated by many others above: no, you can’t overload macros or use optional arguments on them.

For anyone painfully searching some VA_NARGS solution that works with Visual C++. Following macro worked for me flawlessly(also with zero parameters!) in visual c++ express 2010:

#define VA_NUM_ARGS_IMPL(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,N,...) N
#define VA_NUM_ARGS_IMPL_(tuple) VA_NUM_ARGS_IMPL tuple
#define VA_NARGS(...)  bool(#__VA_ARGS__) ? (VA_NUM_ARGS_IMPL_((__VA_ARGS__, 24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1))) : 0

If you want a macro with optional parameters you can do:

//macro selection(vc++)
#define SELMACRO_IMPL(_1,_2,_3, N,...) N
#define SELMACRO_IMPL_(tuple) SELMACRO_IMPL tuple
#define mymacro1(var1) var1
#define mymacro2(var1,var2) var2*var1
#define mymacro3(var1,var2,var3) var1*var2*var3
#define mymacro(...) SELMACRO_IMPL_((__VA_ARGS__, mymacro3(__VA_ARGS__), mymacro2(__VA_ARGS__), mymacro1(__VA_ARGS__))) 

That worked for me aswell in vc. But it doesn’t work for zero parameters.

int x=99;
x=mymacro(2);//2
x=mymacro(2,2);//4
x=mymacro(2,2,2);//8

More concise version of Derek Ledbetter’s code:

enum
{
    plain = 0,
    bold = 1,
    italic = 2
};


void PrintString(const char* message = NULL, int size = 0, int style = 0)
{
}


#define PRINT_STRING(...) PrintString(__VA_ARGS__)


int main(int argc, char * const argv[])
{ 
    PRINT_STRING("Hello, World!");
    PRINT_STRING("Hello, World!", 18);
    PRINT_STRING("Hello, World!", 18, bold);

    return 0;
}

With greatest respect to Derek Ledbetter, David Sorkovsky, Syphorlate for their answers, together with the ingenious method to detect empty macro arguments by Jens Gustedt at

https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/

finally I come out with something that incorporates all the tricks, so that the solution

  1. Uses only standard C99 macros to achieve function overloading, no GCC/CLANG/MSVC extension involved (i.e., comma swallowing by the specific expression , ##__VA_ARGS__ for GCC/CLANG, and implicit swallowing by ##__VA_ARGS__ for MSVC). So feel free to pass the missing –std=c99 to your compiler if you wish =)
  2. Works for zero argument, as well as unlimited number of arguments, if you expand it further to suit your needs
  3. Works reasonably cross-platform, at least tested for

    • GNU/Linux + GCC (GCC 4.9.2 on CentOS 7.0 x86_64)
    • GNU/Linux + CLANG/LLVM, (CLANG/LLVM 3.5.0 on CentOS 7.0 x86_64)
    • OS X + Xcode, (XCode 6.1.1 on OS X Yosemite 10.10.1)
    • Windows + Visual Studio, (Visual Studio 2013 Update 4 on Windows 7 SP1 64 bits)

For the lazies, just skip to the very last of this post to copy the source. Below is the detailed explanation, which hopefully helps and inspires all people looking for the general __VA_ARGS__ solutions like me. =)

Here’s how it goes. First define the user-visible overloaded “function”, I named it create, and the related actual function definition realCreate, and the macro definitions with different number of arguments CREATE_2, CREATE_1, CREATE_0, as shown below:

#define create(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)

void realCreate(int x, int y)
{
  printf("(%d, %d)/n", x, y);
}

#define CREATE_2(x, y) realCreate(x, y)
#define CREATE_1(x) CREATE_2(x, 0)
#define CREATE_0() CREATE_1(0)

The MACRO_CHOOSER(__VA_ARGS__) part ultimately resolves to the macro definition names, and the second (__VA_ARGS__) part comprises their parameter lists. So a user’s call to create(10) resolves to CREATE_1(10), the CREATE_1 part comes from MACRO_CHOOSER(__VA_ARGS__), and the (10) part comes from the second (__VA_ARGS__).

The MACRO_CHOOSER uses the trick that, if __VA_ARGS__ is empty, the following expression is concatenated into a valid macro call by the preprocessor:

NO_ARG_EXPANDER __VA_ARGS__ ()  // simply shrinks to NO_ARG_EXPANDER()

Ingeniusly, we can define this resulting macro call as

#define NO_ARG_EXPANDER() ,,CREATE_0

Note the two commas, they are explained soon. The next useful macro is

#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())

so the calls of

create();
create(10);
create(20, 20);

are actually expanded to

CHOOSE_FROM_ARG_COUNT(,,CREATE_0)();
CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER 10 ())(10);
CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER 20, 20 ())(20, 20);

As the macro name suggests, we are to count number of arguments later. Here comes another trick: the preprocessor only does simple text replacement. It infers the number of arguments of a macro call merely from the number of commas it sees inside the parentheses. The actual “arguments” separated by commas need not to be of valid syntax. They can be any text. That’s to say, in the above example, NO_ARG_EXPANDER 10 () is counted as 1 argument for the middle call. NO_ARG_EXPANDER 20 and 20 () are counted as 2 arguments for the bottom call respectively.

If we use the following helper macros to further expand them

##define CHOOSE_FROM_ARG_COUNT(...) /
  FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define FUNC_RECOMPOSER(argsWithParentheses) /
  FUNC_CHOOSER argsWithParentheses

The trailing , after CREATE_1 is a work-around for GCC/CLANG, suppressing a (false positive) error saying that ISO C99 requires rest arguments to be used when passing -pedantic to your compiler. The FUNC_RECOMPOSER is a work-around for MSVC, or it can not count number of arguments (i.e., commas) inside the parentheses of macro calls correctly. The results are further resolved to

FUNC_CHOOSER (,,CREATE_0, CREATE_2, CREATE_1, )();
FUNC_CHOOSER (NO_ARG_EXPANDER 10 (), CREATE_2, CREATE_1, )(10);
FUNC_CHOOSER (NO_ARG_EXPANDER 20, 20 (), CREATE_2, CREATE_1, )(20, 20);

As the eagle-eyed you may have seen, the last only step we need is to employ a standard argument counting trick to finally pick the wanted macro version names:

#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3

which resolves the results to

CREATE_0();
CREATE_1(10);
CREATE_2(20, 20);

and certainly gives us the desired, actual function calls:

realCreate(0, 0);
realCreate(10, 10);
realCreate(20, 20);

Putting all together, with some rearrangement of statements for better readability, the whole source of the 2-argument example is here:

#include <stdio.h>

void realCreate(int x, int y)
{
  printf("(%d, %d)/n", x, y);
}

#define CREATE_2(x, y) realCreate(x, y)
#define CREATE_1(x) CREATE_2(x, 0)
#define CREATE_0() CREATE_1(0)

#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
#define FUNC_RECOMPOSER(argsWithParentheses) FUNC_CHOOSER argsWithParentheses
#define CHOOSE_FROM_ARG_COUNT(...) FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define NO_ARG_EXPANDER() ,,CREATE_0
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())
#define create(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)

int main()
{
  create();
  create(10);
  create(20, 20);
  //create(30, 30, 30);  // Compilation error
  return 0;
}

Although complicated, ugly, burdening the API developer, there comes a solution for overloading and setting optional parameters of C/C++ functions to us crazy people. The usage of the out-coming overloaded APIs become very enjoyable and pleasant. =)

If there is any further possible simplification of this approach, please do let me know at

https://github.com/jason-deng/C99FunctionOverload

Again special thanks to all of the brilliant people that inspired and led me to achieve this piece of work! =)