Boost logo

Boost :

Subject: Re: [boost] Case study: Boost.Local versus Boost.Phoenix
From: Lorenzo Caminiti (lorcaminiti_at_[hidden])
Date: 2011-02-06 09:44:36

On Sun, Feb 6, 2011 at 7:20 AM, Alexander Nasonov <alnsn_at_[hidden]> wrote:
> Lorenzo Caminiti wrote:
>> On Fri, Feb 4, 2011 at 3:43 PM, Kenny Riddile <kfriddile_at_[hidden]> wrote:
>> > On 2/4/2011 3:39 PM, Phil Endecott wrote:
>> >> Anyway, I'm just going to wait for C++0x lambdas.
>> >
>> > +10000
> I came to the same conclusion 3 years ago and stopped working on
> BOOST_LOCAL_FUNCTION. This was a wrong decision. I'm glad that
> Lorenzo is working on the library.
>> Sorry, there is not point in me waiting for C++0x because I can only
>> use standard C++ in my application domain :((

Also, why don't C++0x lambdas support constant binding? (You can only
by & or value but not by const& or const value... why?)

>> I am sure in 10+ years a new embedded platform will come along with
>> C++0x... well, I am not sure but I hope so. However, for now, I am
>> "stock" with C++ (even pure C++ compliant preprocessor and template
>> metaprogramming tricks are seen suspiciously in this domain because it
>> is not clear if suppliers really test for them even if they are part
>> of the C++ standard...).
> Lorenzo, can you use typeof (sorry, if you already use it in the
> implementation, I've not looked at it yet) and variadic macros?

Yes, Boost.Local uses Boost.Typeof to automatically determine the type
of the bound variables. I am actually using *exactly* the same
mechanism that you Alex programmed for Boost.ScopeExit (with the
global variable `extern boost::scope_exit::aux::undeclared ...`,
typeof, etc) plus a patch from Adam Butcher to handle `typeof(*this)`
on MSVC (see

I think you are also asking if I can use typeof and variadic macros on
my embedded platform compiler:
1) Yes, I can use typeof because __typeof__ is actually part of the
compiler certification process (strangely enough given that is not
pure C++... it must be trivial to test for its correctness... I don't
know). Also, as I understand it, I can rely on Boost.Typeof (using
sizeof() + SFINAE template metaprogramming tricks) to emulate this
functionality on pure C++ compilers.
2) No, I cannot use variadic macros because they are not part of the
compiler certification process (even if they are actually there
because the preprocessor is really a gcc C99 perprocessor).
Also a general guideline in for my application domain is to stick with
100% standard to increase portability -- if a new platform comes along
the only reasonable assumption is for it to have a pure C++ standard
certified compiler (even if the current certified compiler has a C99
preprocessor, the next certified compiler might not -- if they change
the hardware a different base compiler than gcc could be used...).
(That said, if the embedded platform were to change there will be
quite a bit of low level code that will need to be re-written and
everything will need to be throughly re-tested so portability has a
restricted meaning in this context and I essentially hope nothing
changes with my platform, compiler, debugger, etc ;) .)


Boost list run by bdawes at, gregod at, cpdaniel at, john at