מערכים ב-C++: הצהרה, אינדקסים ומלכודות נפוצות

שורה של ערכים בגודל קבוע

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

מצהירים על מערך על ידי ציון טיפוס האיברים, שם וגודל בסוגריים מרובעים. מוסיפים רשימה בסוגריים מסולסלים כדי למלא אותו:

#include <iostream>
using namespace std;

int main() {
    int scores[4] = {90, 75, 100, 60};

    cout << "First score:  " << scores[0] << "\n";
    cout << "Fourth score: " << scores[3] << "\n";
}

האינדקסים מתחילים מאפס: האיבר הראשון הוא scores[0], ולמערך בגודל 4 יש אינדקסים תקינים מ-0 עד 3. הגודל חייב להיות קבוע שידוע בזמן הידור: אי אפשר לכתוב int n = readInput(); int a[n]; ב-C++ סטנדרטית (זו הרחבה לא ניידת). כשצריך גודל שנקבע בזמן ריצה, השתמשו ב-vector במקום.

אתחול מערכים

יש כמה דרכים למלא מערך, וכמה קיצורי דרך שכדאי להכיר:

#include <iostream>
using namespace std;

int main() {
    int a[3] = {1, 2, 3};   // מפורש
    int b[]  = {1, 2, 3};   // הגודל נגזר מהרשימה -> 3
    int c[5] = {1, 2};      // השאר מאותחלים לאפס -> 1 2 0 0 0
    int d[4] = {};          // הכול אפסים

    cout << b[2] << " " << c[3] << " " << d[0] << "\n";
}

הנקודה שכדאי להפנים: כשמספקים פחות ערכי אתחול מהגודל, השאריות עוברות אתחול ערך (אפס לטיפוסים מספריים), ולא נשארות זבל. אבל מערך בלי שום אתחול, int e[4]; שמוצהר כמשתנה מקומי, מכיל ערכים לא מוגדרים, וקריאה שלהם לפני השמה היא undefined behavior.

מעבר על מערך בלולאה

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

#include <iostream>
using namespace std;

int main() {
    int scores[] = {90, 75, 100, 60};
    int n = sizeof(scores) / sizeof(scores[0]);

    int total = 0;
    for (int i = 0; i < n; i++) {
        total += scores[i];
    }

    cout << "Average: " << total / n << "\n";
}

sizeof(scores) הוא מספר הבתים הכולל של המערך כולו; חלוקה ב-sizeof(scores[0]) (הגודל של איבר אחד) נותנת את מספר האיברים. מאז C++17 יש כתיב נקי יותר, std::size(scores), שנקרא טוב יותר ומסרב להתהדר אם בטעות מעבירים לו מצביע. ופשוט עוד יותר כשצריך רק את הערכים: for מבוסס טווח חוסך לגמרי את החישובים עם האינדקס.

#include <iostream>
#include <iterator>   // std::size
using namespace std;

int main() {
    int scores[] = {90, 75, 100, 60};

    cout << "Count: " << size(scores) << "\n";

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

המלכודת של חריגה מהגבולות

C++ לא בודקת גבולות ב-arr[i]. גישה לאינדקס שאחרי האיבר האחרון לא זורקת חריגה ולא מזהירה: היא קוראת או כותבת את מה שנמצא במקרה בזיכרון שם. זה הבאג הנפוץ ביותר במערכים, ו-undefined behavior קלאסי:

int a[3] = {1, 2, 3};
a[3] = 99;          // OOPS - valid indices are 0..2, not 3
cout << a[5];       // garbage, crash, or corruption - undefined behavior

טעות ה-off-by-one מסתתרת בדרך כלל בתנאי של הלולאה. כתיבת i <= n במקום i < n מריצה צעד אחד יותר מדי ונוגעת ב-arr[n], שלא קיים:

for (int i = 0; i <= n; i++)   // BUG: when i == n, arr[i] is out of bounds
    cout << arr[i];

התיקון הוא המשמעת מהסעיף הקודם: לולאה עם i < size, אף פעם לא <=, וחישוב הגודל מתוך המערך במקום להקליד שוב מספר שמתיישן כשמוסיפים איבר.

Decay של מערך: המצביע הנסתר

ההתנהגות הכי מבלבלת של מערכים ב-C++ היא decay: כשמעבירים מערך לפונקציה, הוא מומר בשקט למצביע לאיבר הראשון שלו. המידע על הגודל הולך לאיבוד, ולכן sizeof בתוך הפונקציה מודד את המצביע, לא את המערך.

#include <iostream>
using namespace std;

void printSize(int arr[]) {
    // arr הוא בעצם int*, לא int[4]
    cout << "inside:  " << sizeof(arr) << " bytes\n";   // הגודל של מצביע
}

int main() {
    int data[4] = {1, 2, 3, 4};
    cout << "outside: " << sizeof(data) << " bytes\n";  // 16 (4 ints)
    printSize(data);
}

שימו לב ש-int arr[] ו-int* arr זהים לגמרי כפרמטרים של פונקציה: הסוגריים הם קוסמטיים בלבד. מכיוון שהספירה אבדה, אתם חייבים להעביר את האורך יחד עם המערך בעצמכם:

int sum(const int* arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) total += arr[i];
    return total;
}

הדפוס הזה של "מעבירים מצביע ואורך ומקווים שהם מתאימים" הוא בדיוק החיכוך שדוחף את רוב קוד ה-C++ לכיוון std::array ו-std::vector, שנושאים את הגודל שלהם בעצמם ואף פעם לא עוברים decay.

כמה מילים על מערכים רב-ממדיים

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

#include <iostream>
using namespace std;

int main() {
    int grid[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    for (int r = 0; r < 2; r++) {
        for (int c = 0; c < 3; c++) {
            cout << grid[r][c] << " ";
        }
        cout << "\n";
    }
}

ניגשים אליו כ-grid[row][col]. אותן הסתייגויות לגבי גבולות ו-decay תקפות, ואפילו חמורות יותר, כי העברת מערך דו-ממדי לפונקציה דורשת לפרט כל ממד חוץ מהראשון (void f(int g[][3])). לכל דבר מעבר לרשת קטנה וקבועה, vector של vectorים הרבה פחות מועד לטעויות.

הבא בתור: Vector

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