Skip to content

Instantly share code, notes, and snippets.

@kdungs

kdungs/higherorder.cc

Last active August 29, 2015 14:19
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save kdungs/30787bb2f6e65a1bf0ef to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save kdungs/30787bb2f6e65a1bf0ef to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. kdungs revised this gist Apr 17, 2015. 1 changed file with 1 addition and 1 deletion.
    2 changes: 1 addition & 1 deletion higherorder.cc
    View file
    Original file line number Diff line number Diff line change
    @@ -2,7 +2,7 @@
    #include <functional>

    //
    // Function Literals
    // Classical Function Definition
    //
    int add(int x, int y) {
    return x + y;
  2. kdungs created this gist Apr 17, 2015.
    108 changes: 108 additions & 0 deletions higherorder.cc
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,108 @@
    #include <cassert>
    #include <functional>

    //
    // Function Literals
    //
    int add(int x, int y) {
    return x + y;
    }

    int mul(int x, int y) {
    return x * y;
    }

    //
    // Function Objects
    //
    class Adder {
    public:
    int operator()(int x, int y) const {
    return x + y;
    }
    };

    class Multiplier {
    public:
    int operator()(int x, int y) const {
    return x * y;
    }
    };

    //
    // Function Pointers
    //
    int resultOfCalculation_ptr(int (*op)(int, int), int x,
    int y) {
    return (*op)(x, y);
    }

    //
    // std::function
    //
    int resultOfCalculation_fun(const std::function<int(int, int)>& op, int x,
    int y) {
    return op(x, y);
    }

    //
    // Templates
    //
    template <typename FN>
    int resultOfCalculation_tpl(const FN& op, int x, int y) {
    return op(x, y);
    }


    int main() {
    // Instantiate function objects
    Adder add_o;
    Multiplier mul_o;

    // Define lambdas
    auto add_l = [](int x, int y) { return x + y; };
    auto mul_l = [](int x, int y) { return x * y; };

    // Wrap in std::function
    std::function<int(int, int)> add_f(add), add_of(add_o), add_lf(add_l),
    mul_f(mul), mul_of(mul_o), mul_lf(mul_l);

    // Check results
    int x = 1,
    y = 2,
    s = 3,
    p = 2;
    assert(add(x, y) == s);
    assert(add_o(x, y) == s);
    assert(add_l(x, y) == s);
    assert(mul(x, y) == p);
    assert(mul_o(x, y) == p);
    assert(mul_l(x, y) == p);
    assert(add_f(x, y) == s);
    assert(add_of(x, y) == s);
    assert(add_lf(x, y) == s);
    assert(mul_f(x, y) == p);
    assert(mul_of(x, y) == p);
    assert(mul_lf(x, y) == p);

    assert(resultOfCalculation_ptr(add, x, y) == s);
    assert(resultOfCalculation_ptr(mul, x, y) == p);
    //assert(resultOfCalculation_ptr(add_o, x, y) == s);
    //assert(resultOfCalculation_ptr(mul_o, x, y) == p);
    assert(resultOfCalculation_ptr(add_l, x, y) == s);
    assert(resultOfCalculation_ptr(mul_l, x, y) == p);

    assert(resultOfCalculation_fun(add, x, y) == s);
    assert(resultOfCalculation_fun(mul, x, y) == p);
    assert(resultOfCalculation_fun(add_o, x, y) == s);
    assert(resultOfCalculation_fun(mul_o, x, y) == p);
    assert(resultOfCalculation_fun(add_l, x, y) == s);
    assert(resultOfCalculation_fun(mul_l, x, y) == p);

    assert(resultOfCalculation_tpl(add, x, y) == s);
    assert(resultOfCalculation_tpl(mul, x, y) == p);
    assert(resultOfCalculation_tpl(add_o, x, y) == s);
    assert(resultOfCalculation_tpl(mul_o, x, y) == p);
    assert(resultOfCalculation_tpl(add_l, x, y) == s);
    assert(resultOfCalculation_tpl(mul_l, x, y) == p);
    }