创建需要指向方法函数的指针的模板谓词类，并随之而来的编译器错误

Question

我正在构建一系列重复大量代码的谓词，因此被更改为基于 std::unary_function 的单个模板函数类。我的想法是，我的类接口需要定义 Element_t Element() 和 std::string Name() 等方法，因此谓词模板参数是对象类型以及将进行如下比较的值类型：

// generic predicate for comparing an attribute of object pointers to a specified test value
template <class U, typename R>
class mem_fun_eq : public std::unary_function <U*, bool> {
  private:
    typedef R (U::*fn_t)();
    fn_t fn; 
    R val;
  public:
    explicit mem_fun_eq (fn_t f, R& r) : fn(f), val(r) { } 
    bool operator() (U * u) const {
      return (u->*fn)() == val;
    }   
}; 

因此，如果我有：

class Atom {
  public:
    const Element_t& Element() const { return _element; }
    const std::string& Name() const { return _name; }
};

我想对 Atom 容器执行搜索并检查 Name 或 Element 相等：

typedef std::string (Atom::*fn)() const;

Atom_it it = std::find_if( _atoms.begin(), _atoms.end(), mem_fun_eq <Atom, std::string> ((fn)&Atom::Name, atomname));

但是编译它会在 std::find_if 行上返回以下错误：

error: address of overloaded function with no contextual type information

此外，尝试为以下内容形成相同的谓词：对 Element() 的检查如下：

typedef Atom::Element_t& (Atom::*fn)() const;

Atom_it it = std::find_if(_atoms.begin(), _atoms.end(), mem_fun_eq <Atom, Atom::Element_t> ((fn)&Atom::Element, elmt);

创建一个不同的错误！

error: no matching function for call to ‘mem_fun_eq<Atom, Atom::Element_t>::mem_fun_eq(Atom::Element_t& (Atom::*)()const, const Atom::Element_t&)’
note: candidates are: mem_fun_eq<U, R>::mem_fun_eq(R (U::*)(), R&) [with U = Atom, R = Atom::Element_t]
note:                 mem_fun_eq<Atom, Atom::Element_t>::mem_fun_eq(const mem_fun_eq<Atom, Atom::Element_t>&)

首先，我是否用这个谓词重新发明了轮子？ STL 中是否有我错过的东西可以在单个类中完成相同的工作？我总是可以将谓词分解为几个更具体的谓词，但我试图避免这种情况。

其次，你能帮我解决编译器错误吗？

Answer 1

我不知道有什么简单的方法可以使用 STL 提供的位来完成此操作。可能有一些聪明的 boost 方法，使用迭代器适配器或 boost::lambda，但我个人不会这样做。

显然，C++0x lambda 将使这一切变得简单。

您的问题是尝试将这样的函数转换

const std::string&(Atom::*)()

为这样的函数：

std::string (Atom::*)()

如果您将 typedef R (U::*fn_t)(); 替换为 typedef const R& (U::*fn_t)() const; 那么它应该可以工作。

下面的代码避免了这个问题，并且还提供了类型推断，这样您就可以编写 mem_fun_eq(&Atom::Name,atomname) 。它为我编译，尽管我还没有测试过。

template<typename U, typename R, typename S>
class mem_fun_eq_t : public std::unary_function<U const*, bool>
{
private:
    R (U::*fn_)() const;
    S val_;
public:
    mem_fun_eq_t(R (U::*fn )() const, S val) : fn_(fn), val_(val){}
    bool operator()(U * u)
    {
        return (u->*fn_)() == val_;
    }
};

template<typename U, typename R, typename S>
mem_fun_eq_t<U, R, S> mem_fun_eq(R (U::*fn)() const, S val)
{
    return mem_fun_eq_t<U, R, S>(fn, val);
}

Answer 2

您是否想过尝试混合使用 mem_fun_ref 或 mem_fun 对象来代替成员函数调用？

基本上，您调用 mem_fun 来创建一个对象，该对象接受两个参数 T* 和函数 A 的模板参数（如果它有一个（或无效，如果没有）。因此，您可以像这样组合它：

template<typename MemFunc, typename CompareType, typename T>
struct MyPredicate{
    MyPredicate(MemFunc _functionObj, CompareType _value) 
    : m_Value(_value),
    m_Function(_functionObj){}

    bool operator()(const T &_input){
         return m_Value == m_Function(_input);
    }

 private:
    MemFunc m_Function;
    CompareType m_Value;
 };

编辑：

好吧，这并不完全有效，所以为什么不这样做：

struct NamePred: binary_function<Atom*,string,bool>{
    bool operator()(Atom *_obj, string _val){
        return _obj->Name() == _val;
    };
};

然后使用 bind2nd

find_if( atoms.begin(), atoms.end(), bind2nd( NamePred, "yo" ) );