// Aus diesem Grunde kratzen die folgenden Beispiele nur an der Oberfläche. //
// Andererseits können wir nur an der Oberfläche kratzen, denn wenn wir tiefer kratzen, sind wir nicht mehr an der Oberfläche. //

— Lawrence J. Peter

Algorithmen der Standard-Bibliothek wie for_each() erwarten oft eine Funktion oder einen Funktor, der auf Elemente eines Bereichs angewendet wird. Mit einem Lambda-Ausdruck kann diese Funktion an Ort und Stelle erzeugt werden:

#include <algorithm>
#include <iostream>
#include <string>
 
void lambdademo()
{
  std::string s = "Hello, Lambda Expressions in C++11!";
 
  std::for_each(s.begin(), s.end(),
    [] (char c) { std::cout << c; }       // <-- hier
  );
  std::cout << std::endl;
}

Lambdas sind anonyme, lokal definierte Funktionen. Der Rückgabetyp wird, sofern möglich, automatisch ermittelt. Er kann hinter der Parameterliste mit -> Zieltyp angegeben werden.

  std::string uppercase;
  std::copy_if(s.begin(), s.end(), 
    std::back_inserter(uppercase), 
    [] (char c) -> bool
    { 
      return ('A' <= c && c <= 'Z'); 
    }
  );
  std::cout << uppercase << std::endl;

Man beachte den neuen Algorithmus copy_if() in <algorithm>.

Lambdas sind als Variablenwerte speicherbar, um sie mehrfach zu nutzen. Das Schlüsselwort auto ist hierbei hilfreich:

  auto fromAtoZ = [] (char c) -> char
    { 
      return ('A' <= c && c <= 'Z') ? c : '.'; 
    };
 
  std::list<char> aList;
  std::transform(s.begin(), s.end(), std::back_inserter(aList), fromAtoZ);

Lambda-Ausdrücke beginnen mit einer eckigen Klammer. In dieser kann angegeben werden, welche lokalen Variablen(werte) der Umgebung innerhalb des Lambda-Ausdrucks bekannt sein sollen. Dieses Einbeziehen der Umgebung wird Closure (Einschluss) genannt.

#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
 
void closuredemo()
{
  std::string s = "Hello, lambda expressions in C++11!";
  char low = 'A', high = 'Z';
 
  std::for_each(s.begin(), s.end(),
    [low, high] (char c)            // closure by value
    { 
      if (low <= c && c <= high) std::cout << c; 
    }
  ); 
  std::cout << std::endl;
}

Hier werden die bei der Lambda-Definition aktuellen Werte der Variablen low und high übernommen. Auch referenzieller Einschluss ist möglich und manchmal erwünscht:

  int count = 0;
  std::for_each(s.begin(), s.end(),
    [low, high, &count] (char c)    // closure by reference: &count 
    { 
      if (low <= c && c <= high) ++count; 
    }
  );
  std::cout << count << std::endl;

Durch die Angabe [&] werden alle Variablen der Umgebung als Referenz übernommen. Durch [=] werden alle Werte der Umgebung kopiert. Auch gemischte Angaben [=, &count] sind möglich. In Methoden definierte Lambdas können [this] (als Wert) einschließen, um an Attribute eines Objektes heranzukommen. Weitere Beispiele sind im Visual Team Blog zu finden.

C++14 erlaubt bei der Definition des Lambda-Ausdrucks neue lokale Variablen einzuführen, die ihre Werte durch Ausdrücke erhalten:

void tabulate(double a, double b, int n)
{
  auto f = [a, dy = (b-a)/n] (int i) { return a + i * dy; };
 
  for (int i = 0; i <= n; ++i)
  {
    std::cout << i << '\t' <<  f(i) << '\n';
  }
}

Der Typ von Lambda-Parametern kann vom Compiler ermittelt werden (ab C++14):

void generic_demo()
{
  std::vector<std::string> v { "generic", "lambdas", "in", "C++14" };
 
  std::sort(v.begin(), v.end(), [](auto a, auto b) { return a.size() < b.size(); });
 
  for (auto e : v) std::cout << e << ' ';
  std::cout << '\n';
}