Re: standard vs. hand crafted loops
pavel.turbin@gmail.com wrote:
I've seen many times advise to use standard loops e.g. for_each,
instead of iterator and for loop. I was trying to follow this hint.
But, it looks it involves extra complexity and the code getting larger
without any benefits for me.
for example: count length of each string wrapped into another object
(MyData):
=======================================================
class MyData // some object
{
std::string m_s;
public:
MyData( const std::string &s ) : m_s(s) {}
size_t len() const { return m_s.length(); }
};
class legngth // helper for for_each
{
size_t cnt; // accumulate result
public:
legngth(){ cnt = 0;} // initialize
void operator ()( const MyData &d) { cnt += d.len(); }
operator size_t() { return cnt; } // return the result
};
int _tmain(int argc, _TCHAR* argv[])
{
std::vector<MyData> vec;
vec.push_back(MyData("a"));
vec.push_back(MyData("b"));
vec.push_back(MyData("c"));
//
// count length for all objects of "vec"
//
size_t l = 0;
// standard algorithm
l = std::for_each( vec.begin(), vec.end(), legngth() );
l = 0;
// hand crafted loop
for( std::vector<MyData>::iterator i=vec.begin(); i < vec.end();
++i)
l += i->len();
return 0;
}
=======================================================
Using for_each it takes 10 lines and auxiliary Function object.
Compare
"for" loop it is only 3 lines. Such example looks as very common case,
it is typical to perform two or more operations on container. Create
function object looks as extra useless work.
Is there any better way to write such loops in general?
It is possible to reduce the loop to a single line without having to
write any supporting code:
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include <tr1/functional>
#include <tr1/utility>
using std::plus;
using std::tr1::bind;
using std::tr1::placeholders::_1;
using std::tr1::placeholders::_2;
class MyData
{
std::string m_s;
public:
MyData( const std::string &s ) : m_s(s) {}
size_t len() const { return m_s.length(); }
};
int main()
{
std::vector<MyData> vec;
vec.push_back(MyData("a"));
vec.push_back(MyData("bc"));
vec.push_back(MyData("cde"));
int length = 0;
length = std::accumulate( vec.begin(), vec.end(), length,
bind( plus<int>(),
_1,
bind(&MyData::len, _2)));
std::cout << "length is " << length << "\n";
}
Program Output:
length is 6
And did I mention "concise"? No, I did not - and just as well because
unfortunately the accumulate loop is not particularly concise. Nor is
this code probably as clear as we would prefer it to be. And while
using lambda expressions is one approach to improve its readability, I
think built-in container support support for a generic, iterator
adapter would make for a more simple, more accessible solution:
// fictional implementation
int length = 0;
length = std::accumulate( vec.begin<&MyData::len>(),
vec.end<&MyData::len>(),
length); // not possible currently
In this hypothetical example a container's begin() and end() methods
would have function template overloads parameterized by member function
pointer of the contained class. The template versions of these method
would return an iterator adaptor such that dereferencing the iterator
returns - not the contained itemi itself - but the result of invoking
the member function upon the contained item.
In this way it would be possible to iterate over the "lengths" (or any
other accessible property) of each of the MyData items in the container
and to do so without resorting to baroque expressions. Actually, I
think this idea might be worthwhile proposal to enchance container
classes - depending of course on the necessary support for some kind of
iterator adaptor being present as well.
Greg
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]