我们需要unary_function和binary_function做什么？

Question

我阅读了有关二元和一元函数的教程。我理解它们的结构，但我无法想象在什么情况下我需要这些功能。你能举一个使用它们的例子吗？

http://www.cplusplus.com/reference/std/function/unary_function/

http://www.cplusplus.com/reference/std/function/binary_function/

Answer 1

这些不是函数，而是类（实际上是结构，但并不重要）。当您定义自己的二进制函数以与 STL 算法一起使用时，您可以从这些类派生它们，以便自动获取所有 typedef。

例如，

struct SomeFancyUnaryFunction: public std::unary_function<Arg_t, Result_t>
{
   Result_t operator ()(Arg_t const &)
   {
      ...
   }
};

现在您不需要手动提供 argument_type、result_type 等的 typedef。这些结构，就像 iterator 结构一样，就在那里为了我们的方便，为了重用算法所需的 typedef。

C++11 更新：

从 C++11 开始，新的 std::bind 并不真正需要任何 typedef，因此在某种程度上，它们已经过时了。

Answer 2

基本上，它们提供了允许使用函数适配器从一元和二元函数对象组合高阶函数所需的所有 typedef。例如，这允许在需要一元的情况下使用二进制仿函数，将参数之一绑定到文字值：

std::find_if( begin, end, std::bind1st(greater<int>(),42) );

std::bind1st 依赖于传递给它的仿函数来提供这些类型。

AFAIK 新的 std::bind 不需要它们，因此在新代码中您似乎可以使用 std::bind 并取消它们。

Answer 3

在函数对象的sgi STL文档上有一个解释。总之，unary_function 和 binary_function 用于使函子具有适应性。这允许它们与函数对象适配器一起使用，例如 unary_negate。

Answer 4

这些是什么？

std::unary_function 和 std::binary_function 是用于创建自适应函数对象的基本结构。 “可适应”一词意味着它们提供了必要的类型定义，以便与标准函数适配器（如 std::not1、std::not2、 std::bind1st、std::bind2nd。

我什么时候需要使用它们？

每次需要将自定义函数对象与标准函数适配器一起使用时，您都可以使用它们。

你有例子吗？

让我们考虑一些例子（我知道，它们是人为的。从另一方面我希望它们具有相当的描述性）。

示例 1.

假设您要打印 向量 中长度不小于特定阈值的所有字符串，并将它们打印到 std::cout。

人们可能会使用下一个函数对象：

class LengthThreshold
{
    public:
        LengthThreshold(std::size_t threshold) : threshold(threshold) {}

        bool operator()(const std::string& instance) const
        {
            return (instance.size() < threshold);
        }

    private:
        const std::size_t threshold;
};

现在任务非常简单，可以通过 std::remove_copy_if 算法执行：

// std::size_t threshold is defined somewhere

std::remove_copy_if(some_strings.begin(), some_strings.end(),
        std::ostream_iterator<std::string>(std::cout, "\n"),
        LengthThreshold(threshold)
);

如果您想使用相同的函数对象来打印所有字符串怎么办其长度严格小于阈值？

我们可以想出的明显解决方案是使用 std::not1 函数适配器：

// std::size_t threshold is defined somewhere

std::remove_copy_if(some_strings.begin(), some_strings.end(),
        std::ostream_iterator<std::string>(std::cout, "\n"),
        std::not1(LengthThreshold(threshold))
);

事实上，上面的代码将无法编译，因为我们的 LengthThreshold 不具有适应性，并且没有 std::not1 所必需的 typedef。

为了使其具有适应性，我们需要继承 std::unary_function：

class LengthThreshold : public std::unary_function<std::string, bool> 
{
    // Function object's body remains the same
}

现在我们的第一个示例就像一个魅力。

示例 2。

让我们更改一下之前的示例。假设我们不想在函数对象内存储阈值。在这种情况下，我们可以将函数对象从一元谓词更改为二元谓词：

class LengthThreshold : public std::binary_function<std::string, std::size_t, bool>
{
    public:
        bool operator()(const std::string& lhs, std::size_t threshold) const
        {
            return lhs.size() < threshold;
        }
};

并利用 std::bind2nd 函数适配器：

// std::size_t threshold is defined somewhere

std::remove_copy_if(some_strings.begin(), some_strings.end(),
        std::ostream_iterator<std::string>(std::cout, "\n"),
        std::bind2nd(LengthThreshold(), threshold)
);

C++11 及更高版本怎么样？

上面的所有示例都特​​意仅使用C++ 03。

原因是 std::unary_function 和 std::binary_function 自 C++ 11 起已弃用，并从 C++ 17 中完全删除嗯>。

它是随着更通用和灵活的函数的出现而发生的，例如 std::bind 使得从 std::unary_function 和 std::binary_function 继承变得多余。