Warum Lambdas eine verbesserte Compiler-Optimierung im Vergleich zu einfachen Funktionen ermöglichen

Die C-Standardbibliothek (Zweite Ausgabe) von Nicolai Josuttis behauptet, dass Lambdas dies können von Compilern im Vergleich zu einfachen Funktionen effektiver optimiert werden. Dieser Vorteil ergibt sich aus der Natur von Lambdas als Funktionsobjekte.

Wenn ein Lambda an eine Funktionsvorlage übergeben wird, wird es als neue Funktion instanziiert, die speziell auf dieses Objekt zugeschnitten ist. Dadurch kann der Compiler den Lambda-Aufruf mühelos einbinden. Umgekehrt wird bei einfachen Funktionen ein Funktionszeiger an die Funktionsvorlage übergeben. Traditionell hatten Compiler Schwierigkeiten beim Inlining von Aufrufen, die über Funktionszeiger durchgeführt wurden.

Um dieses Konzept zu veranschaulichen, betrachten Sie die folgende Funktionsvorlage:

template 
void map(Iter begin, Iter end, F f) {
    for (; begin != end;   begin)
        *begin = f(*begin);
}

Aufrufen dieser Funktion mit einem Lambda:

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });

führt zu einer vom Compiler erstellten Instanziierung:

template 
void map(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end;   begin)
        *begin = f.operator()(*begin);
}

In diesem Fall hat der Compiler Zugriff auf _some_lambda_type::operator() und kann Aufrufe nahtlos darin integrieren. Jedes Lambda hat einen eigenen Typ, daher würde die Verwendung eines anderen Lambda mit map() eine neue Instanziierung erzeugen.

Wenn jedoch stattdessen ein Funktionszeiger verwendet würde:

map(int* begin, int* end, int (*f)(int)) {
    for (; begin != end;   begin)
        *begin = f(*begin);
}

Der Compiler wäre nicht in der Lage, Aufrufe von f einzubinden, bis der umfassende Aufruf von map() ebenfalls eingebunden ist, sodass er eine bestimmte Funktion lokalisieren kann. Dies unterstreicht den Vorteil von Lambdas gegenüber einfachen Funktionen im Hinblick auf die Compileroptimierung.