The C preprocessor is justifiably feared and shunned by the C++ community. In-lined functions, consts and templates are usually a safer and superior alternative to a #define.

The following macro:

#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)

is in no way superior to the type safe:

inline bool succeeded(int hr) { return hr >= 0; }

But macros do have their place, please list the uses you find for macros that you can't do without the preprocessor.

Please put each use-cases in a seperate answer so it can be voted up and if you know of how to achieve one of the answers without the preprosessor point out how in that answer's comments.

+12  A: 

When you want to change the program flow (return, break and continue) code in a function behaves differently than code that is actually inlined in the function.

#define ASSERT_RETURN(condition) \
if (!condition, ret_val) { \
    assert(false && #condition); \
    return ret_val; }

// should really be in a do { } while(false) but that's another discussion.

Often times I end up with code like:

int SomeAPICallbackMethod(long a, long b, SomeCrazyClass c, long d, string e, string f, long double yx) { ... }
int AnotherCallback(long a, long b, SomeCrazyClass c, long d, string e, string f, long double yx) { ... }
int YetAnotherCallback(long a, long b, SomeCrazyClass c, long d, string e, string f, long double yx) { ... }

In some cases I'll use the following to make my life easier:

#define APIARGS long a, long b, SomeCrazyClass c, long d, string e, string f, long double yx
int SomeAPICallbackMethod(APIARGS) { ... }

It comes with the caveat of really hiding the variable names, which can be an issue in larger systems, so this isn't always the right thing to do, only sometimes.

Loren Segal
In that situation, you might be better off making a CallbackArg structure.
Josh Matthews
+3  A: 

You can't perform short-circuiting of function call arguments using a regular function call. For example:

#define andm(a, b) (a) && (b)

bool andf(bool a, bool b) { return a && b; }

andm(x, y) // short circuits the operator so if x is false, y would not be evaluated
andf(x, y) // y will always be evaluated
Maybe a more general point: functions evaluate their arguments exactly once. Macros can evaluate arguments more times or fewer times.
Steve Jessop
@[Greg Rogers] all the macro preprocessor does is substitute text. Once you understand that, there should be no more mystery about it.
You could get the equivalent behavior by templatizing andf instead of forcing the evaluation to bool before calling the function. I wouldn't have realized what you said was true without trying it for myself though. Interesting.
Greg Rogers
How exactly could you do that with a template?
+2  A: 

One common use is for detecting the compile environment, for cross-platform development you can write one set of code for linux, say, and another for windows when no cross platform library already exists for your purposes.

So, in a rough example a cross-platform mutex can have

void lock()
    #ifdef WIN32
    #ifdef POSIX

For functions, they are useful when you want to explicitly ignore type safety. Such as the many examples above and below for doing ASSERT. Of course, like a lot of C/C++ features you can shoot yourself in the foot, but the language gives you the tools and lets you decide what to do.

Doug T.
Since the questioner asked: this can be done without macros by including different headers via different include paths per platform. I'm inclined to agree though that macros are often more convenient.
Steve Jessop
I second that. If you start using macros for that purpose, the code can quickly become much less readable
Nemanja Trifunovic
+7  A: 

The obvious include guards

#ifndef MYHEADER_H
#define MYHEADER_H


+15  A: 

When you want to make a string out of an expression, the best example for this is assert (#x turns the value of x to a string).

#define ASSERT_THROW(condition) \
if (!(condition)) \
     throw std::exception(#condition " is false");
Just a nitpick, but I personally would leave the semicolon off.
Michael Myers
I agree, in fact I would put it in a do {} while(false) (to prevent else highjacking) but I wanted to keep it simple.
if(!condition) -> if(!(condition))
@Notinlist, fixed.
+17  A: 

Methods must always be complete, compilable code; macros may be code fragments. Thus you can define a foreach macro:

#define foreach(list, index) for(index = 0; index < list.size(); index++)

And use it as thus:

foreach(cookies, i)
    printf("Cookie: %s", cookies[i]);
Nice - but careful, BOOST's foreach defines the args the other way around
Martin Beckett
I must disagree with you here -- this may be useful for you, but will decrease readability in your code and lead to problems should another person try to define that same macro. Better to just stick with the standard for() in this case.
Nik Reiman
also, you should probably use iterator instead of index, since std::list::size() will need to walk the entire list every time so it could be quite inefficient to do that comparison on every loop.
+1 If you are using some ridiculously complex iterator syntax, writing a foreach style macro can make your code much easier to read and maintain. I've done it, it works.
Most comments completely irrelevant to the point that macros may be code fragments instead of complete code. But thank you for the nitpicking.
@jonner: That assumes that the compiler doesn't optimize out the method call for each iteration. I would assume that any modern, non-naive compiler would do this.
@sqook: As hinted at by steveth45, I think the idea of a foreach loop is ubiquitous enough now, that it should be obvious what your intentions are.
This is C not C++. If you are doing C++, you should be using iterators and std::for_each.
I disagree, chrish. Before lambda's, `for_each` was a nasty thing, because the code each element was runnnig through was not local to the calling point.`foreach`, (and I highly recommend `BOOST_FOREACH` instead of a hand-rolled solution) let's you keep the code close to the iteration site, making it more readable. That said, once lambda's roll out, `for_each` might once again be the way to go.
And it's worth noting that BOOST_FOREACH is itself a macro (but a very well-thought-out one)
Tyler McHenry
+2  A: 

Compilers can refuse your request to inline.

Macros will always have their place.

Something I find useful is #define DEBUG for debug tracing -- you can leave it 1 while debugging a problem (or even leave it on during the whole development cycle) then turn it off when it is time to ship.

Compilers can also common up code without permission.
Steve Jessop
If the compiler refuses your request to inline, it might have a very good reason. A good compiler will be better at inlining properly than you are, and a bad one will give you more performance problems than this.
David Thornley
+2  A: 

When you are making a decision at compile time over Compiler/OS/Hardware specific behavior.

It allows you to make your interface to Comppiler/OS/Hardware specific features.

#if defined(MY_OS1) && defined(MY_HARDWARE1)
#define   MY_ACTION(a,b,c)      doSothing_OS1HW1(a,b,c);}
#elif define(MY_OS1) && defined(MY_HARDWARE2)
#define   MY_ACTION(a,b,c)      doSomthing_OS1HW2(a,b,c);}
#elif define(MY_SUPER_OS)
          /* On this hardware it is a null operation */
#define   MY_ACTION(a,b,c)
#error  "PLEASE DEFINE MY_ACTION() for this Compiler/OS/HArdware configuration"
Martin York
+36  A: 

As wrappers for debug functions, to automatically pass things like __FILE__, __LINE__, etc:

#ifdef ( DEBUG )
#define M_DebugLog( msg )  std::cout << __FILE__ << ":" << __LINE__ << ": " << msg
#define M_DebugLog( msg )
Frank Szczerba
Actually, the original snippet: << __FILE__ ":" <<is fine, __FILE__ generates a string constant, which will be concatenated with the ":" into a single string by the pre-processor.
Frank Szczerba
+20  A: 

Inside conditional compilation, to overcome issues of differences between compilers:

#ifdef ARE_WE_ON_WIN32
#define close(parm1)            _close (parm1)
#define rmdir(parm1)            _rmdir (parm1)
#define mkdir(parm1, parm2)     _mkdir (parm1)
#define access(parm1, parm2)    _access(parm1, parm2)
#define create(parm1, parm2)    _creat (parm1, parm2)
#define unlink(parm1)           _unlink(parm1)
Andrew Stein
In C++, the same could be obtained through the use of inline functions: <code>#ifdef ARE_WE_ON_WIN32 <br>inline int close(int i) { return _close(i) ; } <br> #endif</code>
That removes the #define's, but not the #ifdef and #endif. Anyway, I agree with you.
+10  A: 

Header file guards necessitate macros.

Are there any other areas that necessitate macros? Not many (if any).

Are there any other situations that benefit from macros? YES!!!

One place I use macros is with very repetitive code. For example, when wrapping C++ code to be used with other interfaces (.NET, COM, Python, etc...), I need to catch different types of exceptions. Here's how I do that:

catch (::mylib::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e); \
} \
catch (::std::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e, __LINE__, __FILE__); \
} \
catch (...) { \
    throw gcnew MyDotNetLib::UnknownException(__LINE__, __FILE__); \

I have to put these catches in every wrapper funtion. Rather than type out the full catch blocks each time, I just type:

void Foo()
    try {

This also makes maintenance easier. If I every have to add a new exception type, there's only one place I need to add it.

There are other useful examples too: many of which include the __FILE__ and __LINE__ preprocessor macros.

Anyway, macros are very useful when used correctly. Macros are not evil -- their misuse is evil.

Most compilers support `#pragma once` these days, so I doubt guards are really necessary
They are if you're writing for all compilers instead of only most ;-)
Steve Jessop
So instead of portable, standard preprocessor functionality, you recommend using a preprocessor extension to avoid using the preprocessor? Seems sort of ridiculous to me.
Logan Capaldo
+3  A: 

Something like

void debugAssert(bool val, const char* file, int lineNumber);
#define assert(x) debugAssert(x,__FILE__,__LINE__);

So that you can just for example have

assert(n == true);

and get the source file name and line number of the problem printed out to your log if n is false.

If you use a normal function call such as

void assert(bool val);

instead of the macro, all you can get is your assert function's line number printed to the log, which would be less useful.

+3  A: 

Unit test frameworks for C++ like UnitTest++ pretty much revolve around preprocessor macros. A few lines of unit test code expand into a hierarchy of classes that wouldn't be fun at all to type manually. Without something like UnitTest++ and it's preprocessor magic, I don't know how you'd efficiently write unit tests for C++.

+3  A: 

We use the __FILE__ and __LINE__ macros for diagnostic purposes in information rich exception throwing, catching and logging, together with automated log file scanners in our QA infrastructure.

For instance, a throwing macro OUR_OWN_THROW might be used with exception type and constructor parameters for that exception, including a textual description. Like this:

OUR_OWN_THROW(InvalidOperationException, (L"Uninitialized foo!"));

This macro will of course throw the InvalidOperationException exception with the description as constructor parameter, but it'll also write a message to a log file consisting of the file name and line number where the throw occured and its textual description. The thrown exception will get an id, which also gets logged. If the exception is ever caught somewhere else in the code, it will be marked as such and the log file will then indicate that that specific exception has been handled and that it's therefore not likely the cause of any crash that might be logged later on. Unhandled exceptions can be easily picked up by our automated QA infrastructure.

Johann Gerell

I think this trick is a clever use of the preprocessor that can't be emulated with a function :

#define COMMENT_SLASH(s) /##s

#if defined _DEBUG
#define DEBUG_ONLY

Then you can use it like this:

cout <<"Hello, World!" <<endl;
DEBUG_ONLY cout <<"This is outputed only in debug mode" <<endl;

You can also define a RELEASE_ONLY macro.

Mathieu Pagé
This trick does not work according to the standard. It attempts to create a comment marker through the preprocessor, but comments are to be removed before the preprocessor runs. A conforming compiler will cause a syntax error here.
David Thornley
Sorry David but the compiler must contain a second copy of comment removal.
much easier is to make the debugging flag a global const bool, and use code like this: if(debug) cout << "..."; -- no need for macros!
Stefan Monov
@Stefan : Indeed, it's what I do now. Any decent compiler will not generate any code if debug is false in that case.
Mathieu Pagé
+1  A: 

Let's say we'll ignore obvious things like header guards.

Sometimes, you want to generate code that needs to be copy/pasted by the precompiler:

#define RAISE_ERROR_STL(p_strMessage)                                          \
do                                                                             \
{                                                                              \
   try                                                                         \
   {                                                                           \
      std::tstringstream strBuffer ;                                           \
      strBuffer << p_strMessage ;                                              \
      strMessage = strBuffer.str() ;                                           \
      raiseSomeAlert(__FILE__, __FUNCSIG__, __LINE__, strBuffer.str().c_str()) \
   }                                                                           \
   catch(...){}                                                                \
   {                                                                           \
   }                                                                           \
}                                                                              \

which enables you to code this:

RAISE_ERROR_STL("Hello... The following values " << i << " and " << j << " are wrong") ;

And can generate messages like:

Error Raised:
File : MyFile.cpp, line 225
Function : MyFunction(int, double)
Message : "Hello... The following values 23 and 12 are wrong"

Note that mixing templates with macros can lead to even better results (i.e. automatically generating the values side-by-side with their variable names)

Other times, you need the __FILE__ and/or the __LINE__ of some code, to generate debug info, for example. The following is a classic for Visual C++:

#define WRNG_PRIVATE_STR2(z) #z
#define WRNG __FILE__ "("WRNG_PRIVATE_STR1(__LINE__)") : ------------ : "

As with the following code:

#pragma message(WRNG "Hello World")

it generates messages like:

C:\my_project\my_cpp_file.cpp (225) : ------------ Hello World

Other times, you need to generate code using the # and ## concatenation operators, like generating getters and setters for a property (this is for quite a limited cases, through).

Other times, you will generate code than won't compile if used through a function, like:

#define MY_TRY      try{
#define MY_CATCH    } catch(...) {
#define MY_END_TRY  }

Which can be used as

   doSomethingDangerous() ;
   tryToRecoverEvenWithoutMeaningfullInfo() ;
   damnThoseMacros() ;

(still, I only saw this kind of code rightly used once)

Last, but not least, the famous boost::foreach !!!

#include <string>
#include <iostream>
#include <boost/foreach.hpp>

int main()
    std::string hello( "Hello, world!" );

    BOOST_FOREACH( char ch, hello )
        std::cout << ch;

    return 0;

(Note: code copy/pasted from the boost homepage)

Which is (IMHO) way better than std::for_each.

So, macros are always useful because they are outside the normal compiler rules. But I find that most the time I see one, they are effectively remains of C code never translated into proper C++.


I use no macro in my development.

The only #define I use is for conditional compilation (#ifdef #else #endif) but I try to keep their usage at minimum.


You need a macros for resource identifiers in Visual Studio as the resource compiler only understands them (i.e., it doesn't work with const or enum).

Harold Ekstrom
+2  A: 

I occasionally use macros so I can define information in one place, but use it in different ways in different parts of the code. It's only slightly evil :)

For example, in "field_list.h":

 * List of fields, names and values.
FIELD(EXAMPLE1, "first example", 10)
FIELD(EXAMPLE2, "second example", 96)
FIELD(ANOTHER, "more stuff", 32)
#undef FIELD

Then for a public enum it can be defined to just use the name:

#define FIELD(name, desc, value) FIELD_ ## name,

typedef field_ {

#include "field_list.h"


} field_en;

And in a private init function, all the fields can be used to populate a table with the data:

#define FIELD(name, desc, value) \
    table[FIELD_ ## name].desc = desc; \
    table[FIELD_ ## name].value = value;

#include "field_list.h"
Andrew Johnson
Note: similar technique can be implemented even without a separate include. See:

You can use #defines to help with debugging and unit test scenarios. For example, create special logging variants of the memory functions and create a special memlog_preinclude.h:

#define malloc memlog_malloc
#define calloc memlog calloc
#define free memlog_free

Compile you code using:

gcc -Imemlog_preinclude.h ...

An link in your memlog.o to the final image. You now control malloc, etc, perhaps for logging purposes, or to simulate allocation failures for unit tests.

Andrew Johnson
+2  A: 
#define ARRAY_SIZE(arr) (sizeof arr / sizeof arr[0])

Unlike the 'preferred' template solution discussed in a current thread, you can use it as a constant expression:

char src[23];
int dest[ARRAY_SIZE(src)];
This can be done with templates in a safer way (which won't compile if passed a pointer rather than an array)

Can you implement this as an inline function?

#define my_free(x) do { free(x); x = NULL; } while (0)
template<class T> inline void destroy(T* p = 0; }
@KTC: So right... A pity you can't upmod a comment... :-p ...
+1  A: 

You can #define constants on the compiler command line using the -D or /D option. This is often useful when cross-compiling the same software for multiple platforms because you can have your makefiles control what constants are defined for each platform.


In my last job, I was working on a virus scanner. To make thing easier for me to debug, I had lots of logging stuck all over the place, but in a high demand app like that, the expense of a function call is just too expensive. So, I came up with this little Macro, that still allowed me to enable the debug logging on a release version at a customers site, without the cost of a function call would check the debug flag and just return without logging anything, or if enabled, would do the logging... The macro was defined as follows:

#define dbgmsg(_FORMAT, ...)  if((debugmsg_flag  & 0x00000001) || (debugmsg_flag & 0x80000000))     { log_dbgmsg(_FORMAT, __VA_ARGS__);  }

Because of the VA_ARGS in the log functions, this was a good case for a macro like this.

Before that, I used a macro in a high security application that needed to tell the user that they didn't have the correct access, and it would tell them what flag they needed.

The Macro(s) defined as:

#define SECURITY_CHECK(lRequiredSecRoles) if(!DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, true)) return
#define SECURITY_CHECK_QUIET(lRequiredSecRoles) (DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, false))

Then, we could just sprinkle the checks all over the UI, and it would tell you which roles were allowed to perform the action you tried to do, if you didn't already have that role. The reason for two of them was to return a value in some places, and return from a void function in others...


LRESULT CAddPerson1::OnWizardNext() 
   if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_EMPLOYEE) {
   } else if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_CONTINGENT) {

Anyways, that's how I've used them, and I'm not sure how this could have been helped with templates... Other than that, I try to avoid them, unless REALLY necessary.


If you have a list of fields that get used for a bunch of things, e.g. defining a structure, serializing that structure to/from some binary format, doing database inserts, etc, then you can (recursively!) use the preprocessor to avoid ever repeating your field list.

This is admittedly hideous. But maybe sometimes better than updating a long list of fields in multiple places? I've used this technique exactly once, and it was quite helpful that one time.

Of course the same general idea is used extensively in languages with proper reflection -- just instrospect the class and operate on each field in turn. Doing it in the C preprocessor is fragile, illegible, and not always portable. So I mention it with some trepidation. Nonetheless, here it is...

(EDIT: I see now that this is similar to what @Andrew Johnson said on 9/18; however the idea of recursively including the same file takes the idea a bit further.)

// file foo.h, defines class Foo and various members on it without ever repeating the
// list of fields.

#if defined( FIELD_LIST )
   // here's the actual list of fields in the class.  If FIELD_LIST is defined, we're at
   // the 3rd level of inclusion and somebody wants to actually use the field list.  In order
   // to do so, they will have defined the macros STRING and INT before including us.
   STRING( fooString )
   INT( barInt )   
#else // defined( FIELD_LIST )

#if !defined(FOO_H)
#define FOO_H

// recursively include this same file to define class Foo
#include "foo.h"

// recursively include this same file to define method Foo::clear
#include "foo.h"

// etc ... many more interesting examples like serialization

#else // defined(FOO_H)
// from here on, we know that FOO_H was defined, in other words we're at the second level of
// recursive inclusion, and the file is being used to make some particular
// use of the field list, for example defining the class or a single method of it

#if defined( DEFINE_STRUCT )
#define STRING(a)  std::string a;
#define INT(a)     long a;
   class Foo
#define FIELD_LIST
// recursively include the same file (for the third time!) to get fields
// This is going to translate into:
//    std::string fooString;
//    int barInt;
#include "foo.h"

      void clear();
#undef STRING
#undef INT
#endif // defined(DEFINE_STRUCT)

#if defined( DEFINE_ZERO )
#define STRING(a) a = "";
#define INT(a) a = 0;
#define FIELD_LIST
   void Foo::clear()
// recursively include the same file (for the third time!) to get fields.
// This is going to translate into:
//    fooString="";
//    barInt=0;
#include "foo.h"
#undef STRING
#undef int
#endif // defined( DEFINE_ZERO )

// etc...

#endif // end else clause for defined( FOO_H )

#endif // end else clause for defined( FIELD_LIST )
+3  A: 

To fear the C preprocessor is like to fear the incandescent bulbs just because we get fluorescent bulbs. Yes, the former can be {electricity | programmer time} inefficient. Yes, you can get (literally) burned by them. But they can get the job done if you properly handle it.

When you program embedded systems, C uses to be the only option apart form assembler. After programming on desktop with C++ and then switching to smaller, embedded targets, you learn to stop worrying about “inelegancies” of so many bare C features (macros included) and just trying to figure out the best and safe usage you can get from those features.

Alexander Stepanov says:

When we program in C++ we should not be ashamed of its C heritage, but make full use of it. The only problems with C++, and even the only problems with C, arise when they themselves are not consistent with their own logic.

I think this is the wrong attitude. Just because you can learn to "properly handle it" doesn't mean it's worth anyone's time and effort.
Neil G
+9  A: 


  1. Include guards
  2. Conditional compilation
  3. Reporting (predefined macros like __LINE__ and __FILE__)
  4. (rarely) Duplicating repetitive code patterns.
  5. In your competitor's code.
David Thornley

You can enable additional logging in a debug build and disable it for a release build without the overhead of a Boolean check. So, instead of:

void Log::trace(const char *pszMsg) {
    if (!bDebugBuild) {
    // Do the logging


log.trace("Inside MyFunction");

You can have:

#ifdef _DEBUG
#define LOG_TRACE log.trace
#define LOG_TRACE void


LOG_TRACE("Inside MyFunction");

When _DEBUG is not defined, this will not generate any code at all. Your program will run faster and the text for the trace logging won't be compiled into your executable.

Ates Goral
One can achieve similar effect by playing with templates.
Sergey Skoblikov
inline void LogTrace(const char*) { if(DEBUG) doTrace(); } should be optimized away in release builds.
+2  A: 

String constants are sometimes better defined as macros since you can do more with string literals than with a const char *.

e.g. String literals can be easily concatenated.

#define BASE_HKEY "Software\\Microsoft\\Internet Explorer\\"
// Now we can concat with other literals
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "Settings", &settings);

If a const char * were used then some sort of string class would have to be used to perform the concatenation at runtime:

const char* BaseHkey = "Software\\Microsoft\\Internet Explorer\\";
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "Settings").c_str(), &settings);
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "TypedURLs").c_str(), &URLs);
+1  A: 

I once took a C++ application full of macros that took 45 minutes to build, replaced the macros with inline functions, and got the build down to less than 15 minutes.


Some very advanced and useful stuff can still be built using preprocessor (macros), which you would never be able to do using the c++ "language constructs" including templates.


Making something both a C identifier and a string

Easy way to use variables of enum types as string in C

Boost Preprocessor Metaprogramming

+1  A: 

Static Assert


I've used the preprocesser to calculate fixed-point numbers from floating point values used in embedded systems that cannot use floating point in the compiled code. It's handy to have all of your math in Real World Units and not have to think about them in fixed-point.


// TICKS_PER_UNIT is defined in floating point to allow the conversions to compute during compile-time.
#define TICKS_PER_UNIT  1024.0

// NOTE: The TICKS_PER_x_MS will produce constants in the preprocessor.  The (long) cast will
//       guarantee there are no floating point values in the embedded code and will produce a warning
//       if the constant is larger than the data type being stored to.
//       Adding 0.5 sec to the calculation forces rounding instead of truncation.
#define TICKS_PER_1_MS( ms ) (long)( ( ( ms * TICKS_PER_UNIT ) / 1000 ) + 0.5 )
This can be done with an inlined function
Will inline functions use other inline functions and prevent floating point values from getting in the final code? The example above is quite simple but I've used this method for computing rotational velocity of a wheel through several gears with different ratios based on the counts per revolution of a motor. The macros define each level of conversion.
+1  A: 

Yet another foreach macros. T: type, c: container, i: iterator

#define foreach(T, c, i) for(T::iterator i=(c).begin(); i!=(c).end(); ++i)
#define foreach_const(T, c, i) for(T::const_iterator i=(c).begin(); i!=(c).end(); ++i)

Usage (concept showing, not real):

void MultiplyEveryElementInList(std::list<int>& ints, int mul)
    foreach(std::list<int>, ints, i)
        (*i) *= mul;

int GetSumOfList(const std::list<int>& ints)
    int ret = 0;
    foreach_const(std::list<int>, ints, i)
        ret += *i;
    return ret;

Better implementations available: Google "BOOST_FOREACH"

Good articles available: Conditional Love: FOREACH Redux (Eric Niebler)

+1  A: 

Maybe the greates usage of macros is in platform-independent development. Think about cases of type inconsistency - with macros, you can simply use different header files -- like: --WIN_TYPES.H

typedef ...some struct


typedef ...some another struct


#ifdef WIN32

#include TYPES_H

Much readable than implementing it in other ways, to my opinion.


I've seen C++ header files with 1000 lines of macros. One of the macros was 100+ lines long. (wtf). This was code used in a emulator of some sort. No idea why.


How about token pasting?