Lambdy w C++: funkcje anonimowe z przykładami

Funkcje pisane tam, gdzie ich używasz

Na poprzedniej stronie widać było, jak przeciążanie pozwala kilku funkcjom dzielić jedną nazwę. Czasem jednak nie chcesz nazwanej funkcji w ogóle: potrzebujesz malutkiego kawałka logiki raz, dokładnie w miejscu użycia, a nadawanie mu nazwy tylko dodałoby bałaganu. Właśnie tym jest lambda: funkcją anonimową, którą definiujesz w miejscu.

Lambda ma charakterystyczny czteroczęściowy kształt:

[capture](parameters) -> return_type { body }

Po [] od razu poznasz, że patrzysz na lambdę. Typ zwracany jest opcjonalny, bo kompilator zwykle sam go dedukuje. Oto najprostsza możliwa lambda:

#include <iostream>
using namespace std;

int main() {
    auto greet = []() { cout << "Hello from a lambda!\n"; };

    greet();   // wywołaj ją jak każdą funkcję
    return 0;
}

greet to po prostu zmienna (jej typu nie da się zapisać, więc przechowujesz ją przez auto), którą możesz wywołać przez (). Lambdy z parametrami działają dokładnie jak zwykłe funkcje:

#include <iostream>
using namespace std;

int main() {
    auto add = [](int a, int b) { return a + b; };

    cout << add(3, 4) << "\n";   // 7
    return 0;
}

Przechwytywanie: sięganie do otaczającego zasięgu

Tym, co czyni lambdy czymś więcej niż funkcjami bez nazwy, jest lista przechwytywania, czyli []. Pozwala lambdzie używać zmiennych z zasięgu, w którym została zdefiniowana, a nie tylko własnych parametrów.

Przechwytywanie przez wartość przez [x]: lambda dostaje własną kopię, zamrożoną w chwili swojego utworzenia.

#include <iostream>
using namespace std;

int main() {
    int factor = 10;

    auto scale = [factor](int n) { return n * factor; };

    factor = 999;            // zmienione PO utworzeniu lambdy
    cout << scale(5) << "\n"; // 50, a nie 4995: lambda skopiowała starą wartość
    return 0;
}

Zauważ, że scale(5) wypisało 50, używając wartości factor równej 10, która istniała w chwili tworzenia lambdy. Przechwytywanie przez wartość robi migawkę.

Przechwytywanie przez referencję przez [&x]: lambda odnosi się do oryginalnej zmiennej, widzi późniejsze zmiany i może ją modyfikować.

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    auto addToTotal = [&total](int n) { total += n; };

    addToTotal(5);
    addToTotal(3);
    cout << total << "\n";   // 8: oryginał został zmodyfikowany
    return 0;
}

Możesz też przechwycić wszystko, czego używa lambda, przez [=] (wszystko przez wartość) albo [&] (wszystko przez referencję). To wygodne, ale jawny zapis, czyli [total] albo [&total], dokumentuje dokładnie, czego lambda dotyka, i łatwiej go zrozumieć.

Pułapka wiszącej referencji

Przechwytywanie przez referencję jest w równym stopniu potężne i niebezpieczne. Referencja jest ważna tylko tak długo, jak żyje oryginalna zmienna. Jeśli lambda przeżyje to, co przechwyciła, dostajesz wiszącą referencję i niezdefiniowane zachowanie: program może się wysypać, wypisać śmieci albo przypadkiem wyglądać na działający.

Oto klasyczny błąd: zwracanie lambdy, która przechwytuje zmienną lokalną przez referencję.

auto makeCounter() {
    int count = 0;
    return [&count]() { return ++count; };  // BŁĄD: count tu umiera
}
// Zwrócona lambda odwołuje się teraz do zniszczonej pamięci.

Gdy makeCounter kończy działanie, jego lokalny count jest niszczony, ale lambda wciąż trzyma do niego referencję. Wywołanie zwróconej lambdy dotyka martwej pamięci. Rozwiązaniem jest przechwycenie przez wartość, żeby lambda miała własny stan:

#include <iostream>
using namespace std;

auto makeCounter() {
    int count = 0;
    return [count]() mutable { return ++count; };  // ma własną kopię
}

int main() {
    auto next = makeCounter();
    cout << next() << next() << next() << "\n";  // 123
    return 0;
}

Praktyczna zasada: przechwytuj przez referencję tylko wtedy, gdy lambda jest używana od razu i lokalnie (jak przy algorytmach poniżej). Gdy tylko lambda jest przechowywana, zwracana albo uruchamiana później, wybieraj przechwytywanie przez wartość.

mutable i typy zwracane

Zauważasz mutable w ostatnim przykładzie? Domyślnie przechwycenie przez wartość jest wewnątrz lambdy const: możesz czytać kopię, ale nie możesz jej zmienić. Dodanie mutable pozwala lambdzie modyfikować własne kopie między wywołaniami.

#include <iostream>
using namespace std;

int main() {
    int seen = 0;
    auto track = [seen]() mutable {
        seen++;                 // zmienia kopię w lambdzie, a nie zmienną zewnętrzną
        return seen;
    };

    cout << track() << track() << track() << "\n";  // 123
    cout << "outer seen is still " << seen << "\n";  // 0
    return 0;
}

mutable wpływa tylko na prywatną kopię lambdy: zewnętrzne seen pozostaje nietknięte, i o to właśnie chodzi w przechwytywaniu przez wartość.

W większości przypadków kompilator bez problemu dedukuje typ zwracany. Musisz go zapisać przez -> tylko przy niejednoznaczności, na przykład gdy lambda mogłaby zwracać różne typy w różnych gałęziach:

// Bez -> kompilator nie może wybrać między int a double
auto half = [](int n) -> double {
    if (n % 2 == 0) return n / 2;   // int
    return n / 2.0;                 // double
};

Lambdy i algorytmy: prawdziwa korzyść

Lambdy dodano do C++ po to, żeby przekazywać krótkie kawałki logiki do algorytmów biblioteki standardowej. Przed lambdami trzeba było pisać osobną nazwaną funkcję albo niezgrabny obiekt funkcyjny daleko od miejsca użycia. Teraz logika mieszka dokładnie w miejscu wywołania.

Najczęstszy przykład to własna kolejność sortowania:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> nums = {5, 2, 8, 1, 9, 3};

    // Sortuj malejąco z komparatorem zapisanym w miejscu
    sort(nums.begin(), nums.end(), [](int a, int b) {
        return a > b;
    });

    for (int n : nums) cout << n << " ";  // 9 8 5 3 2 1
    cout << "\n";
    return 0;
}

Tu przechwytywanie błyszczy, bo lambda może wciągnąć wartość, według której filtruje albo liczy. Ten kod liczy, ile wyników przekracza próg wybrany przez użytkownika:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> scores = {42, 88, 17, 95, 63, 71};
    int passMark = 60;

    int passed = count_if(scores.begin(), scores.end(),
        [passMark](int s) { return s >= passMark; });

    cout << passed << " scores passed\n";  // 4
    return 0;
}

Ponieważ te lambdy są używane od razu i nie przeżywają otaczającej funkcji, przechwycenie przez referencję ([&passMark]) też byłoby tu bezpieczne, ale przez wartość jest równie czytelne i nigdy nie zawiśnie.

Dalej: wskaźniki

Lambdy po cichu postawiły głębsze pytanie: gdy przechwytujesz [&x], lambda trzyma się położenia x, a to położenie pozostaje ważne tylko, dopóki x żyje. Ta idea, czyli wartość wskazująca, gdzie coś mieszka w pamięci, i to, co się dzieje, gdy wskazywana rzecz znika, jest dokładnie tematem następnej strony. Zmierzymy się wprost ze wskaźnikami: jak pobrać adres, jak za nim podążać i jak ten sam problem wiszącej referencji, który właśnie widzisz, pojawia się w całym C++.