17

I found that binary_function is removed from C++11. I am wondering why.

C++98:

template <class T> struct less : binary_function <T,T,bool> {
  bool operator() (const T& x, const T& y) const {return x<y;}
};

C++11:

template <class T> struct less {
  bool operator() (const T& x, const T& y) const {return x<y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

MODIFIED----------------------------------------------------------------------------

template<class arg,class result>
struct unary_function
{
       typedef arg argument_type;
       typedef result result_type;
};

For example, if we want to write our adapter for function even in C++98,

template <class T> struct even : unary_function <T,bool> {
  bool operator() (const T& x) const {return 0==x%2;}
};

find_if(bgn,end,even<int>()); //find even number

//adapter
template<typename adaptableFunction >
class unary_negate
{
   private:
       adaptableFunction fun_;
   public:
       typedef adaptableFunction::argument_type argument_type;

       typedef adaptableFunction::result_type result_type;  
       unary_negate(const adaptableFunction &f):fun_(f){}

       bool operator()(const argument_type&x) 
       {
           return !fun(x);
       }
}

find_if(bgn,end, unary_negate< even<int> >(even<int>()) ); //find odd number

How can we improve this in C++11 without unary_function?

4

2 回答 2

21

使用可变参数模板，许多通用函数组合可以更简单、更一致地表达，因此不再需要所有旧的 cruft：

使用：

  • std::function
  • std::bind
  • std::mem_fn
  • std::result_of
  • 拉姆达斯

不要使用：

  • std::unary_function,std::binary_function
  • std::mem_fun
  • std::bind1st,std::bind2nd
于 2014-03-13T17:57:02.070 回答
19

它没有被删除，只是在 C++11 中被弃用了。它仍然是 C++11 标准的一部分。您仍然可以在自己的代码中使用它。虽然它在 C++17 中被删除了。

它不再在标准中使用，因为要求实现派生binary_function是过度规范。

用户不必关心是否less派生自binary_function，他们只需要关心它定义first_argument_type的，second_argument_type和result_type。它应该取决于实现它如何提供这些类型定义。

强制实现从特定类型派生意味着用户可能开始依赖该派生，这是没有意义的，也没有用处。

编辑

在没有 unary_function 的情况下，我们如何在 c++11 中改进这一点？

你不需要它。

template<typename adaptableFunction>
class unary_negate
{
   private:
       adaptableFunction fun_;
   public:
       unary_negate(const adaptableFunction& f):fun_(f){}

       template<typename T>
           auto operator()(const T& x)  -> decltype(!fun_(x))
           {
               return !fun_(x);
           }
}

事实上，你可以做得更好，请参阅not_fn：a generalized negator

于 2014-03-13T18:32:42.903 回答