Lambda

Callable Objects

#include <iostream>

class Fib {
public:
    long operator() (const long n) {
        return (n <= 2) ? 1 : operator()(n-1) + operator()(n-2);
    }
};

int main() {
    Fib fib;
    std::cout << fib(10) << "\n";
    return 0;
}

Lambda version

#include <iostream>
#include <functional>

int main() {
    std::function<long(long)> fib = [&](long n) {
        return (n <= 2) ? 1 : fib(n-1) + fib(n-2);
    };
    std::cout << fib(10) << "\n";
    return 0;
}

Default Arguments

#include <iostream>

int main(int argc, char *argv[]) {
    auto fib = [](long n=0) {
        long a = 0, b = 1;
        for (long i = 0; i < n; ++i) {
            long tmp = b;
            b = a + b;
            a = tmp;
        }
        return a;
    };
    std::cout << fib() << "\n";
    std::cout << fib(10) << "\n";
    return 0;
}

Captureless

#include <iostream>

int main() {
    long (*fib)(long) = [](long n) {
        long a = 0, b = 1;
        for (long i = 0; i < n; ++i) {
            long tmp = b;
            b = a + b;
            a = tmp;
        }
        return a;
    };
    std::cout << fib(10) << "\n";
    return 0;
}

Lambda capture initializers

// g++ -std=c++17 -Wall -Werror -O3 a.cc

#include <iostream>
#include <utility>
#include <memory>

int main(int argc, char *argv[])
{
  std::unique_ptr<int> p = std::make_unique<int>(5566);
  auto f = [x = std::move(p)]() { std::cout << *x << std::endl; };
  f();
}

Capture by std::move

#include <iostream>
#include <utility>

struct Foo {
    Foo() { std::cout << "Constructor" << "\n"; }
    ~Foo() { std::cout << "Destructor" << "\n"; }
    Foo(const Foo&) { std::cout << "Copy Constructor" << "\n"; }
    Foo(Foo &&) { std::cout << "Move Constructor" << "\n";}

    Foo& operator=(const Foo&) {
        std::cout << "Copy Assignment" << "\n";
        return *this;
    }
    Foo& operator=(Foo &&){
        std::cout << "Move Assignment" << "\n";
        return *this;
    }
};

int main(int argc, char *argv[]) {
    Foo foo;
    [f=std::move(foo)] { /* do some tasks here...*/ }();
}

Copy a Global into a Capture

#include <iostream>

int g = 1;

// copy a global to a capture
auto bar = [g=g]() { return g + 1; };

int main(int argc, char *argv[]) {
    int g = 10;
    std::cout << bar() << "\n";
}

constexpr by Default

#include <iostream>

int main() {
    auto fib = [](long n) {
        long a = 0, b = 1;
        for (long i = 0; i < n; ++i) {
            long tmp = b;
            b = a + b;
            a = tmp;
        }
        return a;
    };

    // constexpr by default is new in c++17
    static_assert(fib(10) == 55);
    return 0;
}

output:

$ g++ -std=c++17 -g -O3 a.cpp

Generic Lambda

#include <iostream>
#include <utility>

// g++ -std=c++17 -g -O3 a.cpp

class Sum {
public:
    template <typename ...Args>
    constexpr auto operator()(Args&& ...args) {
        // Fold expression (since c++17)
        return (std::forward<Args>(args) + ...);
    }
};

int main() {
    Sum sum;
    constexpr int ret = sum(1,2,3,4,5);
    std::cout << ret << std::endl;
    return 0;
}

The snippet is equal to the following example

#include <iostream>
#include <utility>

int main() {
    auto sum = [](auto&& ...args) {
        return (std::forward<decltype(args)>(args) + ...);
    };
    constexpr int ret = sum(1,2,3,4,5);
    std::cout << ret << std::endl;
    return 0;
}

In c+20, lambda supports explicit template paramter list allowing a programmer to utilize parameters’ type instead of using decltype.

#include <iostream>

// g++ -std=c++2a -g -O3 a.cpp

int main(int argc, char *argv[])
{
    auto sum = []<typename ...Args>(Args&&... args) {
        return (std::forward<Args>(args) + ...);
    };
    constexpr int ret = sum(1,2,3,4,5);
    std::cout << ret << std::endl;
    return 0;
}

Comparison Function

#include <iostream>
#include <string>
#include <map>

struct Cmp {
    template<typename T>
    bool operator() (const T &lhs, const T &rhs) const {
        return lhs < rhs;
    }
};

int main(int argc, char *argv[]) {

    // sort by keys
    std::map<int, std::string, Cmp> m;

    m[3] = "Foo";
    m[2] = "Bar";
    m[1] = "Baz";

    for (auto it : m) {
        std::cout << it.first << ", " << it.second << "\n";
    }
    return 0;
}
#include <iostream>
#include <string>
#include <map>

bool cmp(const int &lhs, const int &rhs) {
    return lhs < rhs;
}

int main(int argc, char *argv[]) {

    // sort by keys
    std::map<int, std::string, decltype(&cmp)> m(cmp);

    m[3] = "Foo";
    m[2] = "Bar";
    m[1] = "Baz";

    for (auto it : m) {
        std::cout << it.first << ", " << it.second << "\n";
    }
    return 0;
}
#include <iostream>
#include <functional>
#include <string>
#include <map>

template<typename T>
using Cmp = std::function<bool(const T &, const T &)>;

template<typename T>
bool cmp(const T &lhs, const T &rhs) {
    return lhs < rhs;
}

int main(int argc, char *argv[]) {

    // sort by keys
    std::map<int, std::string, Cmp<int>> m(cmp<int>);

    m[3] = "Foo";
    m[2] = "Bar";
    m[1] = "Baz";

    for (auto it : m) {
        std::cout << it.first << ", " << it.second << "\n";
    }
    return 0;
}
#include <iostream>
#include <string>
#include <map>

int main(int argc, char *argv[]) {

    auto cmp = [](auto &lhs, auto &rhs) {
        return lhs < rhs;
    };

    // sort by keys
    std::map<int, std::string, decltype(cmp)> m(cmp);

    m[3] = "Foo";
    m[2] = "Bar";
    m[1] = "Baz";

    for (auto it : m) {
        std::cout << it.first << ", " << it.second << "\n";
    }
    return 0;
}

Break Loops

#include <iostream>

int main(int argc, char *argv[]) {
    bool is_stoped = false;
    for (int i = 0; i < 5; ++i) {
        for (int j = 0; j < 5; ++j) {
            std::cout << i + j << " ";
            if (i + j == 5) {
                is_stoped = true;
                break;
            }
        }
        if (is_stoped) {
            break;
        }
    }
    std::cout << std::endl;
    return 0;
}

The previous example shows a common way to break multiple loops via a flag. However, the drawback is a programmer requires to maintain flags if code includes nested loops. By using a lambda function, it is convenient for developers to break nested loops through the return.

#include <iostream>

int main(int argc, char *argv[]) {
    [&] {
        for (int i = 0; i < 5; ++i) {
            for (int j = 0; j < 5; ++j) {
                std::cout << i + j << " ";
                if (i + j == 5) {
                    return;
                }
            }
        }
    }();
    std::cout << std::endl;
    return 0;
}

Callback

#include <iostream>

template<typename F>
long fib(long n, F f) {
    long a = 0, b = 1;
    for (long i = 0; i < n; ++i) {
        long tmp = b;
        b = a + b;
        a = tmp;
        f(a);
    }
    return a;
}

int main(int argc, char *argv[]) {
    fib(10, [](long res) {
        std::cout << res << " ";
    });
    std::cout << "\n";
    return 0;
}
#include <iostream>
#include <functional>

using fibcb = std::function<void(long x)>;

long fib(long n, fibcb f) {
    long a = 0, b = 1;
    for (long i = 0; i < n; ++i) {
        long tmp = b;
        b = a + b;
        a = tmp;
        f(a);
    }
    return a;
}

int main(int argc, char *argv[]) {
    fib(10, [](long res) {
        std::cout << res << " ";
    });
    std::cout << "\n";
    return 0;
}

Programmers can also use function pointers to define a functino’s callback parameter. However, function pointers are only suitable for captureless lambda functions.

#include <iostream>
#include <functional>

using fibcb = void(*)(long n);

long fib(long n, fibcb f) {
    long a = 0, b = 1;
    for (long i = 0; i < n; ++i) {
        long tmp = b;
        b = a + b;
        a = tmp;
        f(a);
    }
    return a;
}

int main(int argc, char *argv[]) {
    fib(10, [](long res) {
        std::cout << res << " ";
    });
    std::cout << "\n";
    return 0;
}