C++ std:：bind占位符的重载运算符

boost:：bind

为其占位符重载多个运算符：

为方便起见，

bind

生成的函数对象重载逻辑not运算符

以及关系运算符和逻辑运算符

==

，

=，
=
，
和&
，
|

例如，这允许我将
\u 1==所需的\u值
作为谓词传递给STL算法

不幸的是，
std:：bind
似乎没有重载这些运算符：(

为什么呢

用
std:：bind
模拟
\u 1==所需的\u值
的好方法是什么

我认为这是因为C++11有lambda，因此我不明白为什么你需要这样的操作符来代替它。
IIRC，Boost.Bind只重载占位符的那些操作符，因为原来的Boost lambda库Boost.Bind是did的改进（Boost.Bind因Boost.Phoenix而过时，顺便说一句）.
std:：bind
的占位符仅用于此目的，用作
std:：bind
参数的占位符

作为解决方法，请使用多态函子：

struct compare_equal{
  template<class LHS, class RHS>
  bool operator()(LHS&& lhs, RHS&& rhs){ // assume bool return
    return std::forward<LHS>(lhs) == std::forward<RHS>(rhs);
  }
};

// ...
auto bound = std::bind(compare_equal(), _1, desired_value);

struct compare_equal{
模板
布尔运算符（）（LHS&&LHS，RHS&&RHS）{//假定布尔返回
返回std：：forward（lhs）=std：：forward（rhs）；
}
};
// ...
自动绑定=std:：bind（比较_equal（），_1，所需的_值）；

您可以自己为占位符重载这些运算符，例如
运算符
std:：bind似乎没有重载这些运算符？
为什么呢

因为C++11添加了lambda，它为生成匿名函子对象提供了相同（如果不是更好的话）的便利

用std:：bind模拟_1==所需的_值的好方法是什么

std:：bind不用于模拟行为。请使用C++11 lambdas实现问题的答案：

std::vector<int>::iterator it = std::find_if (myvector.begin(), myvector.end(), [](int i) -> bool { return i == desired_value; });

std:：vector:：iterator it=std:：find_if（myvector.begin（），myvector.end（），[]（int i）->bool{return i==所需的_值；}）；

请注意，如果您使用的是可以派生返回类型的较新编译器，则不需要“->bool”语法

如果您不想或不能使用C++11 lambdas，则可以创建如下非匿名函子：

bool IsDesiredValue (int i) {
    return (i == desired_value);
}
std::vector<int>::iterator i = std::find_if (myvector.begin(), myvector.end(), IsDesiredValue);

bool IsDesiredValue（inti）{
返回值（i==所需的_值）；
}
std:：vector:：iterator i=std:：find_if（myvector.begin（）、myvector.end（）、IsDesiredValue）；

另一个例子是，使用C++11 lambdas创建一个匿名函子，以按类型值对向量进行排序：

std::sort(myVector.begin(), myVector.end(), [](const Foo& i, const Foo& j) -> bool { return i.myValue < j.myValue; });

std:：sort（myVector.begin（），myVector.end（），[]（const Foo&i，const Foo&j）->bool{return i.myValue

另一种非lambda版本为：

struct myclass {
  bool operator() (const Foo& i, const Foo& j) { return (i.myValue < j.myValue); }
} myobject;
std::sort(myVector.begin(), myVector.end(), myobject);

struct myclass{
bool操作符（）（const Foo&i，const Foo&j）{return（i.myValue

下面是如何使用boost的运算符重载执行相同的排序：

std::sort(myVector.begin(), myVector.end(), boost::bind(&MyClass::myValue, _1) < boost::bind(&MyClass::myValue, _2))

std:：sort（myVector.begin（）、myVector.end（）、boost:：bind（&MyClass:：myValue，_1）
我认为这是因为C++11有lambda，因此我不明白为什么需要这样的操作符@Nawaz
std：：bind
是TR1的一部分，它比C++11早6年。Fred，但现在它是
std:
的一部分，而不是
TR1:：
您可以始终创建自己的占位符，而非多态lambda的重载运算符使其仍然有用。
\u 1
推断参数类型，而您需要显式spe为lambda指定它。@Xeo:我还是不明白。你所说的是
\u 1
和C++11 lambda的工作方式不同。但问题是，它们不是实现了同样的目标？如果你能做到
[]（自动参数）{…}，它们会的
，但你不能。是的，你可以自己编写类型，但如果你想在泛型代码中使用它，那就失败了。你不能有泛型lambda，但是
boost:：bind
的占位符在设计上是泛型的。@Nawaz:你刚才在你的评论中说明了我试图告诉你的确切问题。我的注释中没有使用任何特定类型代码，使其完全通用。lambda需要您准确地说出将使用的类型。@Xeo c++1y lambda不是这样做的吗？就我个人而言，我喜欢Boost Phoenix比c++11 lambda好得多。它们通常更短，更容易阅读，垃圾语法更少。
struct myclass {
  bool operator() (const Foo& i, const Foo& j) { return (i.myValue < j.myValue); }
} myobject;
std::sort(myVector.begin(), myVector.end(), myobject);

std::sort(myVector.begin(), myVector.end(), boost::bind(&MyClass::myValue, _1) < boost::bind(&MyClass::myValue, _2))