Int PP_CONCAT_IMPL(NAME, INDEX) = 1 // declares a variable name 'NAMEINDEX' This macro concatenates two expressions, and we want the same behavior: #define NAME Thingy #define PP_CONCAT(x, y) PP_CONCAT_IMPL( x, y ) We do the same for the concatenation operations: #define PP_CONCAT_IMPL(x, y) x#y If we call PP_STRINGIFY_IMPL directly, the expression X does not get evaluated, but if we forward it to another expression, it does.Īuto x = PP_STRINGIFY_IMPL(VALUE) // yields 'VALUE'

The reason two steps are needed is due to the way the preprocessor handles expressions. This macro “stringifies” the expression as we have seen above, but we do it in two steps. #define PP_STRINGIFY(X) PP_STRINGIFY_IMPL(X) #ifdef is the same as #if defined, with the difference that defined allows boolean operations, like so: #if defined(HAS_DOOMSDAY_MACHINE) & defined(IS_EVIL)Ī function-like macro is one that uses parentheses, similar to a standard function: #define DESTROY_THE_WORLD(AreYouSure) printf('test.cpp(%d): Hello %s', 3, 'World') Utility MacrosĪs a start let’s implement two utility macros also found in boost.preprocess #define PP_STRINGIFY_IMPL(X) #X If HAS_DOOMSDAY_MACHINE was defined without a value, the first statement would yield false. When used as flags it is common to give #defines a value, which is used to disambiguate statements: #define HAS_DOOMSDAY_MACHINE 1 Which would yield the following after preprocessing: double pi = 3.142 I would group them in three types:Ī macro with out parentheses is commonly used for a constant or flag: #define PI 3.142 Using uppercase names for macros is a common convention. foo.hĪfter the preprocessor this will become: //foo.cĪ third preprocessor instruction is #define, which allows us to define macros. For people coming from languages with modules #include is often confusing, since it’s only a textual replacement. The most common usage of the preprocessor is of course inclusion. The current line information is also available through the macros _LINE_ and _FILE_.

Now errors in the generated file will be displayed as errors coming from the parser.yfile. For instance, if you generate a parser with yacc: //generated-parser.c #line is most commonly used in code-generators. This is typically used to indicate that an error points somewhere else. The #line instruction will tell the preprocessor to change the perceived location of the current input. This is not that useful in the example, but when using macros with strings this functionality will come in handy. The following is entirely valid C and gives us a `“Hello World!”: const char * message = 'Hello' ' ' 'World' '!' One important thing to note is that adjacent string literals get concatenated. Please note that this article follows the C99 preprocessor standard. We’ll start with a primer on the C preprocessor. You can also use gcc -E to check what the preprocessor generates. boost.waveis a C++ implementation of the preprocessor. Another tool worth looking into is pcpp, which is an excellent python implementation of the C preprocessor. I highly recommend looking into boost.preprocessor. I do agree with Phillip’s take, so please consider the content of this article to be limited to cases where “we can justify the use of the preprocessor.”

However, sometimes it’s the only tool we have to accomplish complex tasks, especially if we are limited to C. The C preprocessor has a bad reputation and rightfully so – it can obscure code, introduce weird symbols, and is generally hard to work with. You can learn more about Klemens on his website.Įxploiting the Preprocessor for Fun and Profit Today we have a guest post from Klemens Morgenstern, an embedded C++ consultant.

Macro in c for binary to byte