Iterate a preprocessor macro on a list of class names

Question

I would like to run macros on a list of class names to avoid copy/pasting errors and hassle.

Imagine, as a simple example, that every class in my SDK needs to call a static allocation method before it is used. So, every time I add a new class, I have to manually add the following line at initialization:

MyNewClass::allocate();

And I also need to do the same for initialization and destruction.

So, instead of doing this manually every time, I was wondering if there was a way to write a list of all my class names somewhere, then define a macro to call the corresponding methods for each class in the list. Something in the lines of:

#define ALLOCATE( TheClass ) TheClass ## ::allocate();

But instead of just passing TheClass as an argument, I'd like to pass a list of my classes. So by calling:

ALLOCATE_ALL( ClassA, ClassB, ClassC )

it would expand to:

ClassA::allocate();
ClassB::allocate();
ClassC::allocate();

Ultimately, I would like to be able to define a class list and have multiple macros iterate over it. Something in the lines of:

ALLOCATE_ALL( MyClassList )
INIT_ALL( MyClassList )
DESTROY_ALL( MyClassList )

I've already taken a look at variadic macros but, if I understand the concept correctly, you have to define as many macros as the final number of arguments; and that is simply not viable in my case.

Is this possible at all?

Thanks for any help and/or feedback.

Answer 1

If you are satisfied with having one list of classes, you can use the following trick:

#define MY_CLASSES X(ClassA) X(ClassB) X(ClassC)

Then you can do something like:

#define X(a) a::allocate();
MY_CLASSES
#undef X

To do something else, you can do:

#define X(a) a::init();
MY_CLASSES
#undef X

Answer 2

You could use a variadic function template :

#include <iostream>

// Thanks to Jarod42 for improving it !
template <class... TClasses>
    void allocateAll() {
    std::initializer_list<int>{(TClasses::allocate(), void(), 0)...};
}

struct C1 { static void allocate() { std::cout << "allocated C1\n"; } };
struct C2 { static void allocate() { std::cout << "allocated C2\n"; } };
struct C3 { static void allocate() { std::cout << "allocated C3\n"; } };

int main()
{
    allocateAll<C1, C2, C3>();
    return 0;
}

Outputs :

allocated C1
allocated C2
allocated C3

The functions are called in the same order that you pass their classes in.

You can also centralize the classes list :

// Use a template instead of a function so you can typedef it
template <class... TClasses>
struct ClassesList {
    static void allocateAll() {
        std::initializer_list<int>{(TClasses::allocate(), void(), 0)...};
    }

    // Add any other utilities here

private:
    ClassesList();
};

// Declare your list
using MyClassesList = ClassesList<C1, C2, C3>;

int main(int, char**) {
    // Just as before
    MyClassesList::allocateAll();
}

Answer 3

To improve slightly the answer given by LindyLancer suggesting X-macros you could have a seperate file

 // file my_classes.def
 #ifndef MY_CLASS
 #error MY_CLASS should be defined before including my_classes.def
 MY_CLASS(ClassA)
 MY_CLASS(ClassB)
 /// etc...
 #undef MY_CLASS

Then you would include that several times, e.g.

 #define MY_CLASS(Classname) class Classname;
 #include "my_classes.def"

and later, inside some initializer (or your main)

 #define MY_CLASS(Classname) Classname::init();
 #include "my_classes.def"

Answer 4

Using Boost.Preprocessor :

#include <boost/preprocessor/seq/for_each.hpp>

#define MyClassList \
    (ClassA) \
    (ClassB) \
    (ClassC)

#define ALLOCATE_ALL( R, DATA, ELEM ) \
    ELEM :: allocate();

#define INIT_ALL( R, DATA, ELEM ) \
    ELEM :: init();

//...

BOOST_PP_SEQ_FOR_EACH( ALLOCATE_ALL, _, MyClassList )
BOOST_PP_SEQ_FOR_EACH( INIT_ALL, _, MyClassList )

Answer 5

You can define a generic macro that iterates, but the one time definition of it is ugly. This is because you do need one macro definition for each argument, up to the max number of nesting levels supported by your compiler (I believe the minimum is at least 63, but GCC is only limited by available memory). But since it is generic, you may find other uses of it.

For up to 5, a possible implementation is:

#define M_ITER(M, ...) \
        M_ITER_(__VA_ARGS__, _5, _4, _3, _2, _1)(M, __VA_ARGS__)
#define M_ITER_(_1, _2, _3, _4, _5, X, ...) M_ITER ## X

#define M_ITER_1(M, X)      M(X)
#define M_ITER_2(M, X, ...) M(X) M_ITER_1(M, __VA_ARGS__)
#define M_ITER_3(M, X, ...) M(X) M_ITER_2(M, __VA_ARGS__)
#define M_ITER_4(M, X, ...) M(X) M_ITER_3(M, __VA_ARGS__)
#define M_ITER_5(M, X, ...) M(X) M_ITER_4(M, __VA_ARGS__)

This is basically how BOOST_PP_SEQ_FOR_EACH is implemented.

And then, you could use it for your purpose like this:

#define ALLOCATE_ALL(...) M_ITER(ALLOCATE, __VA_ARGS__)
#define INIT_ALL(...)     M_ITER(INIT, __VA_ARGS__)
#define DESTROY_ALL(...)  M_ITER(DESTROY, __VA_ARGS__)

ALLOCATE_ALL(ClassA, ClassB, ClassC)
INIT_ALL(ClassA, ClassB, ClassC)
DESTROY_ALL(ClassA, ClassB, ClassC)

Answer 6

The accepted answer by Lindydancer is unsatisfactory to me because it relies on repeatedly redefining the X macro, which seems mysterious on use and could lead to collisions.

Instead, I prefer a variation that accepts the name of the macro as a parameter:

#define FOR_EACH_CLASS(macro) \
  macro(ClassA) \
  macro(ClassB) \
  macro(ClassC)

This would be used liked like:

#define CALL_ALLOCATE(classname) classname::allocate();
FOR_EACH_CLASS(CALL_ALLOCATE)
#undef CALL_ALLOCATE   /* optional undef */

There is another answer to a related question: Real-world use of X-Macros that gives more examples of the technique. (Note that, in that question, the accepted answer once again relies on redefining a macro with a particular name, whereas the one I linked accepts the macro name as a parameter.)