Re: C++ Frequently Questioned Answers
on Wed Nov 14 2007, "Andrei Alexandrescu (See Website For Email)"
<SeeWebsiteForEmail-AT-erdani.org> wrote:
The main arguments for embedded metaprogramming have to do with
interoperability:
1. C++ has (limited but) powerful introspection capabilities about its
own types. When you write semantic actions for YACC, it can only
do a fairly dumb textual translation. More sophisticated things
aren't really possible. I realize they're also not needed in that
case, so you may have to stretch your imagination a bit.
2. you get seamless interoperability between different DSLs and your
other libraries, because they're all trafficking in the same
"stuff:" C++ code entities (like types).
That explains the template part just fine, but not the
preprocessor-based horrors.
Short answer: it's better than any alternative we have.
Longer answer: I used to generate C++ code, when I needed to, with
Python scripts. It didn't turn out to be any easier, nor in the end
the code any more understandable, than what I get after having
developed moderate competence with Boost.Preprocessor. Furthermore,
my users were constantly running into the limits of what I generated.
I would hear, every few months, "we have functions with 15 arguments
and your library doesn't support that." Then I would have to explain
to them how to regenerate the code, which many people aren't
comfortable with (they want to use the source as released). With
Boost.Preprocessor I have an easily-documented macro that they can set
on their command-line:
c++ -I/path/to/boost -DBOOST_MYLIBRARY_ARITY_LIMIT=22 sourcefile.cpp
Also, with vertical repetition
(http://www.boost-consulting.com/tmpbook/preprocessor.html#vertical-repetition)
I can debug my source code in place without seeing a bunch of #line
directives when I look at the C++ source.
Finally, in some cases, providing macros as part of a library
interface allows us to offer library interfaces to anything available
with templates. For example, for the current version of
http://boost.org/libs/parameter, Daniel Wallin implemented the
BOOST_PARAMETER_FUNCTION macro
(http://boost.org/libs/parameter/doc/html/index.html#writing-the-function),
which makes the library infinitely easier to use. Instead of writing
a bunch of cumbersome boilerplate forwarding functions by hand, you
have the preprocessor generate them for you. It's a massive
convenience compared to anything else.
Naturally, the fact that sometimes the C++ preprocessor is the best
metaprogramming tool we have points to some inherent weaknesses in
C++'s other metaprogramming facilities. As we introduce modules,
variadic templates, and modular metaprogramming, I hope we'll be able
to put most uses of the preprocessor behind us.
Cheers,
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]