class FFindObjectByName
{
public:
    FFindObjectByName(const std::string &ObjectName)
    : m_ObjectName(ObjectName)
    {
    }

    bool operator()(const CObject *Object)
    {
        return m_ObjectName == Object->GetName();
    }

private:
    const std::string &m_ObjectName;
};

void CObjectNode::EraseObject(const std::string &ObjectName)
{
    TVectorObject::iterator it_find = 
        std::find_if(
        m_Children.begin(),
        m_Children.end(), 
        FFindObjectByName(ObjectName) );
    
    EraseObject(it_find);
}

template<typename T_Class, typename T_Member>
class FCompareMember 
: public std::unary_function<T_Class, bool>
{
    typedef T_Member T_Class::* TMemberPtr;
public:
    FCompareMember(TMemberPtr MemPtr, const T_Member& MemVal) 
        : m_MemPtr(MemPtr)
        , m_MemVal(MemVal) 
    {
    }

    bool operator()(const T_Class* obj) const 
    { 
        return obj->*m_MemPtr == m_MemVal; 
    }

private:
    TMemberPtr    m_MemPtr;
    T_Member    m_MemVal;
};

template<typename T_Class, typename T_Member>
    FCompareMember<T_Class,T_Member> compare_member( 
    T_Member T_Class::* MemPtr, const T_Member& MemVal)
{
    return FCompareMember<T_Class,T_Member>(MemPtr,MemVal);
}

bool operator()(const T_Class* obj) const 
{ 
    return obj->*m_MemPtr == m_MemVal; 
}

bool operator()(const T_Class* obj) const 
{ 
    return obj->*m_MemPtr == m_MemVal; 
}

+

bool operator()(const T_Class& obj) const 
{ 
    return obj.*m_MemPtr == m_MemVal; 
}

> неужели

> bool operator()(const T_Class* obj) const
> {
>     return obj->*m_MemPtr == m_MemVal;
> }
>
> +
>
> bool operator()(const T_Class& obj) const
> {
>     return obj.*m_MemPtr == m_MemVal;
> }
>

find_if(..., cref(x) == bind(&T::member, _1)); // и для ссылок и для указателей
find_if(..., cref(x) == _1 ->* &T::member); // только для указателей
find_if(..., cref(x) == &_1 ->* &T::member); // только для ссылок

template<typename T_Class, typename T_Member>
class FCompareMember : public std::unary_function<T_Class, bool>
{
    typedef T_Member T_Class::* TMemberPtr;
public:
    FCompareMember(TMemberPtr MemPtr, const T_Member& MemVal) 
        : m_MemPtr(MemPtr)
        , m_MemVal(MemVal) 
    {
    }

    template<typename ChainedPtr>
    bool operator()(const ChainedPtr& x)const
    {
      return operator()(*x);
    }

    bool operator()(const T_Class& obj)const 
    { 
        return obj.*m_MemPtr == m_MemVal; 
    }

private:
    TMemberPtr  m_MemPtr;
    T_Member    m_MemVal;
};

    template<typename T_Class, typename T_Member>
    class FCompareMember 
    : public std::unary_function<T_Class, bool>
    {
        typedef T_Member T_Class::* TMemberPtr;
    public:
        FCompareMember(TMemberPtr MemPtr, const T_Member& MemVal) 
            : m_MemPtr(MemPtr)
            , m_MemVal(MemVal) 
        {
        }

        FCompareMember( const FCompareMember &F) 
            : m_MemPtr(F.m_MemPtr)
            , m_MemVal(F.m_MemVal) 
        {
        }

        template<typename ChainedPtr>
            bool operator()(const ChainedPtr& x)const
        {
            return operator()(*x);
        }

        bool operator()(const T_Class& obj) const
        {
            return obj.*m_MemPtr == m_MemVal;
        }

    private:
        TMemberPtr        m_MemPtr;
        const T_Member    &    m_MemVal;
    };

    template<typename T_Class, typename T_Member>
        inline FCompareMember<T_Class,T_Member> 
        compare_mem( T_Member T_Class::* MemPtr, const T_Member& MemVal)
    {
        return FCompareMember<T_Class,T_Member>(MemPtr,MemVal);
    }

//-----------------------------------------------------------------------------
template <typename Class, typename Type>
class member_comparer 
{
    typedef Type Class::*member_ptr_type;
public:
    //-------------------------------------------------------------------------
    member_comparer(member_ptr_type mem_ptr, const Type& mem_val) 
        : m_mem_ptr(mem_ptr),
          m_mem_val(mem_val) 
    {
    }
    //-------------------------------------------------------------------------
    template <typename ChainedPtr>
    bool operator()(const ChainedPtr& x)const
    {
        return operator()(*x);
    }
    //-------------------------------------------------------------------------
    bool operator()(const Class& obj)const
    {
        return obj.*m_mem_ptr == m_mem_val;
    }
    //-------------------------------------------------------------------------
private:
    member_ptr_type m_mem_ptr;
    Type            m_mem_val;
};
//-----------------------------------------------------------------------------
template <typename Class, typename Type>
inline member_comparer<Class, Type> 
make_member_comparer( Type Class::*mem_ptr, const Type& mem_val)
{
    return member_comparer<Class, Type>(mem_ptr, mem_val);
}