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

هناك ثلاث طرق شائعة لإنشاء 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 ويشير إلى أنك تقرأ فقط. أزِل & فتنسخ كل مدخلة؛ وهذا خطأ أداء صامت على خريطة كبيرة.

حين لا يكفي اثنان: 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 مع الـtuple أيضًا، وهي الطريقة الواضحة لاستهلاكه:

#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;
    // استخرج score فقط؛ وتجاهل name وgpa
    tie(ignore, score, ignore) = getRecord();

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

لكن اعرف متى تتوقف: إن ظهرت المجموعة نفسها من الحقول في أكثر من موضع، أو ظللت تنسى هل .second هو الدرجة أم العدد، فعرّف struct بأعضاء مسمّاة. فالـpair والـtuple أنسب للتجميعات المحلية القصيرة العمر؛ وتتفوق الحقول المسمّاة فور أن تبقى البيانات حيّة أطول من تعبير واحد.

المقارنة والترتيب

ميزة إضافية مفيدة: يأتي pair وtuple بمعاملات مقارنة مدمجة تعمل معجميًّا (lexicographically)؛ فهي تقارن العنصر الأول ولا تنتقل إلى التالي إلا عند تساوي الأولَين. وهذا يجعلهما مفاتيح ترتيب مثالية.

#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> أسلوبًا شائعًا لطوابير الأولوية.

التالي: المُكرِّرات (Iterators)

رأيت الآن .first و.second وit->first و*it تظهر حول الحاويات؛ والشيء الذي يربط فعليًا عنصر pair بالـmap التي يعيش فيها هو المُكرِّر (iterator). تشرح الصفحة التالية المُكرِّرات كما ينبغي: ما الذي يُرجِعه فعلًا كل من begin() وend()، وكيف يجوب ++it الحاوية، ومزالق إبطال المُكرِّرات التي تسبّب بعضًا من أبشع حالات السلوك غير المعرَّف في C++.