pair ו-tuple ב-C++: קיבוץ ערכים בלי struct

שני ערכים, אובייקט אחד

לפעמים צריך להחזיק שני דברים ביחד: שם וניקוד, x ו-y, דגל "האם זה עבד" והתוצאה. אפשר להגדיר struct לכל צמד כזה, אבל לקיבוצים חד-פעמיים זה הרבה טקס. std::pair (מ-<utility>) אורז בדיוק שני ערכים לאובייקט אחד, ו-std::tuple (מ-<tuple>) מכליל את זה לכל מספר קבוע של ערכים.

כבר פגשתם את std::pair בעקיפין בדרך לכאן: כל איבר של std::map הוא pair<const Key, Value>. העמוד הזה הופך את זה למפורש ומראה את הדרכים המודרניות והקריאות לבנות ולפרק את הטיפוסים האלה.

#include <iostream>
#include <utility>   // std::pair
#include <string>
using namespace std;

int main() {
    pair<string, int> player{"Ada", 90};

    cout << player.first << " scored " << player.second << "\n";
    return 0;
}

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

יצירת זוגות

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

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

int main() {
    // 1. אתחול בסוגריים מסולסלים: ברירת המחדל המודרנית
    pair<string, int> a{"Boris", 85};

    // 2. std::make_pair: הטיפוס מוסק מהארגומנטים
    auto b = make_pair(string("Rosa"), 78);

    // 3. השמה לתוך pair קיים
    pair<string, int> c;
    c.first = "Liang";
    c.second = 92;

    cout << a.first << " " << b.first << " " << c.first << "\n";
    return 0;
}

make_pair מסיק בשבילכם את טיפוסי האיברים, וזה היה שימושי לפני C++17. היום אתחול בסוגריים מסולסלים יחד עם הסקת ארגומנטים של תבנית מחלקה (pair p{"Boris", 85};) מכסים את רוב המקרים, אבל עדיין תראו את make_pair בכל מקום בקוד קיים.

מלכודת אחת בהסקה: make_pair("hi", 3) מסיק pair<const char*, int>, לא pair<string, int>. ליטרלים של מחרוזת אינם std::string. אם צריך string, כתבו את זה במפורש, make_pair(string("hi"), 3) או כתיבה מלאה של טיפוס ה-pair, אחרת אתם עלולים לקבל בהמשך השוואות או העתקות מפתיעות.

פירוק עם structured bindings

קריאה של .first ו-.second בכל מקום הופכת מהר ללא קריאה, כי השמות לא אומרים כלום. structured bindings של C++17 מאפשרים לתת לשני השדות שמות אמיתיים בשורה אחת:

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

int main() {
    pair<string, int> player{"Ada", 90};

    auto [name, score] = player;   // name = "Ada", score = 90

    cout << name << " scored " << score << "\n";
    return 0;
}

זה זוהר בלולאת for מבוססת טווח על map, שבו כל איבר הוא pair. במקום it->first / it->second, נותנים שם ישירות למפתח ולערך:

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

int main() {
    map<string, int> scores = {{"Ada", 90}, {"Boris", 85}, {"Rosa", 78}};

    for (const auto& [name, score] : scores) {
        cout << name << ": " << score << "\n";
    }
    return 0;
}

השתמשו ב-const auto& בלולאה, בדיוק כמו לכל איבר של מכולה: זה חוסך העתקה של כל pair ומסמן שאתם רק קוראים. הסירו את ה-& ותעתיקו כל רשומה, וזה באג ביצועים שקט ב-map גדול.

כששניים לא מספיקים: tuple

pair נעצר בשני ערכים. כשצריך שלושה או יותר, std::tuple הוא אותו רעיון עם מספר שרירותי. בונים אחד עם אתחול בסוגריים מסולסלים או עם make_tuple, וקוראים אותו עם std::get<N>, כאשר N הוא אינדקס שידוע בזמן הקימפול.

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

int main() {
    tuple<string, int, double> record{"Ada", 90, 4.0};

    cout << get<0>(record) << " "    // Ada
         << get<1>(record) << " "    // 90
         << get<2>(record) << "\n";  // 4

    auto deduced = make_tuple("Boris", 85, 3.7);  // tuple<const char*, int, double>
    cout << get<1>(deduced) << "\n";
    return 0;
}

האינדקס בתוך get<> חייב להיות קבוע שידוע בזמן הקימפול. get<i>(record) כאשר i הוא משתנה בזמן ריצה לא יתקמפל: לשדות של tuple יכולים להיות טיפוסים שונים, ולכן טיפוס האיבר צריך להיקבע במהלך הקימפול, לא בזמן הריצה. אם אתם מוצאים את עצמכם רוצים אינדקס בזמן ריצה, כנראה שאתם צריכים vector.

structured bindings עובדים גם על tuples, וזו הדרך הקריאה להשתמש בהם:

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

int main() {
    tuple<string, int, double> record{"Ada", 90, 4.0};

    auto [name, score, gpa] = record;

    cout << name << " - score " << score << ", gpa " << gpa << "\n";
    return 0;
}

החזרת כמה ערכים

הסיבה היומיומית להשתמש בטיפוסים האלה היא החזרה של יותר מערך אחד מפונקציה בלי להמציא struct או ללהטט בפרמטרי פלט. ארזו את התוצאות ב-pair או ב-tuple ופרקו אותן בנקודת הקריאה.

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

// מחזירה (דגל הצלחה, ערך שפוענח)
pair<bool, int> parsePositive(const string& text) {
    int value = stoi(text);
    if (value <= 0) return {false, 0};
    return {true, value};
}

int main() {
    auto [ok, value] = parsePositive("42");

    if (ok) cout << "Got " << value << "\n";
    else    cout << "Not a positive number\n";
    return 0;
}

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

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

tuple<string, int, double> getRecord() {
    return {"Ada", 90, 4.0};
}

int main() {
    int score;
    // מוציאים רק את הניקוד; מתעלמים מהשם ומהממוצע
    tie(ignore, score, ignore) = getRecord();

    cout << "score = " << score << "\n";
    return 0;
}

אבל מתי לעצור: אם אותה קבוצת שדות מופיעה ביותר ממקום אחד, או שאתם שוכחים כל הזמן אם .second הוא הניקוד או הספירה, הגדירו struct עם איברים בעלי שמות. pair ו-tuple מתאימים ביותר לקיבוצים מקומיים וקצרי חיים, ושדות עם שמות מנצחים ברגע שהנתונים חיים יותר מביטוי אחד.

השוואה ומיון

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

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

int main() {
    vector<pair<int, string>> people = {
        {30, "Ada"}, {25, "Boris"}, {30, "Rosa"}
    };

    sort(people.begin(), people.end());  // לפי גיל, ואז לפי שם

    for (const auto& [age, name] : people) {
        cout << age << " " << name << "\n";
    }
    // 25 Boris / 30 Ada / 30 Rosa
    return 0;
}

שימו לב שסדר השדות חשוב: שימת age ראשון ממיינת קודם כול לפי גיל, ואז לפי שם כהכרעה בשוויון. אם רציתם סדר לפי שם קודם, הייתם מחליפים את סדר האיברים ב-tuple. ההשוואה ברירת המחדל הזו היא בדיוק הסיבה ש-pair<priority, item> הוא idiom נפוץ לתורי עדיפויות.

הבא בתור: איטרטורים

ראיתם עכשיו את .first, .second, it->first ו-*it מופיעים סביב מכולות: מה שבאמת מחבר איבר pair ל-map שבו הוא נמצא הוא איטרטור. העמוד הבא מפרק איטרטורים כמו שצריך: מה begin() ו-end() באמת מחזירים, איך ++it עובר על מכולה, ומלכודות ביטול האיטרטורים שגורמות לכמה מההתנהגויות הלא מוגדרות הגרועות ביותר ב-C++.