Hello, Here's a question for the preprocessor metaprogramming experts out there. I have some classes that need to have write() methods that look like this: template <typename output> bool write(output& out) const { return utils::write(out, member_1) && utils::write(out, member_2) && ... utils::write(out, member_n); } where member_1, member_2, ..., member_n are the member variables of the class. (These write() methods are used as part of a serialization framework). Since I have quite a few classes that need write() methods that look like this, and the structure of each write() method is uniform (the only thing that varies is the names of the class members), I figured that it would be neat to somehow generate the code for these write() methods. What I came up with is macros that look like this: #define MEMBERS1(m1) \ template <typename output> \ bool write(output& out) const \ { \ return utils::write(out, m1); \ } #define MEMBERS2(m1, m2) \ template <typename output> \ bool write(output& out) const \ { \ return utils::write(out, m1) && \ utils::write(out, m2); \ } // and so on for MEMBERS3, MEMBERS4, etc. Then, instead of declaring and defining the write() methods explicilty, I would just call the appropriate MEMBERS# macro in the class definition, e.g. for a class with 3 members named a, b, and c, I'd write MEMBERS3(a, b, c) in the class definition. While this is definitely an improvement over writing the write() methods explicitly for each class, there are two issues with it: 1) The number of lines of code needed to write the macro definitions is quadratic in the maximum number of parameters supported. It would be nice if it could be constant instead. 2) The user of the macros needs to match the macro name to the number of member variables in the class, and to change the macro name whenever the number of member variables changes. I'm wondering if there is a way to improve on this generation scheme that solves one or both of these issues. If I were allowed to use C++0x, I could have a variadic macro MEMBERS(...) and inside it pass the parameters to a variadic template function which unpacks its parameters and calls utils::write() on each. This would solve both issues. Unfortunately, however, I am not allowed to use C++0x features, since our code needs to be able to compile on our servers, which run Ubuntu 8.04, which runs g++ 4.2, which does not support C++0x features. So I thought I'd turn to some more preprocessor magic to solve these issues. I looked at examples in Boost.Preprocessor that generated repetitive code using preprocessor metaprogramming. However, all the examples there generated repetitive *code*, whereas what I seem to need is to be able to generate repetitive *macro definitions*. Is there a way to do that? If not, can anyone recommend other ways of improving the way I generate the code for the write() functions? Thanks in advance, Nate. _________________________________________________________________ Learn more ways to connect with your buddies now http://go.microsoft.com/?linkid=9734388