in-place functor comparison instead of std::binary_function

[news.online.no]

Hi all

Rather than writing std::binary:functions I thought it would be nice to
create a comparison expression directly into the algorithm expression.
Typical use is

struct Person
{
std::string name () const;
};

// Find "John"
std::vector<Person>::iterator it = std::find_if (persons.begin(),
persons.end(), somehow bind Person::name method == "John");

While std::equal could be used in some simple cases, it does not accept
mixed input like &Person::name and "John" (at least to my knowledge)

Is there a way to accomplish this type of comparison using a mix of
binding of functions /return values and plain values ?

Thanks,

Anders

[peter steiner]

news.online.no wrote:

Hi all

Rather than writing std::binary:functions I thought it would be nice to
create a comparison expression directly into the algorithm expression.
Typical use is

struct Person
{
std::string name () const;
};

// Find "John"
std::vector<Person>::iterator it = std::find_if (persons.begin(),
persons.end(), somehow bind Person::name method == "John");

While std::equal could be used in some simple cases, it does not accept
mixed input like &Person::name and "John" (at least to my knowledge)

Is there a way to accomplish this type of comparison using a mix of
binding of functions /return values and plain values ?

boost::lambda provides a solution to your problem.

std::vector<Person>::iterator it = std::find_if (persons.begin(),
persons.end(), bind(&Person::name, _1) == "John");

it is perfectly suited for simple ad-hoc functor declarations in
std::algorithms and the like.

have a look at http://boost.org/doc/html/lambda.

-- peter

[Daniel T.]

In article <bu********************@telenor.com>,
"news.online.no" <an********@geocap.no> wrote:

Hi all

Rather than writing std::binary:functions I thought it would be nice to
create a comparison expression directly into the algorithm expression.
Typical use is

struct Person
{
std::string name () const;
};

// Find "John"
std::vector<Person>::iterator it = std::find_if (persons.begin(),
persons.end(), somehow bind Person::name method == "John");

While std::equal could be used in some simple cases, it does not accept
mixed input like &Person::name and "John" (at least to my knowledge)

Is there a way to accomplish this type of comparison using a mix of
binding of functions /return values and plain values ?

compose1(bind2nd(equal_to<string>(), "John"), mem_fun_ref(&Person::name))

The above predicate takes a Person&, calls '.name()' on it, the passes
the result to a binder2nd which it to "John" using equal_to<string>.

Warning: compose1 is not part of the standard library, but is part of
the original STL. Look it up in <http://www.sgi.com/tech/stl/> for
example.

--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.