Warum wurde unary_function, binary_function, aus C++ 11 entfernt?

Question

Ich habe festgestellt, dass binary_function aus C++ 11 entfernt wird. Ich frage mich warum.

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 ------------------- -------------------------------------------------- -------

Zum Beispiel, wenn wir unseren Adapter für die Funktion sogar in C + schreiben möchten +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 

Wie können wir das in C++ 11 ohne unary_function verbessern?

Answer 1

Es wird nicht entfernt, es ist nur in C++ 11 veraltet. Es ist immer noch Teil des C++ 11-Standards. Sie können es immer noch in Ihrem eigenen Code verwenden. (Edit: Der Ausschuß vor kurzem gewählt aus C++ 17 zu entfernen, though.)

Es ist nicht im Standard mehr verwendet wird, da erfordern Implementierungen von binary_function abzuleiten Überspezifikation ist.

Benutzer sollten nicht egal, ob less von binary_function ableitet, sie müssen nur kümmern, dass es first_argument_type, second_argument_type und result_type definiert. Es sollte von der Implementierung abhängen, wie diese Typedefs bereitgestellt werden.

Das Erzwingen, dass die Implementierung von einem bestimmten Typ abgeleitet wird, bedeutet, dass Benutzer sich möglicherweise auf diese Ableitung verlassen, was sinnlos und nicht sinnvoll ist.

bearbeiten

Wie können wir dies in C++ 11 ohne unary_function verbessern?

Sie brauchen es nicht.

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); 
      } 
} 

In der Tat Sie noch besser machen können, finden Sie not_fn: a generalized negator

Answer 2

Mit variadische Vorlagen können viele allgemeine Funktion Komponieren viel mehr ausgedrückt werden einfach und konsequent, so dass alle von der alten cruft ist nicht mehr notwendig:

Verwenden:

• std::function
• std::bind
• std::mem_fn
• std::result_of
• lambdas

Verwenden Sie nicht:

• std::unary_function, std::binary_function
• std::mem_fun
• std::bind1st, std::bind2nd