Here's one way to do it using std::tr1::bind:

mikets <mikets@frontline-pcb.com> wrote:

Hi there,

I found out that very often I use the following construct:

for (it = myvec.begin(); it != myvec.end(); ++it) {
if (it->name() == "myname")
break;
}

Certainly, the container the method and the constant can be of
any type.

The purpose is to have a template functor and use the
std::find_if instead of above loop.
I tried to mix something with std::mem_func and std::equal.
It looks that this is above my powers.

it = find_if(myvec.begin(), myvec.end(),
compose1(bind2nd(equal_to<string>(), "myname"),
mem_fun_ref(&foo::name)));

Note: the above uses the non-standard, but obviously very useful,
unary_compose adaptor. An implementation of which can be found on SGI's
website.

Here is a complete program proving that the above find_if is equivalent
to your origional loop:

/*
* Portions Copyright (c) 1994 Hewlett-Packard Company
* used with permission.
*/


#include <string>
#include <iostream>
#include <vector>
#include <functional>

class foo {
std::string _name;
public:
foo( const std::string& n ): _name( n ) { }
const std::string& name() const { return _name; }
};

template <class _Operation1, class _Operation2>
class unary_compose
: public std::unary_function<typename _Operation2::argument_type,
typename _Operation1::result_type>
{
protected:
_Operation1 _M_fn1;
_Operation2 _M_fn2;
public:
unary_compose(const _Operation1& __x, const _Operation2& __y)
: _M_fn1(__x), _M_fn2(__y) {}
typename _Operation1::result_type
operator()(const typename _Operation2::argument_type& __x) const {
return _M_fn1(_M_fn2(__x));
}
};

template <class _Operation1, class _Operation2>
inline unary_compose<_Operation1,_Operation2>
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}

int main()
{
using namespace std;
vector<foo> myvec;
myvec.push_back( foo( "joe" ) );
myvec.push_back( foo( "myname" ) );
myvec.push_back( foo( "harold" ) );

vector<foo>::iterator it;
for (it = myvec.begin(); it != myvec.end(); ++it) {
if (it->name() == "myname")
break;
}
assert( it->name() == "myname" );

vector< foo >::iterator it2 = find_if( myvec.begin(), myvec.end(),
compose1( bind2nd( equal_to<string>(), "myname" ),
mem_fun_ref(&foo::name) ) );
assert( it2 == it );

cout << "OK" << endl;
}

mikets <mikets@frontline-pcb.com> wrote:

Hi there,

I found out that very often I use the following construct:

for (it = myvec.begin(); it != myvec.end(); ++it) {
if (it->name() == "myname")
break;
}

Certainly, the container the method and the constant can be of
any type.

The purpose is to have a template functor and use the
std::find_if instead of above loop.
I tried to mix something with std::mem_func and std::equal.
It looks that this is above my powers.

it = find_if(myvec.begin(), myvec.end(),
compose1(bind2nd(equal_to<string>(), "myname"),
mem_fun_ref(&foo::name)));

Note: the above uses the non-standard, but obviously very useful,
unary_compose adaptor. An implementation of which can be found on SGI's
website.

Here is a complete program proving that the above find_if is equivalent
to your origional loop:

/*
* Portions Copyright (c) 1994 Hewlett-Packard Company
* used with permission.
*/


#include <string>
#include <iostream>
#include <vector>
#include <functional>

class foo {
std::string _name;
public:
foo( const std::string& n ): _name( n ) { }
const std::string& name() const { return _name; }
};

template <class _Operation1, class _Operation2>
class unary_compose
: public std::unary_function<typename _Operation2::argument_type,
typename _Operation1::result_type>
{
protected:
_Operation1 _M_fn1;
_Operation2 _M_fn2;
public:
unary_compose(const _Operation1& __x, const _Operation2& __y)
: _M_fn1(__x), _M_fn2(__y) {}
typename _Operation1::result_type
operator()(const typename _Operation2::argument_type& __x) const {
return _M_fn1(_M_fn2(__x));
}
};

template <class _Operation1, class _Operation2>
inline unary_compose<_Operation1,_Operation2>
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}

int main()
{
using namespace std;
vector<foo> myvec;
myvec.push_back( foo( "joe" ) );
myvec.push_back( foo( "myname" ) );
myvec.push_back( foo( "harold" ) );

vector<foo>::iterator it;
for (it = myvec.begin(); it != myvec.end(); ++it) {
if (it->name() == "myname")
break;
}
assert( it->name() == "myname" );

vector< foo >::iterator it2 = find_if( myvec.begin(), myvec.end(),
compose1( bind2nd( equal_to<string>(), "myname" ),
mem_fun_ref(&foo::name) ) );
assert( it2 == it );

cout << "OK" << endl;
}

mikets wrote:

Hi there,

I found out that very often I use the following construct:

for (it = myvec.begin(); it != myvec.end(); ++it) {
if (it->name() == "myname")
break;
}

Certainly, the container the method and the constant can be of
any type.

The purpose is to have a template functor and use the
std::find_if instead of above loop.
I tried to mix something with std::mem_func and std::equal.
It looks that this is above my powers.

Here is a candidate predicate:


template < class T,
class ConstType,
const ConstType (T::*method)() >
class EqualThruMemFunc {
public:
EqualThruMemFunc( const ConstType& value ) :
mValue( value ) { }
bool operator()( T& instance ) {
return (instance.*method)() == mValue ;
}
private:
const ConstType& mValue ;
} ;

class Foo {
public
// ...
const std::string name() ;
} ;

// ...

typedef vector<Foo> MyVecType ;
//
MyVecType myvec ;

MyVecType::iterator it =
find_if( myvec.begin(),
myvec.end(),
EqualThruMemFunc<MyVecType,
std::string,
&MyVecType::name>("myname") ) ;


I am sure there is a more elegant solution for a general case. But this
should get you started.

Later,