Question

如果您将stl容器与POD类型的reference_wrappers一起使用，则以下代码可以正常工作：

int i = 0;
std::vector< boost::reference_wrapper<int> > is;
is.push_back(boost::ref(i));
std::cout << (std::find(is.begin(),is.end(),i)!=is.end()) << std::endl;

但是，如果您使用非POD类型（例如设计示例）：

struct Integer
{
 int value;

 bool operator==(const Integer& rhs) const
 {
  return value==rhs.value;
 }

 bool operator!=(const Integer& rhs) const
 {
  return !(*this == rhs);
 }
};

仅仅声明上面的比较运算符是不够的，因为你必须声明：

bool operator==(const boost::reference_wrapper<Integer>& lhs, const Integer& rhs)
{
 return boost::unwrap_ref(lhs)==rhs;
}

还可能：

bool operator==(const Integer& lhs, const boost::reference_wrapper<Integer>& rhs)
{
 return lhs==boost::unwrap_ref(rhs);
}

为了使等效代码起作用：

Integer j = { 0 };
std::vector< boost::reference_wrapper<Integer> > js;
js.push_back(boost::ref(j));
std::cout << (std::find(js.begin(),js.end(),j)!=js.end()) << std::endl;

现在，我想知道这是否真的是它的意图，因为它有点不切实际。似乎应该有一个更简单的解决方案，例如模板：

template<class T>
bool operator==(const boost::reference_wrapper<T>& lhs, const T& rhs)
{
 return boost::unwrap_ref(lhs)==rhs;
}

template<class T>
bool operator==(const T& lhs, const boost::reference_wrapper<T>& rhs)
{
 return lhs==boost::unwrap_ref(rhs);
}

这可能是一个很好的理由，为什么reference_wrapper的行为方式（可能在没有比较运算符的情况下容纳非POD类型？）。也许已经有一个优雅的解决方案，我只是没有找到它。

Answer 1

当您声明原始比较例程时，上述示例是否有效：

friend bool operator==(const Integer& lhs, const Integer& rhs)
{
    return lhs.value == rhs.value;
}

friend bool operator!=(const Integer& lhs, const Integer& rhs)
{
    return !(lhs == rhs);
}

请注意，在类中声明朋友比较例程与声明成员函数比较例程不同，这就是原始代码可能不起作用的原因。

reference_wrappers的容器（需要比较运算符？）

1 个答案: