vector في ++C: شرح المصفوفات الديناميكية باستخدام std::vector

لماذا vector بدلًا من مصفوفة خام

تمتلك المصفوفة الخام حجمًا ثابتًا مُضمَّنًا في وقت الترجمة، وتنسى طولها لحظة تمريرها إلى دالة. أما std::vector فيحلّ المشكلتين معًا: فهو مصفوفة قابلة لتغيير الحجم تتتبّع طولها بنفسها، وتكبر عند الطلب، وتنظّف ذاكرتها بنفسها. في ++C الحديثة، يُعدّ vector الحاوية الافتراضية - لا تلجأ إلى مصفوفة خام إلا حين يكون لديك سبب محدد لعدم استخدامه.

ضمّن <vector>، ثم صرّح عن واحد مع وضع نوع العنصر بين قوسين زاويّين:

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

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

    cout << "Count: " << scores.size() << "\n";
    cout << "First: " << scores[0] << "\n";
}

يخبرك scores.size() دائمًا بالطول الحالي - دون الحاجة إلى int n منفصل تُبقيه متزامنًا، ودون حيل sizeof. والقيمة {90, 75, 100, 60} هي مُهيّئ بأقواس معقوفة؛ ويستنتج الـ vector بنفسه أنه يحتاج إلى أربع خانات.

إنشاء vector وتهيئته

هناك عدة طرق لبنائه، حسب ما تعرفه مسبقًا:

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

int main() {
    vector<int> empty;                 // 0 عنصر
    vector<int> filled = {1, 2, 3};    // 3 عناصر من قائمة
    vector<int> tens(5, 10);           // 5 عناصر، كل منها = 10
    vector<string> names(3);           // 3 سلاسل فارغة

    cout << empty.size() << " "
         << filled.size() << " "
         << tens.size() << " "
         << names.size() << "\n";      // 0 3 5 3
}

انتبه لمزلق الأقواس الدائرية مقابل المعقوفة: فـ vector<int> tens(5, 10) ينشئ خمس نسخ من 10، بينما vector<int> tens{5, 10} ينشئ vector من عنصرين يحتويان على 5 و10. الأقواس الدائرية تعني «الحجم وقيمة التعبئة»؛ والأقواس المعقوفة تعني «هذه العناصر الحرفية».

إضافة العناصر وإزالتها

جوهر الـ vector هو أنه يكبر. يُلحق push_back في النهاية، ويزيل pop_back من النهاية:

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

int main() {
    vector<int> v;          // ابدأ فارغًا
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);

    v.pop_back();           // أزل الـ 30

    cout << "Size: " << v.size() << "\n";   // 2
    cout << "Back: " << v.back() << "\n";    // 20
}

يُعيد back() العنصر الأخير ويُعيد front() الأول - وهذا أنظف من v[v.size() - 1] وv[0]. ومنذ ++C11 يمكنك أيضًا استخدام emplace_back(args...) لبناء عنصر في مكانه، ما يتجنّب نسخة مؤقتة للأنواع الأثقل.

من الأخطاء الشائعة لدى المبتدئين استدعاء front() أو back() على vector فارغ. هذا سلوك غير معرَّف، وليس خطأً - احرص دائمًا على الحماية أولًا بـ if (!v.empty()).

قراءة العناصر: [] مقابل ()at

تُفهرس الـ vector تمامًا كما تفهرس مصفوفة باستخدام []. لكن [] لا يجري أي فحص للحدود - فالفهرس خارج النطاق سلوك غير معرَّف، قد يقرأ بيانات غير صالحة بصمت أو ينهار لاحقًا في موضع مربك:

vector<int> v = {1, 2, 3};
cout << v[10];   // سلوك غير معرَّف - لا فحص، لا خطأ

عندما تريد الأمان، استخدم at(). فهو يفحص الفهرس ويُطلق std::out_of_range عند وصول خاطئ، فتحصل على فشل واضح بدلًا من الفساد:

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

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

    try {
        cout << v.at(10) << "\n";   // يُطلق out_of_range
    } catch (const out_of_range& e) {
        cout << "Caught: " << e.what() << "\n";
    }
}

قاعدة عملية: استخدم [] في الحلقات المُحكمة حيث أثبتّ بالفعل أن الفهرس صالح، واستخدم at() عند الحدود حيث قد يتسلّل إدخال خاطئ.

المرور على vector

أنظف طريقة للمرور على vector هي حلقة for القائمة على النطاق. خذ العناصر بـ const auto& للقراءة دون نسخ، أو بـ auto& لتعديلها في مكانها:

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

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

    for (auto& n : v) {       // مرجع - يعدّل العناصر الفعلية
        n *= n;
    }

    for (const auto& n : v) { // للقراءة فقط
        cout << n << " ";     // 1 4 9 16
    }
    cout << "\n";
}

إن كنت تحتاج فعلًا إلى الفهرس (لمقارنة العناصر المتجاورة مثلًا)، فاستخدم حلقة عدّ تقليدية - لكن لاحظ أن size() يُعيد نوعًا بلا إشارة (size_t). إن مقارنة int i ذي إشارة به قد تطلق تحذيرات من المترجم والتفافًا غير متوقع، لذا فضّل size_t i أو حلقة قائمة على النطاق متى أمكن:

for (size_t i = 0; i < v.size(); i++) {   // size_t، وليس int
    cout << v[i];
}

size وcapacity وreserve

يحتفظ الـ vector برقمين: size() (عدد العناصر التي يحملها) وcapacity() (عدد العناصر التي يمكنه حملها قبل أن يضطر إلى الكبر). عندما يتجاوز push_back السعة، يخصّص الـ vector كتلة أكبر، وينسخ كل عنصر إليها، ويحرّر الكتلة القديمة. لهذا فإن push_back المتكرر رخيص على نحو مُستهلَك، لكن كل عملية إعادة تخصيص منفردة ليست مجانية:

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

int main() {
    vector<int> v;
    v.reserve(100);          // خصّص مسبقًا مساحة لـ 100

    for (int i = 0; i < 100; i++) {
        v.push_back(i);      // لا إعادة تخصيص - السعة موجودة بالفعل
    }

    cout << "Size: " << v.size() << ", capacity >= " << v.capacity() << "\n";
}

إن كنت تعرف تقريبًا عدد العناصر التي ستضيفها، فاستدعِ reserve() أولًا لتخطّي عمليات إعادة التخصيص المتكررة. لاحظ أن reserve() يغيّر السعة لا الحجم - فيبقى عدد عناصر الـ vector صفرًا حتى تدفعها إليه.

إعادة التخصيص هذه هي أيضًا مصدر أخبث علّة في الـ vector. ولأن الكبر ينقل المخزن، فإن أي مؤشر أو مرجع أو مُكرِّر حفظته إلى داخل الـ vector يصبح مُعلَّقًا بعد push_back يُعيد التخصيص:

vector<int> v = {1, 2, 3};
int& first = v[0];     // مرجع إلى داخل الـ vector
v.push_back(4);        // قد يُعيد التخصيص...
cout << first;         // مُعلَّق - قد يشير إلى ذاكرة محرَّرة

وينطبق الأمر نفسه على المُكرِّرات: لا تستدعِ push_back ولا erase أثناء المرور بمُكرِّر محفوظ. وإن كان لا بدّ من إزالة عناصر أثناء الحلقة، فاستخدم القيمة المُعادة من erase، أو نمط erase-remove مع std::remove.

التالي: map

يكون الـ vector مثاليًا حين تبحث عن الأشياء حسب الموضع - العنصر 0، العنصر 1، وهكذا. لكنك كثيرًا ما تريد البحث عن الأشياء بـ مفتاح بدلًا من ذلك: اسم مستخدم، أو معرّف منتج، أو كلمة. ولهذا الغرض وُجد std::map. سنتناول تاليًا map، حاوية المفتاح-القيمة في ++C، بما في ذلك كيفية الإدراج والبحث والمرور على المدخلات - ومزلق أن [] يُنشئ قيمة افتراضية، الذي يوقع كل الناس تقريبًا في الخطأ.