How do I temporarily disable a macro expansion in C/C++?

Question

For some reason I need to temporarily disable some macros in a header file and the #undef MACRONAME will make the code compile but it will undef the existing macro.

Is there a way of just disabling it?

I should mention that you do not really know the values of the macros and that I'm looking for a cross compiler solution (should work at least in GCC and MSVC).

Answer 1

In MSVC you could use push_macro pragma, GCC supports it for compatibility with Microsoft Windows compilers.

#pragma push_macro("MACRONAME")
#undef MACRONAME

// some actions

#pragma pop_macro("MACRONAME")

Answer 2

Using just the facilities defined by Standard C (C89, C99 or C11), the only 'disable' mechanism is #undef.

The problem is there is no 're-enable' mechanism.

---

As others have pointed out, if the header file containing the macro definitions is structured so that it does not contain any typedef or enum declarations (these cannot be repeated; function and variable declarations can be repeated), then you could #undef the macro, do what you need without the macro in effect, and then re-include the header, possibly after undefining its protection against reinclusion.

If the macros are not defined in a header, of course, you are stuck until you refactor the code so that they are in a header.

One other trick is available - if the macros are function-like macros and not object-like macros.

#define nonsense(a, b)   b /\= a

int (nonsense)(int a, int b)
{
    return (a > b) ? a : b;
}

The function nonsense() is defined fine, despite the macro immediately before it. This is because a macro invocation - for a function-like macro - must be immediately followed by an open parenthesis (give or take white space, possibly including comments). In the function definition line, the token after 'nonsense' is a close parenthesis, so it is not an invocation of the nonsense macro.

Had the macro been an argument-less object-like macro, the trick would not work:

#define nonsense min

int (nonsense)(int a, int b)
{
    // Think about it - what is the function really called?
    return (a > b) ? a : b;
}

This code defines a bogus function that's called min and is nonsensical. And there's no protection from the macro.

This is one of the reasons why the standard is careful to define which namespaces are reserved for 'The Implementation'. The Implementation is allowed to define macros for any purpose it desires or needs, of any type (function-like or object-like) it desires or needs, provided those names are reserved to the implementation. If you as a consumer of the services of The Implementation try to use or define a name reserved to the implementation, you must be aware that your code will probably break sooner or later, and that it will be your fault, not the fault of The Implementation.

Answer 3

Macros make my knees go weak, but wouldn't the most universal solution be to restructure your code so that you wouldn't need to reenable the macro again in the same source file? Wouldn't it be possible to extract some code into a separate function and a separate source file where you can undef the offending macro.

Answer 4

The macros come from some header file, so you should have access to their values. You can then do something like

#include <foo.h> // declares macro FOO

// Do things with FOO

#undef FOO

// do things without FOO

#include <foo.h> // reenable FOO

Your header should then be designed along these lines

#ifndef FOO
#define FOO do_something(x,y)
#endif

Answer 5

EDIT:

You may think that it's that easy:

#ifdef macro
#define DISABLED_macro macro
#undef macro
#endif

// do what you want with macro

#ifdef DISABLED_macro
#define macro DISABLED_macro
#endif

But it's not (like the following example demonstrates)!

#include <iostream>
#include <limits>

#include <windows.h>

#ifdef max
#define DISABLED_max max
#undef max
#endif

int main()
{
    std::cout << std::numeric_limits<unsigned long>::max() << std::endl;

#ifdef DISABLED_max
#define max DISABLED_max
#endif

    std::cout << max(15,3) << std::endl;  // error C3861: "max": identifier not found
    return 0;
}

Using #undef on the macro and re-including the original header is also not likely to work, because of the header guards. So what's left is using the push_macro/pop_macro #pragma directives.

#pragma push_macro("MACRO")
#undef MACRO
// do what you want
#pragma pop_macro("MACRO")

Answer 6

There are specific rules for function-like macroses invokation in C/C++ language. The function-like macroses have to be invoked in the following way:

1. Macros-name
2. Left parethesis
3. One token for each argument separated by commas

Each token in this list can be separared from another by whitespaces (i.e. actual whitespaces and commas)

---

With one trick you "disable preprocessor mechanism" with breaking rules for function-like macro invokation, but be still within a rules of function calling mechanism...

#include <iostream>
using namespace std;

inline const char* WHAT(){return "Hello from function";}

#define WHAT() "Hello from macro"

int main()
{
    cout << (*WHAT)() << "\n"; // use function
    cout << (WHAT)() << "\n";  // use function
    cout << WHAT () << "\n";   // use macro
    
    return 0;
}