Quoting "Warlich, Christof \(Christof\)" :
Hi,
the following code does not compile:
#include
#include
#include
#include <iostream>
class A {};
int main(void) {
BOOST_PP_IIF(boost::is_convertible::value, //
condition
std::cout << "ifbranch";, //
then
std::cout << "elsebranch";); //
else
return 0;
}
There's a few things wrong with this.
Firstly you write BOOST_PP_IIF but include
- you probably meant BOOST_PP_IF.
But more seriously your "condition" is not a number known at
preprocessor-time - i.e. it won't evaluate to a number at
pre-processor time, only at compile-time when the
boost::is_convertible template magic kicks in. Thus BOOST_PP_IF
wouldn't expand as you expect.
However, you aren't even seeing an error related to that problem.
BOOST_PP_COMMA() is indeed being evaluated before the BOOST_PP_IIF()
and thus the compiler is complaining about 4 arguments to the latter
macro - compilers do vary in how they expand macros - search the
developer's list for Paul Mensonides' essay "How macro expansion
works" for more - but you will be safe if your _force_ the COMMA macro
to be expanded after the IF one. The following trick occurs over and
over in writing preprocessor code:
BOOST_PP_IF( X , BOOST_PP_COMMA , BOOST_PP_EMPTY )()
Because BOOST_PP_COMMA and BOOST_PP_EMPTY are function-like macros
they cannot possibly expand until they are "next to" the (). This can
only happen once the BOOST_PP_IF has been evaluated. I.e. the above
example will evaluate to a comma if X is non-zero and nothing
otherwise....
I'd like to know if there is common name for this trick as I find
'"macro name inside the IF, macro arguments outside"-trick' a bit
verbose when discussing with colleagues.
Pete
