Warum haben unary_function, binary_function entfernt von C++11?

Fand ich, dass binary_function entfernt von C++11. 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;
};

GEÄNDERT----------------------------------------------------------------------------

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

Zum Beispiel, wenn wir schreiben wollen, unsere adapter für die Funktion selbst 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

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

InformationsquelleAutor camino | 2014-03-13
  1. 17

    Es nicht entfernt, es ist einfach veraltet in C++11. Es ist immer noch ein Teil der C++11 standard. Können Sie immer noch verwenden es in Ihren eigenen code. Es wurde entfernt in C++17 obwohl.

    Es ist nicht in der standard - mehr, denn die erfordern Implementierungen zur Ableitung von binary_function ist vorbei-Spezifikation.

    Benutzer nicht darum kümmern sollten, ob less stammt aus binary_function, Sie müssen sich nur darum kümmern, dass es definiert first_argument_type, second_argument_type und result_type. Es sollte bis zur Umsetzung, wie es bietet den typedefs.

    Zwingen die Umsetzung Ableitung von einer bestimmten Art bedeutet, dass die Benutzer möglicherweise starten im Vertrauen darauf, dass die Ableitung, das macht keinen Sinn und ist nicht sinnvoll.

    Bearbeiten

    Wie können wir diese verbessern in c++11 ohne unary_function?

    Brauchst du 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, die Sie noch besser machen können, sehen not_fn: eine generalisierte negator

    InformationsquelleAutor Jonathan Wakely
  2. 18

    Mit variadic templates, eine Menge Allgemeine Funktion Komponieren ausgedrückt werden kann, viel mehr einfach und konsistent, so dass alle alten Reste ist nicht mehr notwendig:

    Verwenden:

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

    Nicht verwenden:

    • std::unary_function, std::binary_function
    • std::mem_fun
    • std::bind1st, std::bind2nd
    • binary_function <T,T,bool> vereinfachen unsere Arbeit und machen code mehr konsistent, richtig?
    • Kann er, obwohl?
    • ohne es müssen wir definieren typedef T first_argument_type;.... werden wir vielleicht etwas vergessen hat
    • Tun wir aber? Warum nicht mit den vorhandenen std::function::first_argument_type?
    • also weniger<T> in c++11 definiert first_argument_type,second_argument_type,result_type ist nur um die Kompatibilität mit c++98, richtig?
    • Warten Sie, less<T> nicht definieren, aber std::function definiert, die für ein - und zwei-argument Spezialisierungen. Aber Sie in der Regel nicht brauchen diese Typen, wenn Sie willkürlich verbindliche Einrichtungen zur Verfügung wie dem auch sei...
    • tut Sie definieren (um die Kompatibilität mit C++98), less<void> nicht
    • Ah, OK, danke - macht Sinn.
    • FYIW std::function::first_argument_type scheint auch veraltet in C++17 en.cppreference.com/w/cpp/utility/functional/function
    • Was ist "FYIW"?!

    InformationsquelleAutor Kerrek SB
Schreibe einen Kommentar