Templated for-loop fantasy

[algorimancer]

I use the STL collection classes a lot, and frequently find myself
writing something like:

vector<CDataCla ss>::iterator iter=DataClassC ollection.begin ();
vector<CDataCla ss>::iterator iter_end=DataCl assCollection.e nd();
for(;iter!=iter _end;++iter)
{
//doing stuff with iter...
}

I have this fantasy that it ought to be possible to create a template
to replace all of that with something that looks like:

for<CDataClass> (DataClassColle ction) dataiteration;
//the for<> template could have a variety of loop types and data items
(iterators, etceteras)
//defined. A simple case that iterates over each element in the
DataClassCollec tion might
//look like this:
dataiteration.i terate
{
//doing stuff with "dataiteration. iter"
}

And yes, I know about the for_each method. The problem is that
for_each is a bit awkward to use, and I'd like a template construct
which has the capability of operating on a subsequent statement or
block of statements. I'm not aware that such a capabity exists in C++.

Any ideas/suggestions?
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[andy]

algorimancer wrote:

I use the STL collection classes a lot, and frequently find myself
writing something like:

vector<CDataCla ss>::iterator iter=DataClassC ollection.begin ();
vector<CDataCla ss>::iterator iter_end=DataCl assCollection.e nd();
for(;iter!=iter _end;++iter)
{
//doing stuff with iter...
}

Have you looked at boost ForEach macro, scheduled to be part of the
boost distro at some stage?

http://boost-consulting.com/vault/in...ory=Algorithms

If the link doesnt work go to http://www.boost.org. Find link to vault
and look in algorithms directory.

cheers
Andy Little

[James Hopkin]

algorimancer wrote:

I use the STL collection classes a lot, and frequently find myself
writing something like:

vector<CDataCla ss>::iterator iter=DataClassC ollection.begin ();
vector<CDataCla ss>::iterator iter_end=DataCl assCollection.e nd();
for(;iter!=iter _end;++iter)
{
//doing stuff with iter...
}

#include <boost/foreach.hpp>

BOOST_FOREACH(C DataClass& v, DataClassCollec tion)
{
// do stuff with v
}
James
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[algorimancer]

I had not been aware of the boost FOREACH macro, it looks like it could
do the trick. The boost library seems more accessible than the last
time I looked at it, I'll spend some more time there I think.

Thanks :)

[red floyd]

algorimancer wrote:

I use the STL collection classes a lot, and frequently find myself
writing something like:

vector<CDataCla ss>::iterator iter=DataClassC ollection.begin ();
vector<CDataCla ss>::iterator iter_end=DataCl assCollection.e nd();
for(;iter!=iter _end;++iter)
{
//doing stuff with iter...
}

I have this fantasy that it ought to be possible to create a template
to replace all of that with something that looks like:

for<CDataClass> (DataClassColle ction) dataiteration;
//the for<> template could have a variety of loop types and data items
(iterators, etceteras)
//defined. A simple case that iterates over each element in the
DataClassCollec tion might
//look like this:
dataiteration.i terate
{
//doing stuff with "dataiteration. iter"
}

You've probably thought of this, but...

template <typename Coll, typename Func>
void iterate(Coll& c, Func f)
{
std::for_each(c .begin(), c.end(), f);
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[roberts.noah]

algorimancer wrote:

And yes, I know about the for_each method. The problem is that
for_each is a bit awkward to use, and I'd like a template construct
which has the capability of operating on a subsequent statement or
block of statements. I'm not aware that such a capabity exists in C++.

Any ideas/suggestions?

There is also Boost Lambda and Phoenix that let you do things like:

for_each(begin, end, cout << arg1); // Phoenix version...

I've never used either I just mention it as an idea to look into.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[Valentin Samko]

ro**********@gm ail.com wrote:

There is also Boost Lambda and Phoenix that let you do things like:

I wouldn't use these libraries in a production code. For example, I really do not want to
see Boost.Lambda expression in a call stack when I am looking at a core dump of a
production problem. Also, the syntax of any nontrivial Boost.Lambda expression is just
unreadable (as it introduces a new syntax for already existing C++ constructs).
Not to mention that the compiled code is dog slow if inlining is disabled.

--

Valentin Samko - http://www.valentinsamko.com

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[Ivan Kolev]

James Hopkin wrote:

#include <boost/foreach.hpp>

BOOST_FOREACH(C DataClass& v, DataClassCollec tion)
{
// do stuff with v
}

This is not included in Boost yet. Actually, it wasn't easy to find the
source code - I found it only here:

http://www.nwcpp.org/Meetings/2004/01.html

There's also this page about the library:

http://www.boost.org/regression-logs...l/foreach.html

but I didn't find the source code there.

BOOST_FOREACH is a bit heavy (see the Portability page), actually, as
most Boost libraries. You can define simple macros for your own needs,
like this:

#define for_vector(T,v, i) \
for ( std::vector<T>: :iterator i=v.begin(); i != v.end(); ++i )

and use it like this:

for_vector( CDataClass, DataClassCollec tion, iter )
{
//doing stuff with iter...
}
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[James Hopkin]

Ivan Kolev wrote:

James Hopkin wrote:

#include <boost/foreach.hpp>

BOOST_FOREACH(C DataClass& v, DataClassCollec tion)
{
// do stuff with v
}
This is not included in Boost yet.

Thanks for pointing that out. I'd forgotten I'd dug it out of the boost
sandbox and imported it into our company copy of boost.


BOOST_FOREACH is a bit heavy (see the Portability page), actually, as
most Boost libraries.

I have to admit, it does pull in a lot of headers. But if you're using
boost regularly, that won't be noticeable, especially with the commonly
used stuff in a pre-compiled header.

You can define simple macros for your own needs,
like this:

#define for_vector(T,v, i) \
for ( std::vector<T>: :iterator i=v.begin(); i != v.end(); ++i )

Not such a bad idea, although I'd write it:

#define for_vector(T,v, i) \
for (std::vector<T> ::iterator i=v.begin(), _end = v.end(); i != _end;
++i)
Note that a major benefit of BOOST_FOREACH is that it works with any
container, pairs of iterators (e.g. a return value from equal_range)
and built-in arrays.
James
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[Ivan Kolev]

> I have to admit, it does pull in a lot of headers. But if you're using

boost regularly, that won't be noticeable, especially with the commonly
used stuff in a pre-compiled header.
Yes, it depends on whether you're using Boost or not. Once you start,
you get everything new in Boost sort of "for free".
Not such a bad idea, although I'd write it:

#define for_vector(T,v, i) \
for (std::vector<T> ::iterator i=v.begin(), _end = v.end(); i != _end;
++i)
Indeed. Though I guess vector::end() should be simple enough to be
inlined, this could be useful for other containers.
Note that a major benefit of BOOST_FOREACH is that it works with any
container, pairs of iterators (e.g. a return value from equal_range)
and built-in arrays.

BOOST_FOREACH is impressive. By coincidence, I was working these days
on something similar, trying to create something like a generic
iterator class, but of course nothing can beat the Boost libraries. So
the news about BOOST_FOREACH was very timely for me - thank you :).
Although our project is not "Boost-enabled" yet, it's good to know what
can be done, and also what can we expect of the next standard. Having
foreach included in C++0x would be great.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]