מדריך מהיר לביטויי למדה ב-C++

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

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

מהו בעצם ביטוי למבדה, וכיצד תוכל להשתמש בו לטובתך כמתכנת C++?

מהו ביטוי למבדה?

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

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

מהם החלקים של ביטוי C++ למבדה?

ביטויי למבדה קלים לשימוש ב-C++. אתה יכול לפרק את התחביר של ביטוי למבדה ב-C++ באופן הבא:

[capture_clause](פרמטרים) אפשרויות { expression_body; }

לדוגמה:

int val = 13;
אוטומטי





instagram viewer
 sumPlusVal = [val](int א, int ב) מִשְׁתַנֶהלא למעט ->int { לַחֲזוֹר val + a + b; };
sumPlusVal(2, 5); // 20

מהקוד שלמעלה, אתה יכול לראות שביטוי למבדה מכיל כמה חלקים שמציינים כיצד הוא פועל. להלן סקירה מהירה של כל אחד מהרכיבים הללו.

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

   auto addTwo = [foo](){ לַחֲזוֹר foo + 2; }; // לפי ערך
   auto addThree = [&bar](){ לַחֲזוֹר bar + 3; }; // לפי הפניה
   auto addAllVal = [=](){ לַחֲזוֹר foo + בר; }; // הכל לפי ערך
   auto addAllRef = [&](){ לַחֲזוֹר foo + בר; }; // הכל לפי הפניה
   // צור משתנה בסעיף לכידה
   auto createVarInCapture = [fooBar = foo + bar](){ לַחֲזוֹר פו בר * 5; };
   // no capture - מחזיר שגיאה כי foo אינו נגיש
   auto errorExpression = [](){ לַחֲזוֹר foo + 2; };

2. פרמטרים: חלק זה של ביטוי הלמבדה הוא גם אופציונלי. הוא מכיל את פרמטרי הפונקציה הנדרשים על ידי הלמבדה. זה לא שונה מהדרך הרגילה שבה אתה מגדיר פרמטרים של פונקציה ב-C++.
3. אפשרויות: ניתן גם לציין אפשרויות בעת הגדרת ביטוי למבדה. כמה אפשרויות שבהן תוכל להשתמש הן: מִשְׁתַנֶה, יוצא מן הכלל (לְמָשָׁל לא למעט בקוד לדוגמה הראשון), ->סוג_החזרה (לְמָשָׁל -> אינט), דורש, תכונות, וכו. ה מִשְׁתַנֶה אופציה משמשת לעתים קרובות מכיוון שהיא מאפשרת ללכודות להיות ניתנות לשינוי בתוך הלמבדה. הקוד שלהלן מדגים זאת.

   int ערך = 10;
   // מחזיר שגיאה - הערך הוא קוסט בתוך הביטוי
   הפחתה אוטומטית = [value](){ לַחֲזוֹר --ערך; };
   תוספת אוטומטית = [value]() ניתן לשינוי { לַחֲזוֹר ++ערך; };
   תוֹסֶפֶת(); // 11
   

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

מהם היתרונות של ביטויי למדה?

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

• ביטויי למדה עוזרים לשמור על קוד נקי. אחת הדרכים הטובות ביותר לשמור על הקוד שלך פשוט ומסודר היא באמצעות למבדות במידת האפשר. זה יכול לעזור מאוד בשמירה על מבנה קוד קריא וניתן לשימוש חוזר.
• אתה יכול להעביר למבדות לפונקציות אחרות כפרמטרים. ה ספריות סטנדרטיות של C++std:: sort() השיטה עושה שימוש בהטבה זו. אתה יכול להעביר למבדה כאחד מהפרמטרים של שיטה זו כדי לציין כיצד הפונקציה צריכה לבצע את המיון. לדוגמה:

   std:: וקטור<int> arr = {2, 5, 1, 3, 4};
   std:: sort (arr.begin(), arr.end(), [](int א, int ב){ לַחֲזוֹר a < b; });
  // arr = {1, 2, 3, 4, 5}
  

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

  #לִכלוֹל <iostream>
  באמצעות מרחב שמותסטד;
  intרָאשִׁי(){
  // הגדירו למבדה לשימוש חוזר
   auto addUp = [](auto a, auto b, auto c) noexcept {
   cout <<"עכשיו מוסיף... "<< א <<", "<< ב <<" ו "<< ג << endl;
  לַחֲזוֹר a + b + c;
   };
  cout << addUp (22, 33, 44) << endl;
   cout << addUp (מחרוזת("שַׂמֵחַ "), מחרוזת("הוּלֶדֶת"), מחרוזת("יְוֹם")) << endl; 
   cout << addUp(נָכוֹן, שֶׁקֶר, נָכוֹן) << std:: endl; // מתבצע כמספרים (1 ו-0)
  }
  

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

שימוש במבדות ב-C++

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

עליך לשקול ביטויי למבדה אם אתה רוצה לשלב מושגי C++ מודרניים בבסיס הקוד שלך.