[depr.function.objects] - C++14 → C++17

Files changed (1) hide show

tmp/tmpztm2i3ae/{from.md → to.md} +0 -234

tmp/tmpztm2i3ae/{from.md → to.md} RENAMED Viewed

@@ -1,234 +0,0 @@
-## Function objects <a id="depr.function.objects">[[depr.function.objects]]</a>
-### Base <a id="depr.base">[[depr.base]]</a>
-The class templates `unary_function` and `binary_function` are
-deprecated. A program shall not declare specializations of these
-templates.
-``` cpp
-namespace std {
-  template <class Arg, class Result>
-  struct unary_function {
-    typedef Arg    argument_type;
-    typedef Result result_type;
-  };
-}
-```
-``` cpp
-namespace std {
-  template <class Arg1, class Arg2, class Result>
-  struct binary_function {
-    typedef Arg1   first_argument_type;
-    typedef Arg2   second_argument_type;
-    typedef Result result_type;
-  };
-}
-```
-### Function adaptors <a id="depr.adaptors">[[depr.adaptors]]</a>
-The adaptors ptr_fun, mem_fun, mem_fun_ref, and their corresponding
-return types are deprecated. The function template `bind`  [[func.bind]]
-provides a better solution.
-#### Adaptors for pointers to functions <a id="depr.function.pointer.adaptors">[[depr.function.pointer.adaptors]]</a>
-To allow pointers to (unary and binary) functions to work with function
-adaptors the library provides:
-``` cpp
-template <class Arg, class Result>
-class pointer_to_unary_function : public unary_function<Arg, Result> {
-public:
-  explicit pointer_to_unary_function(Result (*f)(Arg));
-  Result operator()(Arg x) const;
-};
-```
-`operator()` returns `f(x)`.
-``` cpp
-template <class Arg, class Result>
-  pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg));
-```
-*Returns:* `pointer_to_unary_function<Arg, Result>(f)`.
-``` cpp
-template <class Arg1, class Arg2, class Result>
-class pointer_to_binary_function :
-  public binary_function<Arg1,Arg2,Result> {
-public:
-  explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
-  Result operator()(Arg1 x, Arg2 y) const;
-};
-```
-`operator()` returns `f(x,y)`.
-``` cpp
-template <class Arg1, class Arg2, class Result>
-  pointer_to_binary_function<Arg1,Arg2,Result>
-    ptr_fun(Result (*f)(Arg1, Arg2));
-```
-*Returns:* `pointer_to_binary_function<Arg1,Arg2,Result>(f)`.
-``` cpp
-int compare(const char*, const char*);
-replace_if(v.begin(), v.end(),
-  not1(bind2nd(ptr_fun(compare), "abc")), "def");
-```
-replaces each `abc` with `def` in sequence `v`.
-#### Adaptors for pointers to members <a id="depr.member.pointer.adaptors">[[depr.member.pointer.adaptors]]</a>
-The purpose of the following is to provide the same facilities for
-pointer to members as those provided for pointers to functions in
-[[depr.function.pointer.adaptors]].
-``` cpp
-template <class S, class T> class mem_fun_t
-        : public unary_function<T*, S> {
-public:
-  explicit mem_fun_t(S (T::*p)());
-  S operator()(T* p) const;
-};
-```
-`mem_fun_t` calls the member function it is initialized with given a
-pointer argument.
-``` cpp
-template <class S, class T, class A> class mem_fun1_t
-      : public binary_function<T*, A, S> {
-public:
-  explicit mem_fun1_t(S (T::*p)(A));
-  S operator()(T* p, A x) const;
-};
-```
-`mem_fun1_t` calls the member function it is initialized with given a
-pointer argument and an additional argument of the appropriate type.
-``` cpp
-template<class S, class T> mem_fun_t<S,T>
-   mem_fun(S (T::*f)());
-template<class S, class T, class A> mem_fun1_t<S,T,A>
-   mem_fun(S (T::*f)(A));
-```
-`mem_fun(&X::f)` returns an object through which `X::f` can be called
-given a pointer to an `X` followed by the argument required for `f` (if
-any).
-``` cpp
-template <class S, class T> class mem_fun_ref_t
-      : public unary_function<T, S> {
-public:
-  explicit mem_fun_ref_t(S (T::*p)());
-  S operator()(T& p) const;
-};
-```
-`mem_fun_ref_t` calls the member function it is initialized with given a
-reference argument.
-``` cpp
-template <class S, class T, class A> class mem_fun1_ref_t
-      : public binary_function<T, A, S> {
-public:
-  explicit mem_fun1_ref_t(S (T::*p)(A));
-  S operator()(T& p, A x) const;
-};
-```
-`mem_fun1_ref_t` calls the member function it is initialized with given
-a reference argument and an additional argument of the appropriate type.
-``` cpp
-template<class S, class T> mem_fun_ref_t<S,T>
-   mem_fun_ref(S (T::*f)());
-template<class S, class T, class A> mem_fun1_ref_t<S,T,A>
-   mem_fun_ref(S (T::*f)(A));
-```
-`mem_fun_ref(&X::f)` returns an object through which `X::f` can be
-called given a reference to an `X` followed by the argument required for
-`f` (if any).
-``` cpp
-template <class S, class T> class const_mem_fun_t
-      : public unary_function<const T*, S> {
-public:
-  explicit const_mem_fun_t(S (T::*p)() const);
-  S operator()(const T* p) const;
-};
-```
-`const_mem_fun_t` calls the member function it is initialized with given
-a pointer argument.
-``` cpp
-template <class S, class T, class A> class const_mem_fun1_t
-      : public binary_function<const T*, A, S> {
-public:
-  explicit const_mem_fun1_t(S (T::*p)(A) const);
-  S operator()(const T* p, A x) const;
-};
-```
-`const_mem_fun1_t` calls the member function it is initialized with
-given a pointer argument and an additional argument of the appropriate
-type.
-``` cpp
-template<class S, class T> const_mem_fun_t<S,T>
-   mem_fun(S (T::*f)() const);
-template<class S, class T, class A> const_mem_fun1_t<S,T,A>
-   mem_fun(S (T::*f)(A) const);
-```
-`mem_fun(&X::f)` returns an object through which `X::f` can be called
-given a pointer to an `X` followed by the argument required for `f` (if
-any).
-``` cpp
-template <class S, class T> class const_mem_fun_ref_t
-      : public unary_function<T, S> {
-public:
-  explicit const_mem_fun_ref_t(S (T::*p)() const);
-  S operator()(const T& p) const;
-};
-```
-`const_mem_fun_ref_t` calls the member function it is initialized with
-given a reference argument.
-``` cpp
-template <class S, class T, class A> class const_mem_fun1_ref_t
-      : public binary_function<T, A, S> {
-public:
-  explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
-  S operator()(const T& p, A x) const;
-};
-```
-`const_mem_fun1_ref_t` calls the member function it is initialized with
-given a reference argument and an additional argument of the appropriate
-type.
-``` cpp
-template<class S, class T> const_mem_fun_ref_t<S,T>
-   mem_fun_ref(S (T::*f)() const);
-template<class S, class T, class A> const_mem_fun1_ref_t<S,T,A>
-    mem_fun_ref(S (T::*f)(A) const);
-```
-`mem_fun_ref(&X::f)` returns an object through which `X::f` can be
-called given a reference to an `X` followed by the argument required for
-`f` (if any).

Diff to HTML by rtfpessoa