C++14 - Lambda-Funktion mit zwischengespeichertem Rückgabewert

C++14, lambda, auto, cache, C++

Angenommen, wir haben eine Funktion geschrieben, die einen Wert berechnet oder eine Funktion verwendet, um diesen Wert zu berechnen, während die Berechnung der Funktion_, die den Wert berechnet, ziemlich teuer ist und viel Zeit in Anspruch nimmt. In diesem Fall rufen wir die Lambda-Funktion in einigen Codes mehrmals auf.

Um mehrere schwere Funktionsaufrufe zu vermeiden, können wir den Wert zwischenspeichern, den die schwere Funktion zurückgibt.

Beispielcode

#include <iostream>
#include <string>

using namespace std;

int heavy_calc(int base) // heavy function that we want to call once
{
    cout << "heavy_calc" << std::endl;
    // sleep(+100500 years)
    return base * 25;
}

void calclulateValue(int base)
{
    // The following construction allows you to cache the result of executing a heavy function for the duration of one call to calclulateValue
    auto foo
    {
        [cache = heavy_calc(base)]()
        {
            return cache;
        }
    };
    // We call the lambda twice with the cached heavy calc value 
    // In this case, heavy calc is called only once
    int fooFoo = foo() + foo();
    cout << fooFoo << std::endl;
}

int main()
{
    // Call calclulateValue twice with a different base value,
    // to show that the cache is reset every time calclulateValue is called
    calclulateValue(1);
    calclulateValue(10);
    return 0;
}

Ergebnis

heavy_calc
50
heavy_calc
500