Skip to main content

Fun with Lambdas: C++14 Style (part 2)

Look at some interesting examples of C++11/14 lambdas and how they interact with other language features and libraries. I hope to find some time to add some explanations. See part 1 if you missed it.

  • Associative containers and lambdas
    std::set<int, std::function<bool(int, int)>> 
      numbers([](int i, int j) { return i < j; });
  • Recursive Lambdas (see Creating recursive lambdas and returning them too!)
    auto make_fibo() 
      return [](int n) {
        std::function<int(int)> recurse;
        recurse = [&](int n){ 
           return (n<=2)? 1 : recurse(n-1) + recurse(n-2); 
        return recurse(n);
  • Composable list manipulation (e.g., cpplinq, narl, LEESA)
    Box boxes[] = { ... };
    int sum_of_weights = 
      >> where([](const Box & box) { 
           return box.color == Color.RED;
      >> select([](const Box & box) {
           return box.get_weight();
      >> sum();
  • Overloaded Lambdas
    template <class... F>
    struct overload : F... {
      overload(F... f) : F(f)... {}  
    template <class... F>
    auto make_overload(F... f) {
      return overload<F...>(f...);   
    auto f = 
        make_overload([](int i) { /* print */ },
                      [](double d) { /* print */ });
    f(10); // int 
    f(9.99); // double
  • Type Switch (simple pattern matching) (see type_switch.cpp and this paper)
    struct Base { 
      virtual ~Base() {} 
    struct Derived : Base {};
    template <class Poly>
    void test(Poly& p) {  
        [](int i)             { cout << "int";       },
        [](std::string &)     { cout << "string";    },
        [](Derived &)         { cout << "Derived";   },     
        [](Base &)            { cout << "Base";      },    
        otherwise([](auto x)  { cout << "Otherwise"; })
    Derived d;
    Base &b = d;
    std::string cpptruths = "C++ Truths";
    boost::any something = cpptruths;
    test(10);        // int
    test(cpptruths); // string
    test(something); // string
    test(b);         // Derived
    test(9.99);      // Otherwise
  • Converting shared_ptr between boost and std (see StackOverflow)
    template <typename T>
    make_shared_ptr(std::shared_ptr<T> ptr) 
      return boost::shared_ptr<T>(ptr.get(), 
        [ptr](T*) mutable { ptr.reset(); });
    template <typename T>
    make_shared_ptr(boost::shared_ptr<T> ptr)
      return std::shared_ptr<T>(ptr.get(), 
        [ptr](T*) mutable { ptr.reset(); });
  • In-place parameter pack expansion 
    template <class... T>
    void foreach(T... args) 
      bool b[] = { [=](){ 
        std::cout << args << "\n"; 
        return true; 
      }()... }; 
    foreach(10, 20.2, true);
  • Memoization (see original)
    template <typename ReturnType, 
              typename... Args>
    auto memoize(ReturnType (*func)(Args...))
        std::map<std::tuple<Args...>, ReturnType> cache;
        return ([=](Args... args) mutable  
            std::tuple<Args...> t(args...);
            if (cache.find(t) == cache.end())                
              std::cout << "not found\n";
              cache[t] = func(args...);
            return cache[t];
  • Finally, slides


Amber said…
should `sum_of_weights` have been `count_of_weights`? (that'd make it a bit trivial). Or perhaps `count()` is the mistake

(I surely hope count doesn't sum)
Amber said…
The memoization example is nice and succinct, but it strikes me as significantly less advanced than others I've seen years ago on your blog, and even somewhat less featured than e.g. Herb's popular example.

Is there a reason you prefer this one, beyond the clarity of exposition?
Seth said…
I really like the overload example. Something like that should be in the standard library (though more general, so it works for any callable entity, not just inheritable classes.)

The 'In-place parameter pack expansion' example relies on function arguments being evaluated in a certain order. Instead you can avoid no_op(...) and do:
{bool b[] = {[=]() { cout << args << "\n"; return true; }()...};}

Nagy said…
Here is the original discussion for make_shared_ptr:
Sumant said…
@Amber and @Seth: Right. Thanks. I fixed the code.
y121516 said…
The Overloaded Lambdas code is ill-formed.
It work on Clang, but it is error occurred on GCC.
And behavior of GCC is correct.

Please see a entry and well-formed code written by @fimbul11
Lee said…
Nice couple of posts, Sumant. Made me want to dig into this a bit more. I've done a bit of digging, and have some more yet to do. I did find a way to compose lambdas (and, by extension, functions).

I've got a blog post on that at
Leopoldo said…
Muy buena.
Pagina de códigos basicos:
Thanks for sharing this information. Python is an easy language for beginners, because there's less of an emphasis on syntax. So, if you forget your parentheses or misplace a few semicolons, it shouldn't trip you up as much as it might if you were coding in a different language.If you wanna try to check out more about learn programming C++
C and C++ Live Project Training in Delhi- RKM IT Institute is a skill enhancement coaching center that makes engineers hot property in the booming IT industry. We offer C and C++ Programming Concepts & Languages training by experts.
Unknown said…
Thank you very much for the sharing! COOL.. Pakistani Bridal Dresses
Priya Kannan said…
Great site for these post and i am seeing the most of contents have useful for my Carrier.Thanks to such a useful information.Any information are commands like to share him.
Python Training in Chennai
Unknown said…
Wow great blog thank u for the explanation of concept using example program.....
Java Training Institute in Chennai
IICE-Indore said…
I am looking for some good blog sites for studying. I was searching over search engines and found your blog site.
C and C++ Training Institute in Indore

Popular Content

Unit Testing C++ Templates and Mock Injection Using Traits

Unit testing your template code comes up from time to time. (You test your templates, right?) Some templates are easy to test. No others. Sometimes it's not clear how to about injecting mock code into the template code that's under test. I've seen several reasons why code injection becomes challenging. Here I've outlined some examples below with roughly increasing code injection difficulty. Template accepts a type argument and an object of the same type by reference in constructor Template accepts a type argument. Makes a copy of the constructor argument or simply does not take one Template accepts a type argument and instantiates multiple interrelated templates without virtual functions Lets start with the easy ones. Template accepts a type argument and an object of the same type by reference in constructor This one appears straight-forward because the unit test simply instantiates the template under test with a mock type. Some assertion might be tested in

Covariance and Contravariance in C++ Standard Library

Covariance and Contravariance are concepts that come up often as you go deeper into generic programming. While designing a language that supports parametric polymorphism (e.g., templates in C++, generics in Java, C#), the language designer has a choice between Invariance, Covariance, and Contravariance when dealing with generic types. C++'s choice is "invariance". Let's look at an example. struct Vehicle {}; struct Car : Vehicle {}; std::vector<Vehicle *> vehicles; std::vector<Car *> cars; vehicles = cars; // Does not compile The above program does not compile because C++ templates are invariant. Of course, each time a C++ template is instantiated, the compiler creates a brand new type that uniquely represents that instantiation. Any other type to the same template creates another unique type that has nothing to do with the earlier one. Any two unrelated user-defined types in C++ can't be assigned to each-other by default. You have to provide a

Multi-dimensional arrays in C++11

What new can be said about multi-dimensional arrays in C++? As it turns out, quite a bit! With the advent of C++11, we get new standard library class std::array. We also get new language features, such as template aliases and variadic templates. So I'll talk about interesting ways in which they come together. It all started with a simple question of how to define a multi-dimensional std::array. It is a great example of deceptively simple things. Are the following the two arrays identical except that one is native and the other one is std::array? int native[3][4]; std::array<std::array<int, 3>, 4> arr; No! They are not. In fact, arr is more like an int[4][3]. Note the difference in the array subscripts. The native array is an array of 3 elements where every element is itself an array of 4 integers. 3 rows and 4 columns. If you want a std::array with the same layout, what you really need is: std::array<std::array<int, 4>, 3> arr; That's quite annoying for