Re: std::for_each + break

From:

terminator <farid.mehrabi@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 23 Nov 2007 04:26:41 -0800 (PST)

Message-ID:

<cd5684c5-234d-4189-a526-9eb1f01c0d4a@s6g2000prc.googlegroups.com>

On Nov 22, 12:14 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:

terminator wrote:

On Nov 20, 3:13 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:

terminator wrote:

On Nov 20, 12:45 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:

Kira Yamato wrote:

On 2007-11-19 07:12:29 -0500, yurec
<Yurij.Zha...@materialise.kiev.ua> said:

Hi

I wanna give template method of library class with some predicate,
which I put to std::for_each in that method.How to break the
std::for_each with predicate?(exceptions are used olny in
exceptional situations, as i know)

Thanks

I would think throwing an exception is a simple and elegant solution
here.

Simple and elegant? in this case?

Compare

  try {
    std::for_each( seq.begin(), seq.end(),
    throwing_predicate_and_action );
  }
  catch ( whatever ) {}

to

  for ( iterator_type iter = seq.begin();
        iter != seq.end() && ! break_condition( *iter );
        ++iter ) {
    some_action( *iter );
  }

I cannot say that I find the try-throw-catch version easier to grok or
more elegant.

Just because we have called a mechanism 'exception' and gave it the
connotation that it is for error-handling purposes, does not mean
that we can only use the mechanism as such and nothing else.

I wholeheartly agree to that. I prefer to refer to the mechanism as
try-throw-catch or stack-unwinding to avoid connotations. Sometimes,
when someone says "exception are only to be thrown is exceptional
circumstances", I reply (only half-jokingly): "ok. so throw something
else".

Ok, so some runtime cost is needed to setup try-catch blocks, but
I'm not sure scanning the list twice with find_if/for_each combo is
necessarily faster.

No, but a simple for loop might be (and it also might convey intend
better than any of the alternatives).

what`s wrong with std::find_if when breaking is needed?

It depends: std::find_if conveys the intend of searching. It goes against
expectations to use it with a predicate whose evaluation leaves
side-effects on the container elements. On the other hand, std::for_each
carries no such connotation (although some people feel otherwise on the
ground that the standard classifies it as non-mutating). So, std::find_if
is not a good substitute for std::for_each in the case where you just
want a loop that performs some action on an initial segment of the list.

I guess, the way to do this idiomatically in STLeese is something like:

std::for_each( begin, std::find_if( begin, end, condition ), action );

Now, I see that the OP did not specify whether there is a need for
performing an action on the elements of the sequence or whether the task
at hand is simply to find the first where a condition holds. In the later
case, std::find_if is of course perfectly fine.

that is double looping :too much run time.

Before you come to that conclusion, you might want to measure. Note that
during the first loop, only the condition is evaluated and during the
second loop only the action is evaluated. That means, as long as
incrementing iterators is cheap compared to evaluating the condition and
performing the action, the double looping is should not be expected to be
significantly more expensive.

Moreover, optimization in compilers has come a long way and I wouldn't be
surprised if the compiler would actually fold the two loops into one
(especially since the first is only used to determine the upper bound for
the second).

you have solved the case that checking precedes modification;

for(...){
    if(...) break;
    ...
};

so what would you do if some part of modifiction is intended precede
the 'break' .I mean:

for(...){
    ...
    if(...) break;
    ...
}

the elements after the breaking iterator are supposed to remain
unprocessed of course.
what would you do with multiple breaking?(like this:)

for(...){
    ...
    if(...) break;
    ...
    if(...) break;
    ...
}

But the main mantra with respect to performance is: measure, measure,
measure, measure, ...

despite irreadability 'find_if' gives a breakable loop that relies on
the return value of pred.This is far faster than breaking throughout
exceptions.Is there a third solution which is both fast and readable?

Upthread, I suggested:

  for ( ... ) {
    ...
  }

and I still find it readable and fast.

you migth find this readable too:

for (hell_template <with_lots_of_args>::iterator
it=container.begin();...)...;

of course 'auto' can fix this in next generation of c++ compilers:

for(auto it=container.begin();...)...;

regards,
FM.