מערכים ב-C#: הצהרה, Length, מיון, מערך דו-ממדי ומערך משונן

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

הצהרה על מערך ואתחול

הטיפוס של מערך הוא טיפוס האיבר ואחריו []. יש כמה דרכים ליצור מערך:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

פלט:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] ממלא כל איבר בערך ברירת המחדל של הטיפוס: 0 למספרים, false ל-bool, null למחרוזות ולטיפוסי הפניה אחרים. הצורה המקוצרת { "Ana", "Ben" } עובדת רק בהצהרה; כשמציבים למשתנה קיים צריך names = new[] { "Dev", "Eli" };.

Length, אינדקסים והאיבר האחרון

האינדקסים רצים מ-0 עד Length - 1. Length הוא מאפיין, ולכן אין לו סוגריים (בניגוד למתודה Count() של LINQ).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

פלט:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

קריאה או כתיבה מחוץ לגבולות זורקות IndexOutOfRangeException בזמן ריצה; הקומפיילר לא תופס את זה. הגורם הרגיל הוא תנאי לולאה שנכתב i <= arr.Length במקום i < arr.Length.

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

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

לולאה על מערך

לולאת for נותנת את האינדקס; foreach נותנת כל איבר והיא הבחירה הברורה יותר כשרק קוראים.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

פלט:

4.95 | 13.20 | 3.58
Total: 21.73

משתנה ה-foreach הוא לקריאה בלבד: p = 0; בתוך הלולאה היא שגיאת קומפילציה. כדי לשנות איברים, השתמשו בלולאה עם אינדקס.

מיון, היפוך וחיפוש

המחלקה הסטטית Array מחזיקה את פונקציות העזר. Array.Sort ממיינת במקום ולא מחזירה כלום, כך שהסדר המקורי אובד.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

פלט:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf מחזירה -1 כשהערך חסר. Array.Find מחזירה את ערך ברירת המחדל של הטיפוס (0 כאן) כששום דבר לא תואם, וזה דו-משמעי עבור מספרים; השתמשו ב-Array.FindIndex כשזה חשוב. מיון בסדר יורד בקריאה אחת הוא Array.Sort(scores, (a, b) => b.CompareTo(a)).

אם צריך את התוצאה הממוינת בלי לגעת במקור, LINQ מחזיר מערך חדש: var sorted = scores.OrderBy(s => s).ToArray();. ראו LINQ.

שינוי גודל: מערך לא יכול לגדול

האורך קבוע. Array.Resize יוצרת מערך חדש בגודל המבוקש, מעתיקה את האיברים, ומעדכנת את המשתנה שמעבירים ב-ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

פלט:

4
2
True
False

כל שינוי גודל מעתיק את כל האיברים. הגדלת מערך באיבר אחד בכל פעם בתוך לולאה היא איטית, וזה בדיוק מה ש-List<T> עושה בשבילכם ביעילות רבה יותר, כשהוא מכפיל את המערך הפנימי שלו.

מערכים הם טיפוסי הפניה: העתקה

הצבת מערך למשתנה אחר מעתיקה את ההפניה, לא את האיברים. אז שני השמות מצביעים על אותו מערך.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

פלט:

100
2
0, 100, 2, 3, 0

אותו דבר קורה כשמעבירים מערך למתודה: המתודה יכולה לשנות את האיברים של הקוד הקורא. Clone, Array.Copy, CopyTo ו-ToArray() של LINQ יוצרים כולם עותק רדוד. במערך של אובייקטים, המערך החדש מחזיק הפניות לאותם אובייקטים, כך ששינוי של copy[0].Name עדיין משנה את מה ש-original[0] רואה.

השוואת מערכים עם == משווה הפניות. כדי להשוות תוכן, השתמשו ב-a.SequenceEqual(b) מתוך System.Linq.

מערכים דו-ממדיים (רב-ממדיים)

רשת מלבנית מוצהרת עם פסיק בתוך הסוגריים המרובעים. מאנדקסים אותה עם [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

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

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

פלט:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X 

Length במערך דו-ממדי הוא מספר האיברים הכולל (6 ברשת של 2 על 3), ולכן לולאות מקוננות משתמשות ב-GetLength(0) וב-GetLength(1). Rank הוא מספר הממדים. שלושה ממדים עובדים באותה דרך: new int[4, 4, 4] ו-cube[x, y, z]. לולאת foreach על מערך דו-ממדי עוברת על כל האיברים שורה אחרי שורה.

מערכים משוננים (מערכים של מערכים)

מערך משונן (jagged array) int[][] הוא מערך שהאיברים שלו הם בעצמם מערכים, ולכל מערך פנימי יכול להיות אורך משלו. הוא מתאים לנתונים כמו "הזמנות לכל לקוח", שבהם השורות שונות בגודלן.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

פלט:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] יוצר רק את המערך החיצוני; כל שורה מתחילה כ-null, ו-orders[0][0] לפני שמציבים שורה זורק NullReferenceException. התחביר new int[3][4] אינו מותר; יוצרים כל שורה בעצמכם.

השתמשו ב-[,] לרשת אמיתית (לוח, מטריצה, פיקסלים) וב-[][] כשלשורות יש אורכים שונים או כשרוצים להחליף שורות שלמות.

מערך מול List

ההמרה היא קריאה אחת לכל כיוון: new List<int>(arr) או arr.ToList(), ו-list.ToArray(). List<T> היא הגרסה שיכולה לגדול.

טעויות נפוצות

• i <= arr.Length בלולאה. האינדקס התקף האחרון הוא Length - 1; זה זורק IndexOutOfRangeException.
• הדפסת המערך ישירות. Console.WriteLine(arr) מדפיס System.Int32[]; השתמשו ב-string.Join.
• ציפייה ש-Array.Sort תחזיר את המערך הממוין. היא מחזירה void וממיינת במקום.
• העתקה עם =. זה מעתיק את ההפניה; השתמשו ב-Clone() או ב-ToArray().
• שימוש בשורות של מערך משונן לפני שיוצרים אותן. כל שורה של new T[n][] היא null עד שמציבים לה ערך.
• שימוש ב-Length למספר השורות של מערך דו-ממדי. הוא סופר את כל האיברים; השתמשו ב-GetLength(0).