{"id":2202,"date":"2025-01-28T20:35:49","date_gmt":"2025-01-28T20:35:49","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=2202"},"modified":"2025-01-28T21:45:27","modified_gmt":"2025-01-28T21:45:27","slug":"function-adapters","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/the-standard-template-library-2\/function-adapters\/","title":{"rendered":"Function Adapters"},"content":{"rendered":"\n

<\/span>Function Adapters<\/span><\/h2>\n\n\n\n

Just as iterator adapters help you construct a wider variety of iterators, a Function Adapter<\/strong><\/em> helps you create a wider variety of function objects.<\/p>\n\n\n\n

STL provides three kinds of function adapters:<\/p>\n\n\n\n

    \n
  • Binders<\/strong><\/em> : Converts function objects that take two arguments into function objects that take one.<\/li>\n\n\n\n
  • Negaters<\/strong><\/em> : Create a new function object class that inverts the result of a function.<\/li>\n\n\n\n
  • Adapters for pointers to functions<\/strong><\/em> : Useful if you already have a function defined, and want to create a function object out of it.<\/li>\n<\/ul>\n\n\n\n
    \n

    WARNING:<\/strong><\/p>\n\n\n\n

    It appears that a number of these function adapters are now deprecated in C++11, and removed in C++17. <\/p>\n\n\n\n

    There are alternative approaches recommended below, and on the web.<\/p>\n<\/blockquote>\n\n\n\n

    <\/span>Binders<\/span><\/h3>\n\n\n\n

    In the C++ STL, binders<\/strong><\/em> are a type of functors that bind or associate some of the arguments of a function to a fixed value.<\/strong> This fixed value is stored inside the functor and the rest of the arguments can be passed dynamically at the time of calling the functor.<\/p>\n\n\n\n

    Here is an example of using a binder<\/strong><\/em>.<\/p>\n\n\n\n

    The find_if()<\/strong> algorithm is like find()<\/strong>, except that it takes a unary predicate function object (a function object encapsulating a one-argument function that returns a bool<\/strong> value.)<\/p>\n\n\n\n

    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  STL Function Adapters<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span><vector><\/span><\/span>\n#include<\/span> <\/span><algorithm><\/span><\/span>\n#include<\/span> <\/span><functional><\/span><\/span>\n<\/span>\n\/\/ Binder example<\/span><\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::vector<<\/span>int<\/span>> values = { <\/span>10<\/span>, -<\/span>200<\/span>, <\/span>30<\/span>, -<\/span>90<\/span>, <\/span>56<\/span>, <\/span>89<\/span> };<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Find all elements greater than 20<\/span><\/span>\n  <\/span>std<\/span>::<\/span>vector<\/span><<\/span>int<\/span>>::iterator it =<\/span><\/span>\n          <\/span>std<\/span>::<\/span>find_if<\/span>(<\/span>values<\/span>.<\/span>begin<\/span>(), <\/span>values<\/span>.<\/span>end<\/span>(),<\/span><\/span>\n                       <\/span>std<\/span>::<\/span>bind2nd<\/span>(<\/span>std<\/span>::<\/span>greater<\/span><<\/span>int<\/span>>(), <\/span>20<\/span>));<\/span><\/span>\n  <\/span>if<\/span> (it != <\/span>values<\/span>.<\/span>end<\/span>())<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"First element greater than 20: "<\/span> << *it << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    … which produces the following output:<\/p>\n\n\n\n
    First element greater than 20: 30\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    We constructed the predicate for the search by starting with greater<int>()<\/strong>, a function object that defines a binary function:<\/p>\n\n\n\n
    bool operator()(int x, int y) const\n{ return x > y; }<\/strong><\/code><\/pre>\n\n\n\n
    By applying bind2nd<\/strong> to this function object, and 50<\/strong>, we produced a function object that defines a unary function:<\/p>\n\n\n\n
    bool operator()(int x) const\n{ return x > 50; }<\/strong><\/code><\/pre>\n\n\n\n
    as if we had programmed another function object type:<\/p>\n\n\n\n
    struct GreaterThan50 : unary_function<int, bool>\n{\n\tbool operator()(int x) const\n\t{ return x > 50; }\n};<\/strong><\/code><\/pre>\n\n\n\n
    The bind2nd<\/strong> binder binds the second argument of the binary operator.  There is also a bind1st<\/strong> binder which may be used to bind the first argument in a similar way<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    \n
    NOTE:<\/strong><\/p>\n\n\n\n
    bind1st<\/strong> and bind2nd<\/strong> are deprecated in C++11 and removed in C++17.<\/p>\n\n\n\n
    The above code was compiled and run using C++11, and produced the following warning:<\/p>\n\n\n\n
    main.cpp:21:29 'bind2nd<std::greater<int>, int>' is deprecated<\/strong>\nbind2nd<std::greater<int>, int>' has been explicitly marked deprecated here<\/strong><\/code><\/pre>\n\n\n\n
    It refused to compile using C++17.<\/p>\n\n\n\n
    Starting from C++11, the C++ Standard Library provides std::bind,<\/strong> which is a more general binder that can bind any number of arguments to any values and returns a new function object. The new function object can then be used as a regular function, taking the remaining unbound arguments.<\/p>\n\n\n\n
    Syntax of std::bind in C++<\/strong><\/p>\n\n\n\n
    std::bind(function, arg1, arg2, ..., argN);<\/strong><\/code><\/pre>\n\n\n\n
    Parameters in std::bind in C++<\/strong><\/p>\n\n\n\n
      \n
    • function <\/strong>is the function or function object that you want to bind some of its arguments.<\/li>\n\n\n\n
    • arg1, arg2, \u2026, argN <\/strong>are the arguments to bind. These arguments can be any type of value or expression, including references, pointers, and placeholder values (e.g., std::placeholders::_1, std::placeholders::_2, etc.)<\/li>\n<\/ul>\n\n\n\n
      The current advice is to “consider using lambdas instead, which are more flexible and readable<\/em>.”<\/strong> (For lambda descriptions, see later)<\/p>\n<\/blockquote>\n\n\n\n
      <\/span>Negaters<\/span><\/h3>\n\n\n\n
      A Negater<\/em> is a kind of function adapter that is used to reverse the sense of a predicate function object.<\/p>\n\n\n\n
      STL provides two negaters:<\/p>\n\n\n\n
        \n
      • not1<\/strong> : Negates a unary predicate<\/li>\n\n\n\n
      • not2<\/strong> : Negates a binary predicate<\/li>\n<\/ul>\n\n\n\n
        The not1<\/strong> negater, given a unary predicate function object p<\/strong>, generates a unary predicate object that defines the function:<\/p>\n\n\n\n
        bool operator()(const T &x) const\n{ return !(p(x)); }<\/strong><\/code><\/pre>\n\n\n\n
        <\/span>The not1<\/code> Negater<\/span><\/h4>\n\n\n\n
        Here is an example of a not1<\/strong> negator:<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  STL Function Adapters<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span><vector><\/span><\/span>\n#include<\/span> <\/span><algorithm><\/span><\/span>\n#include<\/span> <\/span><functional><\/span><\/span>\n<\/span>\n\/\/ not1 Negator example<\/span><\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::vector<<\/span>int<\/span>> values = { <\/span>10<\/span>, -<\/span>200<\/span>, <\/span>30<\/span>, -<\/span>90<\/span>, <\/span>56<\/span>, <\/span>89<\/span> };<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Find all elements greater than 20<\/span><\/span>\n  <\/span>std<\/span>::<\/span>vector<\/span><<\/span>int<\/span>>::iterator it =<\/span><\/span>\n  <\/span>std<\/span>::<\/span>find_if<\/span>(<\/span>values<\/span>.<\/span>begin<\/span>(), <\/span>values<\/span>.<\/span>end<\/span>(),<\/span><\/span>\n               <\/span>not1<\/span>(<\/span><\/span>\n                    <\/span>std<\/span>::<\/span>bind2nd<\/span>(<\/span>std<\/span>::<\/span>greater<\/span><<\/span>int<\/span>>(), <\/span>20<\/span>)<\/span><\/span>\n                    )<\/span><\/span>\n               );<\/span><\/span>\n  <\/span>if<\/span> (it != <\/span>values<\/span>.<\/span>end<\/span>())<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"First element not greater than 20: "<\/span> << *it << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        \n
        … which produces:<\/p>\n\n\n\n
        First element not greater than 20: 10\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n\n\n\n
        \n
        This code was compiled using C++11, with the bind2nd<\/code><\/strong> deprecation warning.<\/p>\n\n\n\n
        It will not compile using C++17<\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
        <\/span>The not2 Negater<\/span><\/h4>\n\n\n\n
        Assume we have a class, CompareIDs<\/strong>, of objects with a binary predicate function object that compares objects based on an id<\/strong> field.<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  CompareIDs.h<\/span><\/span>\n\/\/  STL Function Adapters<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> CompareIDs_h<\/span><\/span>\n#define<\/span> CompareIDs_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span>   <\/span>\/\/ for ostream, etc.<\/span><\/span>\n#include<\/span> <\/span><functional><\/span> <\/span>\/\/ for binary_function<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>CompareIDs<\/span><\/span>\n  : <\/span>public<\/span> <\/span>std<\/span>::<\/span>binary_function<\/span><<\/span>CompareIDs<\/span>, <\/span>CompareIDs<\/span>, <\/span>bool<\/span>><\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>int<\/span> id;<\/span>  \/\/ ID field<\/span><\/span>\n  <\/span>bool<\/span> <\/span>operator()<\/span>(<\/span>const<\/span> <\/span>CompareIDs<\/span> <\/span>&<\/span>x<\/span>, <\/span>const<\/span> <\/span>CompareIDs<\/span> <\/span>&<\/span>y<\/span>) <\/span>const<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>return<\/span> <\/span>x<\/span>.<\/span>id<\/span> >= <\/span>y<\/span>.<\/span>id<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>friend<\/span> <\/span>std<\/span>::<\/span>ostream<\/span> <\/span>&<\/span>operator<<<\/span>(<\/span>std<\/span>::<\/span>ostream<\/span> <\/span>&<\/span>o<\/span>, <\/span>const<\/span> <\/span>CompareIDs<\/span> <\/span>&<\/span>x<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    o << <\/span>x<\/span>.<\/span>id<\/span>;<\/span><\/span>\n    <\/span>return<\/span> o;<\/span><\/span>\n  }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* CompareIDs_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        <\/div>\n<\/div>\n\n\n\n
        Assume we want to sort a vector of CompareIDs<\/strong> objects<\/p>\n\n\n\n
        We can’t use default ordering, since operator <<\/strong> is not defined for CompareIDs<\/strong>.<\/p>\n\n\n\n
        We can’t use the overloaded operator defined in the type, because it uses >=<\/strong> to compare ids, not <<\/strong><\/p>\n\n\n\n
        We can, however, use a not2<\/strong> negator to solve the problem:<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  STL Function Adapters<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span><vector><\/span><\/span>\n#include<\/span> <\/span><algorithm><\/span><\/span>\n#include<\/span> <\/span><functional><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"compareIDs.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>const<\/span> <\/span>size_t<\/span> SIZE = <\/span>15<\/span>;<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>display<\/span>(<\/span>std<\/span>::<\/span>vector<\/span><<\/span>CompareIDs<\/span>> <\/span>v<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < SIZE; i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>v<\/span>[i] << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::vector<CompareIDs> <\/span>v<\/span>(SIZE);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < SIZE; i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>v<\/span>[i].<\/span>id<\/span> = SIZE - (i + <\/span>1<\/span>);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Before sorting:"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>display<\/span>(v);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>sort<\/span>( <\/span>v<\/span>.<\/span>begin<\/span>(), <\/span>v<\/span>.<\/span>end<\/span>(), <\/span>not2<\/span>(<\/span>CompareIDs<\/span>()) );<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"After sorting:"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>display<\/span>(v);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        \n
        … which produces the following output:<\/p>\n\n\n\n
        Before sorting:\n14\n13\n12\n11\n10\n9\n8\n7\n6\n5\n4\n3\n2\n1\n0\n\nAfter sorting:\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
        <\/div>\n\n\n\n
        \n
        NOTE:<\/strong><\/p>\n\n\n\n
        The above program was compiled using C++11, and it received the following warning:<\/p>\n\n\n\n
        CompareIDs.h:15:17 'binary_function<CompareIDs, CompareIDs, bool>' is deprecated<\/strong><\/code><\/pre>\n\n\n\n
        It refused to compile with C++17.<\/p>\n\n\n\n
        So, binary_function<\/strong> is deprecated in C++11, and removed in C++17.<\/p>\n\n\n\n
        Why was it deprecated?<\/strong><\/p>\n\n\n\n