Re: Vector reserve in a for_each
kwikius wrote:
On 24 Feb, 08:42, Alan Johnson <a...@yahoo.com> wrote:
Chris Roth wrote:
I have a vector of vectors:
vector< vector<double> > v;
and have initialized it with:
v( 5 );
as I know I will have 5 columns of data. At this point, I read text file
data into each of the the vectors using push_back. I know that I will be
reading in 5000 elements into each vector, so I use reserve:
ifstream f( "file.txt" );
if(f.is_open())
{
for( vector< vector<double> >::iterator itr = v.begin();
itr != v.end(); ++itr )
{
itr->reserve(5000);
}
double d;
while(f >> d)
{
m_data[0].push_back( d );
f >> d;
m_data[1].push_back( d );
f >> d;
m_data[2].push_back( d );
f >> d;
m_data[3].push_back( d );
f >> d;
m_data[4].push_back( d );
}
}
However, could I use a for_each to set the reserve of the vectors? Or is
there a different/better way to read in the 5 column text data?
Thanks in advance.
Here's how you'd do it. But I would comment that in the amount of time
it took me to get the syntax just right I could have written the
equivalent for loop a hundred times over.
Somehow I just feel that things could be so much sweeter...
#include <algorithm>
#include <functional>
#include <vector>
#include <iostream>
#include <boost/preprocessor/cat.hpp>
#define CONTAINER_FUN_ADAPT1(ret,fun,arg) > namespace impl{ > struct BOOST_PP_CAT(fun,_fun){ > arg v; > BOOST_PP_CAT(fun,_fun)(arg v_in) > : v(v_in){} > template <typename C> > ret operator()( C & c)const > { > c. fun(v); > } > }; > } > impl::BOOST_PP_CAT(fun,_fun) fun( arg v) > { > return impl::BOOST_PP_CAT(fun,_fun)(v); > } >
namespace my{
// reserve space in a container adaptor
CONTAINER_FUN_ADAPT1(void,reserve,size_t);
// wrap ugly std:: syntax
template <typename Seq, typename F>
void for_each(Seq & seq,F const & f)
{
std::for_each(seq.begin(),seq.end(),f);
}
}
int main()
{
//--------ugly --------------
std::vector< std::vector<double> > v1(5) ;
std::for_each(
v1.begin(), v1.end(),
std::bind2nd(
std::mem_fun_ref(
&std::vector<double>::reserve
),
5000
)
);
//check it worked...
std::cout << (int) v1[2].capacity() <<'\n';
//----- pretty ---------------
std::vector< std::vector<double> > v2(5) ;
my::for_each(v2,my::reserve(5000));
//check it worked...
std::cout << (int) v2[2].capacity() <<'\n';
}
This thread is a good example of why C++ needs lambda functions (or
anonymous functions, or function literals, or whatever you want to call
them). The concept of doing the same thing to every item in a container
is arguably the most common algorithm one would apply to a container,
but use C++'s for_each is just such a pain.
Either you need to write a functor, which typically needs to be a full
blown class with at least operator() and a constructor that wraps up
enough of the local state to be useful, or you have to play around with
binders and generic function objects. boost::function and boost::bind
seem like the answer for the few moments until you actually try to do
something non-trivial with them, like compose two functions that are
created by binding parameters on two other functions, at which point you
realize that because this is all just a library hack, you have to
surround the inner binds with a boost::protect. And lord help you if
you are trying to do any of this in a scope where it isn't convenient to
add a "using namespace boost ;".
Typically after struggling with indecipherable compiler errors for an
hour or so, most people just give up and spend 2 minutes writing a for loop.
--
Alan Johnson