לולאת for מבוססת טווח ב-C++: תחביר, auto והפניות

"לכל איבר, עשו את זה"

לולאת ה-for הקלאסית שסופרת מצוינת כשיש אינדקס שמניע אותה. אבל ברוב הזמן האינדקס בכלל לא מעניין אתכם: אתם רק רוצים לגעת בכל איבר של מכולה. כתיבת for (int i = 0; i < v.size(); i++) בשביל זה רועשת, ו-i נמצא במרחק טעות אחת של אחד-יותר-מדי מקריאה מחוץ לגבולות.

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

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

int main() {
    vector<int> scores = {90, 75, 100, 60};

    for (int s : scores) {
        cout << s << "\n";
    }
}

בלי אינדקס, בלי .size(), בלי גבולות לטעות בהם. קראו את זה כ"לכל s ב-scores". זה עובד על מערכים גולמיים, std::vector, std::string, std::map וכל דבר אחר שחושף begin() ו-end().

תנו ל-auto לבחור את הטיפוס

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

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

int main() {
    vector<string> names = {"Ada", "Linus", "Grace"};

    for (auto name : names) {
        cout << "Hello, " << name << "!\n";
    }
}

אבל יש כאן עלות נסתרת. auto name רגיל מסיק string ומעתיק כל איבר לתוך name בכל מעבר. עבור int זה בחינם, עבור string או struct גדול זו הקצאה מבוזבזת בכל איטרציה. הפתרון הוא הפניות, וזה הדבר הבא שצריך להבין.

שינוי במקום עם auto&

אם כותבים auto x, מקבלים עותק, ולכן השמה ל-x משנה את העותק ולא את המכולה. שימו לב למלכודת הזו:

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

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

    for (auto n : nums) {   // עותק! השינויים נזרקים
        n *= 10;
    }

    for (int n : nums) cout << n << " ";   // עדיין 1 2 3
}

ההכפלה בשקט לא עושה כלום, כי n הוא עותק זמני. כדי באמת לערוך את האיברים, קחו אותם לפי הפניה עם auto&:

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

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

    for (auto& n : nums) {   // הפניה: עורכת את האיבר האמיתי
        n *= 10;
    }

    for (int n : nums) cout << n << " ";   // 10 20 30
}

ה-& הבודד הוא כל ההבדל בין "להסתכל בלי לגעת" לבין "לערוך במקום". אם אי פעם תתהו למה השינויים שלכם נעלמים, כמעט תמיד זו הסיבה.

קריאה בלי העתקה: const auto&

כשצריך רק לקרוא איברים אבל יקר להעתיק אותם, השתמשו ב-const auto&. ההפניה חוסכת את ההעתקה, ו-const מתעד (ואוכף) שלא תשנו כלום:

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

int main() {
    vector<string> words = {"refactor", "compile", "deploy"};

    size_t total = 0;
    for (const auto& w : words) {   // בלי עותק, אי אפשר לשנות את w בטעות
        total += w.size();
    }

    cout << "Total characters: " << total << "\n";
}

כלל אצבע טוב:

for (auto x : c)         // עותק: טיפוסים זולים (int, char, מצביעים)
for (auto& x : c)        // עריכה: רוצים לשנות את האיברים
for (const auto& x : c)  // קריאה: טיפוסים כבדים שרק בודקים

השתמשו כברירת מחדל ב-const auto& לקריאה וב-auto& לכתיבה. השתמשו ב-auto רגיל רק לטיפוסים קטנים באמת שזול להעתיק.

לולאה על maps וזוגות

לולאת for מבוססת טווח על std::map נותנת לכם std::pair לכל רשומה, עם .first (המפתח) ו-.second (הערך). מאז C++17, structured bindings מאפשרים לפרק את הזוג הזה לשני משתנים עם שמות ישירות בכותרת הלולאה:

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<string, int> ages = {{"Ada", 36}, {"Grace", 85}};

    for (const auto& [name, age] : ages) {
        cout << name << " is " << age << "\n";
    }
}

[name, age] ברור הרבה יותר מחזרה על entry.first ו-entry.second בכל מקום. השאירו גם כאן את const auto&: המפתח של רשומה ב-map הוא string, ולכן העתקה של כל זוג תהיה בזבזנית.

המלכודת: אל תשנו גודל תוך כדי לולאה

המלכודת הגדולה ביותר היא שינוי הגודל של המכולה בזמן שלולאת for מבוססת טווח עוברת עליה. קריאה ל-push_back, erase, insert או clear עלולה להקצות מחדש את האחסון שמתחת ולבטל את האיטרטורים הפנימיים של הלולאה. התוצאה היא התנהגות לא מוגדרת, כלומר קריסות או זבל, לא שגיאה ידידותית:

vector<int> v = {1, 2, 3};
for (int x : v) {
    v.push_back(x);   // התנהגות לא מוגדרת: ההקצאה מחדש מבטלת את הטווח
}

אם צריך להוסיף או להסיר איברים תוך כדי עיבוד, עברו ללולאת for מבוססת אינדקס או איטרטור ונהלו את הגבולות בעצמכם, או בנו מכולת תוצאה נפרדת והחליפו אליה אחר כך. שתי מלכודות קטנות יותר מאותה משפחה: לעולם אל תקשרו לולאת for מבוססת טווח לאובייקט זמני שמת מיד (for (auto x : makeVector()) בסדר, אבל for (auto& x : someObj.getTempVector()) עלול להישאר תלוי), וזכרו ש-for (auto& c : myString) מאפשר לשנות תווים בודדים במקומם.

הבא בתור: פונקציות

לולאת for מבוססת טווח מסדרת את המעבר על איברים, והבחירות בין auto / auto& / const auto& שלמדתם עכשיו עוברות ישירות לאחד הכלים החשובים ביותר ב-C++. בהמשך נארוז לוגיקה בפונקציות לשימוש חוזר: ניתן לקוד שם, פרמטרים וערך החזרה, כדי שתוכלו לקרוא לו מכל מקום במקום לחזור על עצמכם.