Lambda ב-C++: פונקציות אנונימיות עם דוגמאות

פונקציות שכותבים במקום שבו משתמשים בהן

בעמוד הקודם ראיתם איך העמסה מאפשרת לכמה פונקציות לחלוק שם אחד. אבל לפעמים לא רוצים פונקציה עם שם בכלל: צריך פיסת לוגיקה קטנה פעם אחת, בדיוק במקום שבו משתמשים בה, ולתת לה שם רק יוסיף עומס. זו בדיוק lambda: פונקציה אנונימית שאפשר להגדיר בתוך הקוד.

ל-lambda יש צורה ייחודית בת ארבעה חלקים:

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

ה-[] הוא הסימן שאתם מסתכלים על lambda. טיפוס ההחזרה אופציונלי: בדרך כלל הקומפיילר מסיק אותו. הנה הפשוטה ביותר שאפשר:

#include <iostream>
using namespace std;

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

    greet();   // קוראים לה כמו לכל פונקציה
    return 0;
}

greet הוא פשוט משתנה (אי אפשר לכתוב את הטיפוס שלו, ולכן שומרים אותו עם auto) שאפשר לקרוא לו עם (). lambdas עם פרמטרים עובדות בדיוק כמו פונקציות רגילות:

#include <iostream>
using namespace std;

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

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

לכידות: גישה לטווח שמסביב

החלק שהופך lambdas ליותר מסתם פונקציות בלי שם הוא רשימת הלכידה, ה-[]. היא מאפשרת ל-lambda להשתמש במשתנים מהטווח שבו היא הוגדרה, ולא רק בפרמטרים שלה.

לכידה לפי ערך עם [x]: ה-lambda מקבלת עותק משלה, קפוא ברגע שבו היא נוצרת.

#include <iostream>
using namespace std;

int main() {
    int factor = 10;

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

    factor = 999;            // שונה אחרי שה-lambda נוצרה
    cout << scale(5) << "\n"; // 50, לא 4995: היא העתיקה את הערך הישן
    return 0;
}

שימו לב ש-scale(5) הדפיס 50, עם הערך 10 של factor שהיה קיים כשה-lambda נוצרה. לכידה לפי ערך לוקחת תמונת מצב.

לכידה לפי הפניה עם [&x]: ה-lambda מתייחסת למשתנה המקורי, רואה שינויים מאוחרים יותר ויכולה לשנות אותו.

#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: המקורי השתנה
    return 0;
}

אפשר גם ללכוד את כל מה שה-lambda משתמשת בו עם [=] (הכול לפי ערך) או [&] (הכול לפי הפניה). זה נוח, אבל כתיבה מפורשת, [total] או [&total], מתעדת בדיוק במה ה-lambda נוגעת וקל יותר לחשוב עליה.

מלכודת ההפניה התלויה

לכידה לפי הפניה חזקה ומסוכנת באותה מידה. ההפניה תקפה רק כל עוד המשתנה המקורי חי. אם ה-lambda חיה יותר זמן ממה שהיא לכדה, מקבלים הפניה תלויה והתנהגות לא מוגדרת: התוכנית עלולה לקרוס, להדפיס זבל, או להיראות כאילו היא עובדת במקרה.

זו הטעות הקלאסית: החזרת lambda שלוכדת משתנה מקומי לפי הפניה.

auto makeCounter() {
    int count = 0;
    return [&count]() { return ++count; };  // באג: count מת כאן
}
// ה-lambda שהוחזרה מתייחסת עכשיו לזיכרון שהושמד.

כש-makeCounter חוזרת, המשתנה המקומי count שלה מושמד, אבל ה-lambda עדיין מחזיקה הפניה אליו. קריאה ל-lambda שהוחזרה נוגעת בזיכרון מת. הפתרון הוא ללכוד לפי ערך, כך שה-lambda מחזיקה במצב משלה:

#include <iostream>
using namespace std;

auto makeCounter() {
    int count = 0;
    return [count]() mutable { return ++count; };  // מחזיקה עותק משלה
}

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

כלל אצבע: לכדו לפי הפניה רק כשה-lambda משמשת מיד ובאופן מקומי (כמו עם האלגוריתמים בהמשך). ברגע ש-lambda נשמרת, מוחזרת או רצה מאוחר יותר, העדיפו לכידה לפי ערך.

mutable וטיפוסי החזרה

שמתם לב ל-mutable בדוגמה האחרונה? כברירת מחדל, לכידה לפי ערך היא const בתוך ה-lambda: אפשר לקרוא את העותק אבל לא לשנות אותו. הוספת mutable מאפשרת ל-lambda לשנות את העותקים שלה בין קריאות.

#include <iostream>
using namespace std;

int main() {
    int seen = 0;
    auto track = [seen]() mutable {
        seen++;                 // משנה את העותק של ה-lambda, לא את החיצוני
        return seen;
    };

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

mutable משפיע רק על העותק הפרטי של ה-lambda: ה-seen החיצוני לא נפגע, וזו כל המטרה של לכידה לפי ערך.

ברוב המקרים הקומפיילר מסיק את טיפוס ההחזרה בלי בעיה. צריך לכתוב אותו במפורש עם -> רק כשיש עמימות, למשל lambda שעשויה להחזיר טיפוסים שונים בענפים שונים:

// בלי -> הקומפיילר לא יכול להחליט בין int ל-double
auto half = [](int n) -> double {
    if (n % 2 == 0) return n / 2;   // int
    return n / 2.0;                 // double
};

lambdas ואלגוריתמים: התמורה האמיתית

הסיבה ש-lambdas נוספו ל-C++ היא כדי להעביר פיסות לוגיקה קצרות לאלגוריתמים של הספרייה הסטנדרטית. לפני lambdas הייתם צריכים לכתוב פונקציה נפרדת עם שם או אובייקט פונקציה מסורבל, רחוק מהמקום שבו השתמשו בו. עכשיו הלוגיקה נמצאת ממש בנקודת הקריאה.

הדוגמה הנפוצה ביותר היא סדר מיון מותאם:

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

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

    // מיון בסדר יורד עם פונקציית השוואה בתוך הקוד
    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;
}

לכידות זוהרות כאן, כי ה-lambda יכולה למשוך ערך לסנן או לספור לפיו. הקוד הזה סופר כמה מספרים עוברים סף שהמשתמש בחר:

#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;
}

מכיוון שה-lambdas האלה משמשות מיד ולא חיות יותר זמן מהפונקציה שמסביב, גם לכידה לפי הפניה ([&passMark]) הייתה בטוחה כאן, אבל לכידה לפי ערך ברורה באותה מידה ואף פעם לא נשארת תלויה.

הבא בתור: מצביעים

lambdas העלו בשקט שאלה עמוקה יותר: כשלוכדים [&x], ה-lambda מחזיקה ב_מיקום_ של x, והמיקום הזה נשאר תקף רק כל עוד x חי. הרעיון הזה, ערך שמתייחס למקום שבו משהו נמצא בזיכרון, ומה קורה כשהדבר שהוא מצביע עליו נעלם, הוא בדיוק הנושא של העמוד הבא. ניפגש עם מצביעים פנים אל פנים: איך לוקחים כתובת, איך עוקבים אחריה, ואיך אותה בעיה של הפניה תלויה שראיתם עכשיו מופיעה בכל רחבי C++.