Warum sind Lambdas in C optimierbarer als einfache Funktionen?

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

Die C Standard Library (Second Edition) 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 getätigt wurden.

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

template <typename Iter, typename F>
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*, _some_lambda_type>(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end; ++begin)
        *begin = f.operator()(*begin);
}

In diesem Fall ist die Der Compiler hat 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*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

Der Compiler würde dies tun Es ist nicht möglich, Aufrufe von f einzubinden, bis der umfassende Aufruf von map() ebenfalls eingebunden ist, was es ihm ermöglicht, eine bestimmte Funktion zu lokalisieren. Dies unterstreicht den Vorteil von Lambdas gegenüber einfachen Funktionen im Hinblick auf die Compiler-Optimierung.

Das obige ist der detaillierte Inhalt vonWarum sind Lambdas in C optimierbarer als einfache Funktionen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!