ב-C#, מערכים משמשים כמיכלים לאחסון אלמנטים מאותו סוג נתונים. בעת יצירת מערך, ישנן מספר גישות לאתחל אותו עם אלמנטים. מאמר זה מתעמק בשיטות השונות לאתחול מערכים ב-C#, ומספק חקירה מקיפה של כל גישה.
שיטות לאתחל מערכים ב-C#
מערכים הם מבנה נתונים חיוני בתכנות מחשבים המאפשר לך לאחסן ולתפעל אוסף של אלמנטים מאותו סוג נתונים במיקומי זיכרון רציפים. הנה כמה דרכים לאתחל מערכים ב-C#:
1: אתחול מערכים באמצעות תחביר אתחול מערך
הגישה הפשוטה ביותר לאתחול מערך היא על ידי שימוש בתחביר אתחול המערך, שכן הדבר כרוך בסגירת רכיבי המערך בסוגרים, מופרדים בפסיקים, למשל:
int [ ] מספרים = { 1 , 2 , 3 , 4 , 5 } ;
בקוד זה, נוצר מערך שלמים בשם 'מספרים' ומאותחל עם הערכים 1 עד 5. באופן דומה, אתה יכול להשתמש באותו תחביר כדי לאתחל מערך רב-ממדי.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
הנה קוד לדוגמה שמשתמש בתחביר האתחול כדי לאתחל מערך 1D ו-2D ב-C#:
שימוש במערכת;
מערך כיתה
{
ריק סטטי ראשי ( חוּט [ ] args )
{
// אתחול מערך 1D באמצעות תחביר האתחול
int [ ] array1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'ערכים במערך 1D:' ) ;
ל ( int i = 0 ; אני < array1D.Length; i++ ) {
Console.WriteLine ( array1D [ אני ] ) ;
}
// אתחול מערך דו מימדי באמצעות תחביר האתחול
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'ערכים ב-array2D:' ) ;
ל ( int i = 0 ; אני < array2D.GetLength ( 0 ) ; i++ ) {
ל ( int j = 0 ; י < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ אני, י ] ) ;
}
}
}
}
בקוד זה, אנו משתמשים בתחביר האתחול כדי לאתחל מערך שלם חד מימדי בשם array1D עם הערכים 1, 2, 3, 4 ו-5.
אנחנו גם משתמשים בתחביר האתחול כדי לאתחל מערך שלם דו מימדי בשם array2D עם הערכים {1, 2}, {3, 4} ו-{5, 6}.
לאחר מכן אנו משתמשים בלולאות נוספות כדי לעבור דרך כל אלמנט של כל מערך ולהדפיס את הערך שלו לקונסולה.
2: אתחול מערכים באמצעות מילת המפתח החדשה
שיטה נוספת לאתחול מערך כוללת שימוש ב- חָדָשׁ מילת מפתח. זה כולל ציון גודל המערך בסוגריים מרובעים, ואחריו מילת המפתח החדשה, ולאחר מכן את סוג הנתונים של רכיבי המערך. לדוגמה:
int [ ] מספרים = חדש int [ 5 ] ;
קוד זה יוצר מערך שלמים בשם מספרים בגודל 5 ומאתחל את כל האלמנטים לערך ברירת המחדל שלהם, שהוא 0 עבור מערכים שלמים.
להלן התחביר לאתחול מערך רב מימדי באמצעות מילת המפתח החדשה ב-C#:
< סוּג > [ , ] < arrayName > = חדש < סוּג > [ < אורך1 > , < אורך2 > ,... ] { { < ערכים ראשוניים > } } ;
בתחביר זה,
הנה דוגמה כיצד להשתמש בתחביר זה כדי לאתחל מערך שלמים דו מימדי:
int [ , ] myArray = new int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
בדוגמה זו, אנו מאתחלים מערך שלמים דו מימדי בשם myArray עם 3 שורות ו-2 עמודות באמצעות מילת המפתח החדשה. אנו מספקים גם ערכים ראשוניים עבור כל רכיב במערך באמצעות תחביר הפלטה הכפולה. הערכים הם {1, 2}, {3, 4} ו-{5, 6}, המתאימים לאלמנטים בכל שורה.
הנה דוגמה כיצד להשתמש במילת המפתח החדשה כדי לאתחל גם מערך חד מימדי וגם מערך דו מימדי ב-C#, יחד עם קוד להדפסת הערכים בכל מערך:
שימוש במערכת;מערך כיתה
{
ריק סטטי ראשי ( חוּט [ ] args )
{
// אתחול א 1 -מערך ממדי
int [ ] myArray1D = new int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'ערכים ב-myArray1D:' ) ;
ל ( int i = 0 ; אני < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ אני ] ) ;
}
// אתחול א 2 -מערך ממדי
int [ , ] myArray2D = new int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'ערכים ב-myArray2D:' ) ;
ל ( int i = 0 ; אני < myArray2D.GetLength ( 0 ) ; i++ )
{
ל ( int j = 0 ; י < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ אני, י ] ) ;
}
}
}
}
בקוד זה, אנו משתמשים במילת המפתח החדשה כדי לאתחל מערך שלם חד מימדי בשם myArray1D עם הערכים 1, 2, 3, 4 ו-5, ומערך דו מימדי שלמים הנקרא myArray2D עם הערכים {1, 2}, {3, 4} ו-{5, 6}.
לאחר מכן אנו משתמשים בלולאות כדי לעבור דרך כל אלמנט של כל מערך ולהדפיס את הערך שלו לקונסולה. שימו לב שלמערך הדו-ממדי, אנו משתמשים GetLength() כדי לקבוע את מספר השורות והעמודות, ושימוש בלולאות מקוננות כדי לחזור על כל אלמנט.
3: אתחול מערכים באמצעות לולאות
ניתן לאתחל מערכים גם באמצעות לולאות. גישה אחת היא להשתמש בלולאת for, המאפשרת לך לעבור דרך המערך ולהקצות ערכים לכל אלמנט.
int [ ] מספרים = חדש int [ 5 ] ;ל ( int i = 0 ; אני < מספרים.אורך; i++ )
{
מספרים [ אני ] = i + 1 ;
}
קוד זה יוצר מערך שלמים בשם מספרים בגודל של 5 ומקצה לכל אלמנט ערך השווה לאינדקס שלו פלוס 1. הנה דוגמה כיצד לאתחל מערך שלמים דו מימדי ב-C# באמצעות לולאות:
ל ( int i = 0 ; אני < 3 ; i++ )
{
ל ( int j = 0 ; י < 2 ; j++ )
{
myArray [ אני, י ] = i + j;
}
}
בדוגמה זו, אנו משתמשים בלולאות מקוננות כדי לחזור על כל אלמנט של מערך דו-מימדי שלמים הנקרא myArray , בעל 3 שורות ו-2 עמודות. עבור כל אלמנט, אנו מגדירים את הערך שלו לסכום של מדדי השורות והעמודות שלו באמצעות הביטוי i + j.
הנה דוגמה כיצד להשתמש בלולאות כדי לאתחל גם מערך חד מימדי וגם מערך דו מימדי ב-C#, יחד עם קוד להדפסת הערכים בכל מערך:
שימוש במערכת;מערך כיתה
{
ריק סטטי ראשי ( חוּט [ ] args )
{
// אתחול א 1 -מערך ממדי באמצעות לולאה
int [ ] myArray1D = new int [ 5 ] ;
ל ( int i = 0 ; אני < myArray1D.Length; i++ )
{
myArray1D [ אני ] = i + 1 ;
}
Console.WriteLine ( 'ערכים ב-myArray1D:' ) ;
ל ( int i = 0 ; אני < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ אני ] ) ;
}
// אתחול א 2 מערך ממדי באמצעות לולאות מקוננות
int [ , ] myArray2D = new int [ 3 , 2 ] ;
ל ( int i = 0 ; אני < 3 ; i++ )
{
ל ( int j = 0 ; י < 2 ; j++ )
{
myArray2D [ אני, י ] = i + j;
}
}
Console.WriteLine ( 'ערכים ב-myArray2D:' ) ;
ל ( int i = 0 ; אני < 3 ; i++ )
{
ל ( int j = 0 ; י < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ אני, י ] ) ;
}
}
}
}
בקוד זה, אנו משתמשים בלולאת for כדי לאתחל מערך שלם חד-ממדי בשם myArray1D עם הערכים 1, 2, 3, 4 ו-5. אנו משתמשים גם ב- Nested for loops כדי לאתחל מערך שלם דו מימדי הנקרא myArray2D עם הערכים {0, 1}, {1, 2} ו-{2, 3} באמצעות הביטוי i + j.
לאחר מכן השתמש בלולאות נוספות כדי לעבור דרך כל אלמנט של כל מערך ולהדפיס את הערך שלו לקונסולה.
4: אתחול מערכים באמצעות Array.Copy()
גישה חלופית לאתחול מערך כוללת שימוש בפונקציה Array.Copy() . זה כולל יצירת מערך מקור עם האלמנטים הרצויים ולאחר מכן העתקתם למערך יעד. לדוגמה:
int [ ] מָקוֹר = { 1 , 2 , 3 , 4 , 5 } ;int [ ] target = new int [ מקור.אורך ] ;
מערך. העתק ( מָקוֹר , יעד, מקור.אורך ) ;
קוד זה יוצר מערך שלם בשם מקור עם הערכים 1 עד 5, יוצר מערך שלם חדש בשם target באותו גודל כמו מקור, ולאחר מכן מעתיק את האלמנטים ממקור ליעד.
הרשה לי להציג דוגמה המדגימה את השימוש ב-Array.Copy כדי לאתחל מערך שלם דו מימדי ב-C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = new int [ 3 , 2 ] ;
מערך. העתק ( sourceArray, destinationArray, sourceArray.Length ) ;
בדוגמה זו, יש לנו מערך שלמים דו מימדי שנקרא sourceArray עם 3 שורות ו-2 עמודות. אנחנו משתמשים Array.Copy() להעתיק את התוכן של sourceArray למערך דו מימדי חדש של מספרים שלמים בשם destinationArray, שיש לו גם 3 שורות ו-2 עמודות.
ה Array.Copy() השיטה לוקחת שלושה טיעונים : ה מערך מקור , ה מערך יעד , וה אורך של הנתונים שיועתקו. במקרה זה, אנו מעתיקים את כל התוכן של sourceArray לְתוֹך מערך יעד , אז אנחנו עוברים sourceArray.Length כטיעון השלישי.
שים לב שאתה יכול להשתמש Array.Copy() לאתחל מערכים עם כל מספר ממדים, כל עוד למערך המקור והיעד יש אותו מספר ממדים ובאותו גודל בכל מימד.
כמו כן, זכור זאת Array.Copy() מבצע עותק רדוד של מערך המקור, כלומר אם מערך המקור מכיל סוגי הפניות, ההפניות יועתקו אך האובייקטים עצמם לא ישוכפלו.
הנה הקוד המלא שמשתמש Array.Copy() פונקציה לאתחל את המערך ב-C#:
שימוש במערכת;מערך כיתה
{
ריק סטטי ראשי ( חוּט [ ] args )
{
// אתחול א 1 -מערך ממדי באמצעות Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = new int [ 5 ] ;
מערך. העתק ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'ערכים ב-destinationArray1D:' ) ;
ל ( int i = 0 ; אני < destinationArray1D.Length; i++ ) {
Console.WriteLine ( destinationArray1D [ אני ] ) ;
}
// אתחול א 2 -מערך ממדי באמצעות Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = new int [ 3 , 2 ] ;
מערך. העתק ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'ערכים ב-destinationArray2D:' ) ;
ל ( int i = 0 ; אני < destinationArray2D.GetLength ( 0 ) ; i++ ) {
ל ( int j = 0 ; י < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ אני, י ] ) ;
}
}
}
}
בקוד זה, אנו משתמשים Array.Copy() לאתחל מערך שלם חד מימדי בשם destinationArray1D עם הערכים 1, 2, 3, 4 ו-5 ממערך מקור שנקרא sourceArray1D.
אנחנו גם משתמשים Array.Copy() לאתחל מערך שלם דו מימדי בשם destinationArray2D עם הערכים {1, 2}, {3, 4} ו-{5, 6} ממערך מקור שנקרא sourceArray2D.
לאחר מכן אנו משתמשים בלולאות נוספות כדי לעבור דרך כל אלמנט של כל מערך ולהדפיס את הערך שלו לקונסולה.
סיכום
במאמר זה, חקרנו דרכים שונות לאתחול מערכים ב-C#. כיסינו את תחביר אתחול המערך, באמצעות מילת המפתח החדשה, אתחול מערכים באמצעות לולאות ושימוש בשיטת Array.Copy() . בהתאם למקרה השימוש הספציפי, לכל אחת מהשיטות הללו יש סט יתרונות וחסרונות משלה. היכרות עם הגישות המגוונות הללו תאפשר לך לבחור את אחת המתאימה ביותר לדרישות הספציפיות שלך.