How is BOOST_PREVENT_MACRO_SUBSTITUTION supposed to work? - c++

Question

I'm reading boost's config/suffix.hpp, and I'm surprised with the following code:
// Workaround for the unfortunate min/max macros defined by some platform headers
#define BOOST_PREVENT_MACRO_SUBSTITUTION
// <skipped unimportant lines>
namespace std {
template <class _Tp>
inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
return __b < __a ? __b : __a;
}
template <class _Tp>
inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
return __a < __b ? __b : __a;
}
}
This actually seems to be a valid thing to make the definitions of min and max functions compile when the same-named macros are defined. But why would this be useful at the actual call site? Wouldn't the macro actually substitute when the functions are called? I've tried to make a simple test, "emulating" this setup:
#include <iostream>
#define PREVENT_MACRO_SUBSTITUTION
#define max(x,y) ((x)<(y)?(y):(x))
namespace test
{
int max PREVENT_MACRO_SUBSTITUTION (int a, int b)
{
std::cerr << "Function max\n";
return a<b?b:a;
}
}
int main()
{
int x=test::max(5,6);
std::cout << "x="<<x<<"\n";
}
And, as expected, I get a compilation error due to expansion of max macro. So, how is boost's macro substitution prevention supposed to work?

Answer 1

It's not supposed to do what you think it's supposed to do.
If a min or max macro is defined, and the user wishes to call those std::min or std::max functions, it's the user's responsibility to make sure the macro is suppressed. Possibly again using BOOST_PREVENT_MACRO_SUBSTITUTION, possibly using parentheses ((std::min) (...)).
All the use of BOOST_PREVENT_MACRO_SUBSTITUTION is doing here is preventing a syntax error from being raised for the definition of std::min and std::max, like you figured out already. It would happily expand min as a macro if the header had used inline const _Tp& min (const _Tp& __a, const _Tp& __b), resulting in something like inline const _Tp& ((const _Tp& __a) < (const _Tp& __b) ? (const _Tp& __a) : (const _Tp& __b)). But if code doesn't actually use min or max, then including that header file should be harmless.