RE: [Boost-Users] Given std::map<ID,struct>, efficient way to access std::vector<struct.member>?

1 Sep 2003

      Well, I've trimmed you're example down some more, as to me it didn't seem to
be important that the struct was a member of CFilter.  So I think your
question boils down to :

struct A
{
	int	a;
};
typedef std::map my_map;

void do_something_on_a_slice(int a)
{
	// whatever
}

void f(const my_map& map_)
{
	std::for_each(map_.begin(), map_.end(), /*what goes here*/);
}

You could use iterator_adaptors for this, but I think that is complicating
things unnecessarily, something like this would work (untested) :

struct select_a : std::unary_function
{
	const result_type& operator()(const argument_type& arg) const
	{
		return arg.second.a;
	}
	// similar non const operator here
};

void f(const std::map& map_)
{
	boost::projection_iterator_generator::type first(map_.begin()), last(map_.end());
	std::for_each(first, last, do_something_on_a_slice);
}

See http://www.boost.org/libs/utility/projection_iterator.htm

But I think bind in this situation is a better solution.  (Partly because
the interface to iterator_adaptors will be changing in the next release,
possibly to the point of breaking the above code - Jeremy?)

void f(const my_map& map_)
{
	using boost::bind;
	std::for_each(map_.begin(), map_.end(),
		bind(do_something_on_a_slice,
			bind(&A::a,
				bind(&my_map::value_type::second, _1)
			)
		)
	);
}

Though at this point I would consider writing a function object, any
expression involving three bind's is getting close to (or some might say
past) write-only code.

As to efficiency, if this is a bottleneck it is mostly likely the iteration
over the map that is causing the problem, or the actual 'doing' code.  Most
of the binding code should be optimised away by the compiler to a bare
mimimum.  It may be that you are better changing container, a sorted vector
perhaps.

HTH

Sam

(PS Apologies if I did miss a point somewhere and oversimplify your code)

Chris Russell <> wrote:
...
Hello folks, I've got an interesting little design problem
and I'm looking
for some advice on how best to implement an efficient solution.
(snip)
...
Here's a simplified statement of the problem that I believe
outlines the
relevant details:
I've got a class declared as follows:
--- begin example class ----
...
In English: CFilter declares some structure with some number
of data members
of arbitrary types. Internally CFilter allocates a std::map of these
structures using some key_t. Effectively this defines a table
of data whose
rows are of type sRow_t, and whose columns can be conceptualized as
std::vector, std::vector where
std::vector.size() == mapData.size().
At runtime, CFilter.ProcessRow is called std::map.size() times followed by a single call to CFilter.ProcessData.
I'm trying to figure out how to _efficiently_ access the
column vectors in
the implementation of CFilter.ProcessData.

RE: [Boost-Users] Given std::map<ID,struct>, efficient way to access std::vector<struct.member>?

Sam Partington