شرح المُكرِّرات في C++: begin وend وأنواع المُكرِّرات

ما هو المُكرِّر فعليًا

كل حاوية قياسية - vector وstring وmap وset وlist - تخزّن عناصرها داخليًا بطريقة مختلفة. فالـ vector كتلة متجاورة، والـ map شجرة متوازنة، والـ list عُقَد مترابطة. ومع ذلك يمكنك المرور عليها كلها بالطريقة نفسها. والذي يجعل ذلك ممكنًا هو المُكرِّر: كائن صغير "يشير إلى" عنصر واحد ويعرف كيف يخطو إلى التالي.

تخيَّل المُكرِّر بوصفه مؤشرًا معمَّمًا. تحصل على واحد من begin()، وتقرأ العنصر الذي يشير إليه بـ *، وتُحرِّكه إلى الأمام بـ ++. تتلاءم القطع هكذا:

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

int main() {
    vector<int> v = {10, 20, 30};

    vector<int>::iterator it = v.begin();
    cout << *it << "\n";   // 10 - فك الإسناد يقرأ العنصر

    ++it;                  // التقدّم إلى العنصر التالي
    cout << *it << "\n";   // 20
}

تُعيد v.begin() مُكرِّرًا إلى العنصر الأول؛ و*it تعطيك ذلك العنصر؛ و++it تنتقل إلى التالي. هذا الثلاثي - فكّ الإسناد، والتقدّم، والمقارنة - هو النموذج الذهني بأكمله.

begin() وend() والمجال نصف المفتوح

النصف الآخر من الصورة هو end(). والأمر الحاسم: end() لا يشير إلى العنصر الأخير، بل يشير إلى الموضع الذي يلي العنصر الأخير بموضع واحد. وهذا مجال "نصف مفتوح" مقصود [begin, end): فـ begin مُضمَّن، وend إشارة التوقف.

هذا التصميم يجعل الحلقة القياسية نظيفة - تمشي حتى يساوي المُكرِّر end():

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

int main() {
    vector<int> v = {3, 1, 4, 1, 5};

    for (auto it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << "\n";
}

لاحظ it != v.end()، وليس it < v.end(). فمعظم مُكرِّرات الحاويات (مثل map أو list) لا تدعم <، بل تدعم == و!= فقط، لذا فإن != هو الخيار القابل للنقل. كما أن auto يوفّر عليك كتابة vector<int>::iterator يدويًا - فالمُترجِم يستنتجه.

تنحلّ حالة الحاوية الفارغة بطبيعتها: عندما تكون الحاوية فارغة يكون begin() == end()، فلا يُنفَّذ جسم الحلقة أبدًا. لا حاجة إلى أي معالجة خاصة.

لا تفُكَّ إسناد end() أبدًا

أكثر أخطاء المُكرِّرات شيوعًا هو فكّ إسناد end(). وبما أنه يشير إلى موضع واحد بعد العنصر الأخير، فإن *v.end() يقرأ ذاكرة ليست ملكًا لك - سلوك غير مُعرَّف، أي انهيار أو قمامة صامتة، لا رسالة خطأ ودودة:

vector<int> v = {1, 2, 3};
cout << *v.end();   // سلوك غير معرَّف - end() ليس عنصرًا

والفخ نفسه يصيب دوال البحث. تُعيد std::find القيمة end() عندما لا تجد القيمة، لذا يجب أن تتحقق قبل فكّ الإسناد:

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

int main() {
    vector<int> v = {2, 4, 6, 8};

    auto it = find(v.begin(), v.end(), 5);
    if (it != v.end()) {
        cout << "Found: " << *it << "\n";
    } else {
        cout << "5 is not in the vector\n";   // هذا ما يُنفَّذ
    }
}

قارن دائمًا المُكرِّر المُعاد بـ end() قبل أن تفُكَّ إسناده. ونسيان جملة if هذه من أكثر مصادر الانهيار شيوعًا في شيفرة الـ STL لدى المبتدئين.

const وcbegin والمُكرِّرات العكسية (reverse)

تمنحك الحاويات نكهات مختلفة من المُكرِّرات بحسب ما تحتاج إليه:

• begin() / end() - مُكرِّرات عادية للقراءة/الكتابة (*it = ... يعمل).
• cbegin() / cend() - مُكرِّرات const_iterator؛ يمكنك القراءة من خلالها لكن لا يمكنك تعديل العنصر.
• rbegin() / rend() - مُكرِّرات عكسية تمشي من النهاية نحو البداية؛ و++ يتحرّك فعليًا في الاتجاه المعاكس.

المُكرِّرات العكسية هي الطريقة النظيفة للمرور بالاتجاه المعاكس دون حسابات فهرسة معقّدة:

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

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

    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        cout << *it << " ";   // 4 3 2 1
    }
    cout << "\n";
}

مع المُكرِّرات العكسية ما زلت تكتب ++it للتقدّم - فالمُكرِّر يتولّى اتجاه "الرجوع" داخليًا. استخدم cbegin()/cend() (أو مرجعًا const إلى الحاوية) عندما يُفترض ألا تقرأ الحلقة سوى القراءة، حتى يمنعك المُترجِم من الكتابة عن طريق الخطأ.

مُكرِّرات map تعطي pairs

ليس كل مُكرِّر غلافًا رقيقًا حول مؤشر. فمُكرِّر std::map يمشي عبر شجرة، وفكّ إسناده يعطيك std::pair من المفتاح والقيمة، يُوصَل إليهما عبر ->first و->second (تمامًا كالمؤشر، يدعم المُكرِّر ->):

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

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

    for (auto it = ages.begin(); it != ages.end(); ++it) {
        cout << it->first << " -> " << it->second << "\n";
    }
}

حلقة for المعتمِدة على المجال مبنية مباشرة على begin()/end()، لذا فإنك في التكرار الأمامي البسيط ستلجأ إليها عادةً. أما المُكرِّرات الصريحة فتُثبت جدارتها حين تحتاج إلى مرور عكسي، أو إلى موضع عنصر، أو إلى تمرير مجال إلى خوارزمية.

الفخ الكبير: إبطال المُكرِّرات

هذا هو المزلق الذي يقع فيه الجميع عاجلًا أم آجلًا. عندما تغيّر بنية حاوية، قد تصبح المُكرِّرات الموجودة مُبطَلة - تشير إلى ذاكرة حُرِّرت أو نُقِلت. واستخدام أحدها سلوك غير مُعرَّف.

بالنسبة إلى vector، قد يُعيد push_back تخصيص المخزن المؤقت بأكمله ليُكبِّره، مُبطِلًا كل مُكرِّر قائم. أما الحذف أثناء المرور فأشدّ شهرةً - وهذا انهيار كلاسيكي:

vector<int> v = {1, 2, 3, 4};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it % 2 == 0)
        v.erase(it);   // خطأ - erase يُبطِل it، ثم ++it سلوك غير معرَّف
}

الحل أن erase يُعيد مُكرِّرًا صالحًا إلى العنصر الذي يلي المحذوف. تقدَّم فقط حين لا تحذف:

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

int main() {
    vector<int> v = {1, 2, 3, 4, 5, 6};

    for (auto it = v.begin(); it != v.end(); ) {
        if (*it % 2 == 0)
            it = v.erase(it);   // erase يُعيد المُكرِّر الصالح التالي
        else
            ++it;               // تقدَّم فقط عندما لا يُحذف شيء
    }

    for (int x : v) cout << x << " ";   // 1 3 5
    cout << "\n";
}

لاحظ أن ترويسة for لا تتضمّن ++it - فالجسم هو من يقرّر متى يتقدّم. (في الشيفرة الواقعية، يُنجِز اصطلاح erase-remove أو std::erase_if في C++20 هذا في سطر واحد.) والقاعدة التي ينبغي تذكّرها: أي عملية تضيف عناصر أو تزيلها قد تُبطِل المُكرِّرات، فلا تتمسّك بمُكرِّر قديم عبر مثل هذا التغيير.

التالي: الخوارزميات

الآن وقد صرت قادرًا على وصف المجال بوصفه زوجًا من begin/end، فقد فتحت مكتبة خوارزميات الـ STL بأكملها. فدوال مثل sort وfind وcount وaccumulate لا تأبه بنوع الحاوية التي بين يديك - فهي تعمل على مجالات المُكرِّرات، بحيث يعمل الاستدعاء نفسه على vector، أو مصفوفة، أو شريحة من إحداها. وفيما يلي سنُشغِّل هذه المُكرِّرات وندَع المكتبة القياسية تتولّى التكرار نيابةً عنك.