C++ 运算符（）缺少参数列表

我有一些奇怪的错误，我想得到一些帮助。代码如下：

Obs.h：

class Obs;

struct Try : public std::pair<Item&, std::pair<int, int> > {
    Item& item() const;
    int dx() const;
    int dy() const;

    Try( Item& i, int _dx, int _dy );
};

struct Pred : public std::binary_function<Obs, Try, bool> {
    bool operator() (Obs& o, Try& m) const;
};

class Obs {

    Rect position;

public:

    Obs (Rect dimensions);
    bool Allows (Item i, int dx, int dy) const;

};

B.h：

class ObsHolder {

    std::list< Obs* > list;

public:

    void AddObstacle (Obs* obs);
    bool CanMove (Item& i, int dx, int dy);

};

我得到的主要错误是：

'Pred:：operator（）'：函数调用缺少参数列表；使用“&Pred:：operator（）”创建指向成员的指针

我还得到：

c:\program files（x86）\microsoft visual studio 11.0\vc\include\utility（85）：错误C2440:“正在初始化”：无法从“int”转换为“Item&”

---

还有一些在“my_path*\microsoft visual studio 11.0\vc\include\utility（83）”下抱怨std:：pair的错误

pair

无法获取引用模板参数。您需要使用

std:：reference\u wrapper

不要使用不推荐使用的活页夹。他们在引用参数方面有问题

不要从

对继承。它没有虚拟析构函数

如果您真的想使用

bind2nd

：它不是将成员函数指针作为参数，而是可调用对象的值

现代C++中的一个完整例子。我还是不会用

std:：list

但是管理内存本身的东西

#include <utility>
#include <functional>
#include <tuple>
#include <list>
#include <algorithm>

class Obs;
class Item {};

typedef std::tuple<std::reference_wrapper<Item>, int, int> Try;

Item& item(Try& t) { return std::get<0>(t); }
const Item& item(const Try& t) { return std::get<0>(t); }
int dx(const Try& t) { return std::get<1>(t); }
int dy(const Try& t) { return std::get<1>(t); }
Try make_try(Item& i, int x, int y) { return std::make_tuple(std::ref(i), x, y); }

// missing
struct Rect {}; 

class Obs {
  Rect position;
public:

  Obs (Rect dimensions) : position(dimensions) {}
  bool Allows (Item i, int dx, int dy) const { return false; /* quite compiler */ }
};

struct Pred {
  bool operator() (Obs& o, const Try& m) const {
    return !o.Allows( item(m), dx(m), dy(m) );
  }
};


class ObsHolder {
  std::list< Obs* > list;
public:

  void AddObstacle (Obs* obs);
  bool CanMove (Item& i, int dx, int dy) {
    Pred p;
    auto x = make_try(i, dx, dy);
    return std::find_if(list.begin(), list.end(), 
                        [=](Obs* o) { return p(*o, x); }) == list.end();
  }
};

int main()
{

  return 0;
}

#包括
#包括
#包括
#包括
#包括
Obs类；
类项{}；
typedef std:：tuple Try；
Item&Item（Try&t）{returnstd:：get（t）；}
常量项和项（常量Try&t）{return std:：get（t）；}
intdx（consttry&t）{returnstd:：get（t）；}
int dy（const Try&t）{return std:：get（t）；}
Try make_Try（Item&i，intx，inty）{return std:：make_tuple（std:：ref（i），x，y）；}
//失踪
struct Rect{}；
类Obs{
直视位；
公众：
Obs（矩形维度）：位置（维度）{}
bool允许（Item i，int dx，int dy）常量{返回false；/*相当编译器*/}
};
结构预测{
布尔运算符（）（Obs&o，const Try&m）const{
return！o.Allows（项目（m）、dx（m）、dy（m））；
}
};
类别持有人{
标准：：列表列表；
公众：
无效障碍物（Obs*Obs）；
布尔可以移动（项目&i、整数dx、整数dy）{
Pred-p；
自动x=尝试（i，dx，dy）；
返回std:：find_if（list.begin（），list.end（），
[=]（Obs*o）{返回p（*o，x）；}）=list.end（）；
}
};
int main（）
{
返回0；
}

它能拼出来<代码>使用“&Pred:：operator（）”创建指向成员的指针@sehe即使已详细说明，也不会起作用

bind2nd

不将指向成员的指针作为参数。从编译器错误中删除文件名和行号等有趣的内容对事情毫无帮助。

bool ObsHolder::CanMove (Item& i, int dx, int dy) {

    return std::find_if( list.begin(), list.end(), std::bind2nd(Pred::operator(), Try(i, dx, dy) )) == list.end();

}

#include <utility>
#include <functional>
#include <tuple>
#include <list>
#include <algorithm>

class Obs;
class Item {};

typedef std::tuple<std::reference_wrapper<Item>, int, int> Try;

Item& item(Try& t) { return std::get<0>(t); }
const Item& item(const Try& t) { return std::get<0>(t); }
int dx(const Try& t) { return std::get<1>(t); }
int dy(const Try& t) { return std::get<1>(t); }
Try make_try(Item& i, int x, int y) { return std::make_tuple(std::ref(i), x, y); }

// missing
struct Rect {}; 

class Obs {
  Rect position;
public:

  Obs (Rect dimensions) : position(dimensions) {}
  bool Allows (Item i, int dx, int dy) const { return false; /* quite compiler */ }
};

struct Pred {
  bool operator() (Obs& o, const Try& m) const {
    return !o.Allows( item(m), dx(m), dy(m) );
  }
};


class ObsHolder {
  std::list< Obs* > list;
public:

  void AddObstacle (Obs* obs);
  bool CanMove (Item& i, int dx, int dy) {
    Pred p;
    auto x = make_try(i, dx, dy);
    return std::find_if(list.begin(), list.end(), 
                        [=](Obs* o) { return p(*o, x); }) == list.end();
  }
};

int main()
{

  return 0;
}