#define VA_NUM_ARGS(...) \
    (sizeof(#__VA_ARGS__) == sizeof("") \
     ? 0 : VA_NUM_ARGS_IMPL(__VA_ARGS__, 5,4,3,2,1))

This will be evaluated as a constant expression by the compiler. Since the preprocessor removes all extra whitespace, an empty argument list will always become a zero-length string.

BUILD_FACTORY(Object, (int)(vector))

It is nicer than second but uglier than first.
On the other hand it works for all compilers.

P.S.
Talking about Factory pattern, are you familiar with auto-registering approach ?
I mean that you don’t have manually add types to the factory.

I think Boost Preprocessor should starting using VA_ARGS since all popular compilers support this feature.

Btw, your approach with max is not scalable.
You have to define all maxN variations.

While we possibly could do these things with Boost.Preprocessor, I find it nicer to ask people to write:

BUILD_FACTORY(Object, int, vector)

Than:

BUILD_FACTORY(Object, (int, (vector, (BOOST_PP_NIL))))

Also, if I use Boost.Preprocessor, I find all the iteration functionality to be very nasty. Long ago I implemented tr1::tuple for g++, and started using boost.preprocessor. In the end I ended up reimplementing the bits of it I wanted, as it is very complex to read.

Hopefully much of it, particularly to do with looping, could be reimplemented and simplified now we have variadic macros.

#include <boost/preprocessor/list/fold_left.hpp>
#include <boost/preprocessor/selection/max.hpp>

#define LIST (1, (3, (5, (2, (4, BOOST_PP_NIL)))))

#define OP(d, state, x) BOOST_PP_MAX_D(d, state, x)

#define LIST_MAX(list) BOOST_PP_LIST_FOLD_LEFT(OP, 0, LIST)

LIST_MAX(LIST) // expands to 5

On the other hand it seems that you invent Boost.Tuple

Let us create the following macro dispatcher, which takes a macro name and its arguments, and generates the proper call:

#define macro_dispatcher(func, ...) \
            macro_dispatcher_(func, VA_NUM_ARGS(__VA_ARGS__))
#define macro_dispatcher_(func, nargs) \
            macro_dispatcher__(func, nargs)
#define macro_dispatcher__(func, nargs) \
            func ## nargs

(It requires two more levels of indirection due to the nature of the preprocessor).

Then, we could use it for “overloading” macros like you suggested. For example, here is how we would implement a MAX macro which accepts a varying number of arguments:

#define max(...) macro_dispatcher(max, __VA_ARGS__)(__VA_ARGS__)

#define max1(a) a
#define max2(a,b) ((a)>(b)?(a):(b))
#define max3(a,b,c) max2(max2(a,b),c)
// ...

// to verify, run the preprocessor alone (g++ -E):
max(1,2,3);

Then, we are able to implement a solution to your problem in the same way, without writing too much code:

#define BIG_CLASS(...) \
            macro_dispatcher(BIG_CLASS, __VA_ARGS__)(__VA_ARGS__)

#define BIG_CLASS3 /* Your example */

I think this is pretty handy, useful, and general at the same time.

I have a macro designed to build a class which looks like (simplifying, the full thing is much nastier, here is the case for “2″ arguments).

  #define BIG_CLASS2(name, Type1, Type2) \
  class name ## Box \
  {
    Type1 t1; \
    Type2 t2; \
    template <typename T1, typename T2>\
    name##Box(T1 _t1, T2 _t2) : t1(_t1), t2(_t2) {} \
  };\

While I probably could write a macro that could produce this for any size, it’s tricky to get things like the “typename T1, typename T2″ to come out right, and I never need this bigger than 5, so I’m happy to just write them out.

However, it is a bit annoying that I have to tell people to put the 1,2,.. at the start of the name, and will be nice to be able to remove it.