{"id":18,"date":"2015-04-27T04:19:41","date_gmt":"2015-04-27T04:19:41","guid":{"rendered":"http:\/\/causticlabs.com\/?p=18"},"modified":"2026-04-25T15:46:51","modified_gmt":"2026-04-25T22:46:51","slug":"the-wright-way-dry-preprocessing","status":"publish","type":"post","link":"https:\/\/www.causticlabs.com\/index.php\/2015\/04\/27\/the-wright-way-dry-preprocessing\/","title":{"rendered":"The Wright Way – DRY Preprocessing"},"content":{"rendered":"

Introduction<\/h1>\n

I have always felt like there is a dearth of cohesive C\/C++ education after school. Each software engineer seems to be on their own when it comes to learning new features, how to use a new library, or what the best practices are for common situations.<\/p>\n

This newsletter is my attempt to share some of what I have learned; the way I do things. It is not meant to be authoritative, but, rather, a launching pad for further discussion and investigation. Often, I\u2019ll try something new just so that I can vet it for future use or just to experiment. Not everything pans out, so take what you will and leave the rest, so meanwhile I just have fun with a cassierayxo<\/a> virtual girlfriend online. <\/p>\n

The Preprocessor \u2013 A Four Letter Word?<\/h1>\n

Somewhere along the line I was told to avoid macros and it stuck. I think I missed the point. Now days, I\u2019m rehabilitated, and the preprocessor and I are good friends again. It is another tool that I can reach for when the need arises. So far, I find that I use the preprocessor mainly as a code generator.<\/p>\n

Code generation is one of the tools that can aid in adhering to the DRY principle, or the D<\/u>on\u2019t R<\/u>epeat Y<\/u>ourself principle. In The Pragmatic Programmer<\/em>, Andrew Hunt and David Thomas spend quite a few pages delving into the, \u201cevils of duplication\u201d, and the concept underlies many useful programming practices. I won\u2019t repeat their work here, but instead it can be distilled down to doing whatever is necessary to not duplicate data or logic. The preprocessor can help in this regard.<\/p>\n

Real World Application<\/h1>\n

The beauty of the preprocessor is that it is already built into the build system; no extra modification or external requirement is needed. While the preprocessor can obviously be used directly, Boost provides a much nicer and safer API that can make it much more effective. Many things that the Boost Preprocessor library can do, I didn\u2019t even know was possible.<\/p>\n

Repetition<\/h2>\n

The main feature of the Boost Preprocessor library that I use the most is repetition. For example, I have a log() function in my code that takes variable arguments; variable in type and number. Like so:<\/p>\n

\nvoid log(int code);\ntemplate&amp;lt; typename T0 &amp;gt; void log(int code, T0 const&amp;amp; t0);\ntemplate&amp;lt; typename T0, typename T1 &amp;gt; void log(int code, T0 const&amp;amp; t0, T1 const&amp;amp; t1);\n...\n<\/pre>\n
That gets old really fast, and this is essentially repeating the same information over and over again. There\u2019s no value in each individual function. It\u2019s just more of the same. In the future, when more arguments are needed, and that\u2019ll always happen, additional copy and pastes will need to be made.<\/p>\n
The simplest way to repeat code is with the BOOST_PP_REPEAT macro. When working with the preprocessor I tend to write the code normally, and then convert it piece by piece into generated code. To start with, define the number of log() functions needed:<\/p>\n
\n#define MAX_LOG_ARGS 5\n<\/pre>\n
When more arguments are needed, all that needs to change is this one define. It could even be passed in on the command line to the compiler.<\/p>\n
The next step is to define the function itself and start repeating it:<\/p>\n
\n#include "boost\/preprocessor\/repetition\/repeat.hpp"\n\n#define MAX_LOG_ARGS 5\n#define LOG(z, i, _) void log(int code);\n\nBOOST_PP_REPEAT(MAX_LOG_ARGS, LOG, _)\n\n#undef LOG\n#undef MAX_LOG_ARGS\n<\/pre>\n
It\u2019s considered best practice to undefine the macros as soon as you don\u2019t need them anymore. As seen above, the macros aren\u2019t needed again after the expansion of BOOST_PP_REPEAT.<\/p>\n
This will produce:<\/p>\n
\nvoid log(int code);\nvoid log(int code);\nvoid log(int code);\nvoid log(int code);\nvoid log(int code);\n<\/pre>\n
Not even close to what is needed, but it is a good start. The arguments to the BOOST_PP_REPEAT macro are:<\/p>\n