Boost logo

Boost :

From: Douglas Gregor (gregod_at_[hidden])
Date: 2001-08-17 09:24:42

On Thursday 16 August 2001 07:35, you wrote:
> Douglas Gregor wrote:
> > Boost.Function can eliminate the need for the template parameters:
> > typedef boost::function<void> Action;
> > typedef boost::function<bool> Pred;
> >
> > A library like Lambda, Boost.Bind, or FACT would let you define the
> > predicate and action inline.
> In general, it cannot be done.
> If you consider, say:
> x = x + 1
> you can wrap it using something like
> ASSIGN ( VAR(&x), SUM ( VAR(&x), VAL (1) )
> [the actual tempate code is probably grosser :-[

I believe it would be:
  bind(ref(x) = ref(x) + free1, 1)

> but such a decomposition only works for some constructions.
> Other constructions cannot be wrapped. For example,
> functions with n arguments, where n exceeds the number
> supported by the library. Struct member access,
> pointer to member formation, exception handling,
> multiple inheritance ... the list is long.

Most of these are possible - "n" can always be increased (and most libraries
make it easy), Lambda supports exception handling; struct member
access/pointer to member formation can be done (just form a pointer-to-member
and pass it). I'm not saying the result is pretty, but I believe most
constructs _can_ be handled. The only glaring omission I've found is the lack
of "break"; exception handling works, but has terrifying performance
implications on some compilers :(.

Multiple inheritance doesn't quite fit the above list, unless we're talking
about very different problems...

> FYI: I was writing a book on STL some years ago,
> and I gave up because, while it is _possible_ to do quite
> significant work using templates, the result
> is so gross as to be useless. You can replace
> a loop
> for(;;) { body }
> with
> for_each(body_functoid)
> but then you have to translate the body, and in the end
> the first form is easier to write, gives better
> diagnostics, compiles faster, generates better code,
> etc etc .. in the end, template metaprogramming
> is only interesting if you're considering how to
> fix the core language to actually make it useful.
> The killer was a triple loop: three or four lines
> of C++ turned into several _pages_ of templates.
> I used only plain STL, so I guess you could do better
> with more combinators (eg using Lambda or Bind,
> or whatever), but in the end, these library cannot
> solve the general problem, only slightly expand
> the class of problems which can be solved.

An identifier is worth a hundred comments, IMHO. This is by far more of a
religious issue than any other, but given:

Container container;
for(Container::iterator i = container.begin(), i != container.end(); ++i)
  // code that does something


for_each(container.begin(), container.end(), doSomething());

I'll almost always take the second version, because doSomething can be an
identifier that concisely state what operation is performed on each object.
It couldn't possibly read more clearly.


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