‫‪1‬‬
‫מערכים ומחרוזות תווים‬
‫הגדרה של מערך פשוט‬
‫שימוש במערך פשוט‬
‫מערך של אובייקטים‬
‫מערך דו ממדי‬
‫המחלקה ‪Array‬‬
‫המחלקה ‪String‬‬
‫שרשור של מחרוזות תווים‬
‫המחלקה ‪StringBuilder‬‬
‫‪© 2009 Haim Michael‬‬
‫‪2‬‬
‫הגדרה של מערך פשוט‬
‫מערך הוא מבנה נתונים פשוט אשר כולל מספר סופי של אלמנטים מטיפוס זהה‪ .‬כדי ליצור מערך יש תחילה להצהיר על‬
‫המשתנה שיחזיק בתוכו את ה‪ reference-‬למערך )המערך הוא אובייקט(‪.‬‬
‫;‪Type [ ] var_name‬‬
‫לדוגמא‪:‬‬
‫;‪int [ ] vec‬‬
‫כדי לייצור מערך )כדי לקבל ‪ reference‬לאובייקט שהוא מערך( יש להשתמש ב‪ new-‬באופן הבא‪:‬‬
‫;]‪var_name = new type_name[array_size‬‬
‫לדוגמא‪:‬‬
‫;]‪vec = new int[10‬‬
‫לאחר שהמערך נוצר ניתן להשתמש בו‪ .‬את גודל המערך לא ניתן לשנות‪.‬‬
‫ניתן בשורת קוד אחת גם להצהיר על המשתנה אשר יחזיק ב‪ reference-‬למערך וגם לייצור את המערך עצמו ולהכניס‬
‫את ה‪ reference-‬שלו אל תוך המשתנה‪.‬‬
‫;]‪type_name [ ] var_name = new type_name[10‬‬
‫לדוגמה‪:‬‬
‫;]‪int [] vec = new int[10‬‬
‫‪© 2009 Haim Michael‬‬
‫‪3‬‬
‫ניתן בשורה אחת גם לייצור את המשתנה שיחזיק ב‪ reference-‬למערך‪ ,‬גם לייצור את המערך וגם לאתחל אותו‪.‬‬
‫;}‪type_name[] var_name = new type_name[array_size] {value, value... vaelu‬‬
‫לדוגמה‪:‬‬
‫;}‪int vec[] = new int[5] {23,53,112,22,3‬‬
‫ניתן לבצע את אותה פעולה בכתיב מקוצר באופן הבא‪:‬‬
‫;}‪new int[] {23,53,112,22,3‬‬
‫= ][‪int vec‬‬
‫ניתן אף לכתוב זאת באופן הבא‪:‬‬
‫;}‪int vec[] = {23,53,112,22,3‬‬
‫‪© 2009 Haim Michael‬‬
‫‪4‬‬
‫שימוש במערך פשוט‬
‫השימוש במערך ב‪ C#-‬דומה לאופן השימוש בשפות התכנות האחרות‪ .‬באמצעות מספר האינדקס אשר יירשם בתוך‬
‫הסוגריים המרובעות נוכל לקבל את הערך אשר נמצא בתא מסוים במערך או‪ ,‬לחלופין‪ ,‬להכניס ערך מסוים לתא מסוים‬
‫במערך‪ .‬מספרי האינדקס מתחילים ב‪.0-‬‬
‫‪int[] vec = new int[4]{4,23,55,21};int numA = vec[0]; //first element‬‬
‫‪int numB = vec[1]; //accessing second element‬‬
‫‪vec[2] = numA+numB; //accessing third element‬‬
‫ניסיון לגשת לתא במערך באמצעות מספר אינדקס אשר מצביע אל מחוץ לגבולות המערך יגרום לכך שייזרק‬
‫‪.ArrayIndexOutOfRangeException‬‬
‫בכל מערך קיים ‪ property‬ששמו ‪ Length‬אשר מחזיק את מספר התאים )גודל המערך(‪ .‬באמצעותו ניתן לכתוב קוד‬
‫יותר יעיל‪.‬‬
‫;}‪int[] vec={2,4,12,54‬‬
‫)‪for(int i=0; i<vec.Length; i++‬‬
‫{‬
‫;)]‪Console.WriteLine(vec[i‬‬
‫}‬
‫כאשר עובדים עם מערכים ניתן להשתמש בלולאה ‪ foreach‬ובאמצעותה לעבור על כל איברי המערך‪.‬‬
‫;}‪int[] vec={2,4,12,54‬‬
‫)‪foreach(int number in vec‬‬
‫{‬
‫;)‪Console.WriteLine(number‬‬
‫}‬
‫‪© 2009 Haim Michael‬‬
‫‪5‬‬
‫מערך של אובייקטים‬
‫מערך של אובייקטים הוא‪ ,‬למעשה‪ ,‬מערך של ‪ references‬לאובייקטים‪ .‬אופן ההגדרה שלו דומה להגדרה של מערך של‬
‫ערכים פשוטים‪ .‬כל תא במערך של אובייקטים יכול להכיל או ‪ reference‬לאובייקט או ‪.null‬‬
‫{]‪Rectangle[] recs = new Rectangle[3‬‬
‫‪new Rectangle(4,3),‬‬
‫‪new Rectangle(2,4),‬‬
‫)‪new Rectangle(1,3‬‬
‫;}‬
‫את המערך שנוצר בקטע קוד זה ניתן לתאר באופן הבא‪:‬‬
‫‪FE1212‬‬
‫‪vec‬‬
‫‪FE1212‬‬
‫‪D22A A42E‬‬
‫‪F232‬‬
‫‪A42E‬‬
‫‪F232‬‬
‫‪1‬‬
‫‪width‬‬
‫‪2‬‬
‫‪width‬‬
‫‪3‬‬
‫‪height‬‬
‫‪4‬‬
‫‪height‬‬
‫‪© 2009 Haim Michael‬‬
‫‪D22A‬‬
‫‪width 4‬‬
‫‪3‬‬
‫‪height‬‬
6
.‫להלן דוגמת קוד אשר מציגה את יצירתו של מערך של אובייקטים‬
using System;
namespace abelski.samples
{
public class RectanglesArrayDemo
{
public static void Main()
{
Rectangle[] vec;
vec = new Rectangle[3];
vec[0] = new Rectangle(4,3);
vec[1] = new Rectangle(2,4);
vec[2] = new Rectangle(1,3);
foreach(Rectangle rec in vec)
{
Console.WriteLine(rec);
}
}
}
public abstract class Shape
{
public abstract double Area();
}
public class Rectangle : Shape
{
private double width,height;
public Rectangle()
{
width=10;
height=10;
}
public Rectangle(double val)
{
width = val;
height = val;
}
public Rectangle(double val1, double val2)
{
width = val1;
height = val2;
}
public override double Area()
{
return width*height;
}
© 2009 Haim Michael
7
public double Width {get; set;}
public double Height {get; set;}
public override String ToString()
{
return "width="+width+" height="+height;
}
}
}
.‫להלן הפלט שיתקבל‬
© 2009 Haim Michael
‫‪8‬‬
‫מערך דו ממדי‬
‫כדי להצהיר על משתנה אשר יוכל להחזיק ב‪ reference-‬למערך דו ממדי יש להוסיף פסיק אל תוך הסוגריים המרובעות‬
‫שאני מוסיפים מימין לשם ה‪ type-‬אשר יהיה ה‪ type-‬של כל אחד מהתאים במערך‪.‬‬
‫;‪int [,] matrix‬‬
‫כאשר יוצרים אובייקט שהוא מערך דו ממדי יש להוסיף פסיק אל תוך הסוגריים המרובעות שמוסיפים בהמשך להפעלת‬
‫הפקודה ‪ new‬ולציין מימין ומשמאל לפסיק את הממדים של המערך שרוצים לייצור‪.‬‬
‫;]‪matrix = new int[4,3‬‬
‫בדוגמה זו נוצר מערך דו ממדי בעל ‪ 4‬שורות ו‪ 3-‬עמודות‪ .‬ניתן באופן דומה ליצור מערכים בממדים גדולים יותר‪.‬‬
‫אופן השימוש במערך דו ממדי ב‪ C#-‬דומה לאופן השימוש המקובל בשפות תכנות אחרות‪ .‬כדי לגשת לתא מסוים במערך‬
‫יש לציין בתוך הסוגריים המרובעות את מספר השורה ואת מספר העמודה של התא שאליו רוצים לגשת‪.‬‬
‫;]‪int[,] matrix = new int[3,3‬‬
‫;‪matrix[0,0] = 1‬‬
‫;‪matrix[0,1] = 2‬‬
‫;‪matrix[0,2] = 3‬‬
‫;‪matrix[1,0] = 4‬‬
‫;‪matrix[1,1] = 5‬‬
‫;‪matrix[1,2] = 6‬‬
‫;‪matrix[2,0] = 7‬‬
‫;‪matrix[2,1] = 8‬‬
‫;‪matrix[2,2] = 9‬‬
‫בדוגמה זו ניתן לראות כיצד מוכנס הערך ‪ 1‬אל תוך התא הראשון בשורה הראשונה‪ ,‬כיצד מוכנס הערך ‪ 2‬אל תוך התא‬
‫השני בשורה הראשונה‪ ,‬כיצד מוכנס הערך ‪ 3‬אל תוך התא השלישי בשורה הראשונה וכו'‪.‬‬
‫‪© 2009 Haim Michael‬‬
‫‪9‬‬
‫ניתן ליצור מערך דו ממדי ולאתחל אותו גם בכתיב המקוצר הבא‪:‬‬
‫= ‪int [,] matrix‬‬
‫{‬
‫‪{1,2,3},‬‬
‫‪{4,5,6},‬‬
‫}‪{7,8,9‬‬
‫;}‬
‫ניתן להוסיף פסיקים נוספים כדי ליצור מערך בעל מספר ממדים גדול יותר‪.‬‬
‫דרך נוספת ליצירת מערך דו ממדי ב‪ C#-‬כוללת את יצירתו של מערך אשר בכל אחד מתאיו יוכל להכיל ‪reference‬‬
‫למערך פשוט‪ .‬כדי לעשות זאת‪ ,‬יש תחילה להצהיר על משתנה אשר יוכל להחזיק בתוכו ‪ reference‬למערך חד ממדי‬
‫רגיל שבכל אחד מתאיו ניתן להכיל ‪ reference‬למערך אחר‪ .‬כדי להצהיר על משתנה כגון זה‪ ,‬אשר יוכל להכיל‬
‫‪ reference‬למערך שבכל אחד מתאיו ניתן יהיה להכיל ‪ reference‬למערך אחר שכל אחד מתאיו יכול להכיל ערך מ‪type-‬‬
‫מסוים‪ ,‬יש להוסיף צמד סוגריים מרובעות נוסף ל‪ type-‬המצוין‪.‬‬
‫;‪int [][] matrix‬‬
‫בשורה זו נוצר משתנה בשם ‪ matrix‬אשר יוכל להכיל בתוכו ‪ reference‬למערך אשר כל אחד מתאיו יוכל להכיל בתוכו‬
‫‪ reference‬למערך אחר שכל אחד מתאיו יכול להכיל ערך מסוג ‪ .int‬כדי ליצור אובייקט שהוא מערך אשר כל אחד מתאיו‬
‫יכול להכיל ‪ reference‬למערך רגיל יש להוסיף זוג סוגריים מרובעות באופן הבא‪:‬‬
‫;][]‪matrix = new int[3‬‬
‫בשורה זו נוצר אובייקט חדש שהוא מערך בגודל ‪ 3‬ושבכל אחד מתאיו ניתן להכיל ‪ reference‬למערך רגיל של ערכים‬
‫מסוג ‪ .int‬כעת יש ליצור את המערכים שה‪ references-‬שלהם יושמו אל תוך כל אחד משלושת התאים של המערך‬
‫שיצרנו‪ .‬ניתן לעשות זאת באופן הבא‪:‬‬
‫;}‪matrix[0] = new int[2] {1,2‬‬
‫;}‪matrix[1] = new int[3] {4,5,6‬‬
‫;}‪matrix[2] = new int[5] {5,4,3,2,1‬‬
‫‪© 2009 Haim Michael‬‬
10
.‫ הדוגמה הבאה מציגה זאת‬.‫את ערכיי המערך הדו ממדי שהתקבל ניתן לקבל באמצעות לולאות מכוננות‬
using System;
namespace abelski.samples
{
public class JaggedArrayDemo
{
public static void Main()
{
Rectangle[][] matrix;
matrix = new Rectangle[3][];
matrix[0] = new Rectangle[2]
{
new Rectangle(4,3),
new Rectangle(2,2)
matrix[1] = new Rectangle[3]
{
new Rectangle(4,3),
new Rectangle(2,4),
new Rectangle(3,3)
};
};
matrix[2] = new Rectangle[1]
{
new Rectangle(1,2)
}
foreach(Rectangle[] array in matrix)
{
foreach(Rectangle rec in array)
{
Console.WriteLine(rec);
}
}
}
public abstract class Shape
{
}
public abstract double area();
public class Rectangle : Shape
{
private double width,height;
public Rectangle()
{
width=10;
height=10;
© 2009 Haim Michael
};
11
}
public Rectangle(double val)
{
width = val;
height = val;
}
public Rectangle(double val1, double val2)
{
width = val1;
height = val2;
}
public override double Area()
{
return width*height;
}
public double Width {get; set;}
public double Height {get; set;}
public override String ToString()
{
return "width="+width+" height="+height;
}
}
}
.‫להלן הפלט שנקבל‬
© 2009 Haim Michael
‫‪12‬‬
‫המחלקה ‪Array‬‬
‫כאשר אנו יוצרים אובייקט שהוא מערך‪ ,‬האובייקט שמתקבל נוצר למעשה ממחלקה אשר יורשת מהמחלקה‬
‫האבסטרקטית ‪ .Array‬מסיבה זו‪ ,‬ניתן למצוא בכל מערך שאנו יוצרים את כל אחד מה‪ properties-‬וה‪ methods-‬שניתן‬
‫למצוא במחלקה ‪ .Array‬אחד ה‪ properties-‬השימושיים שניתן להשתמש בו הוא ‪ ,Length‬אשר מחזיק בגודלו של‬
‫המערך‪ .‬באמצעות ‪ property‬זה ניתן לכתוב קוד יותר יעיל אשר יעבוד היטב בכל מקרה‪ .‬במחלקה ‪ Array‬ניתן גם למצוא‬
‫את המתודה הסטטית ‪ CreateInstance‬אשר מאפשרת לנו דרך נוספת ליצירת מערך חדש‪ .‬דוגמת הקוד הבאה מציגה‬
‫זאת‪.‬‬
‫‪...‬‬
‫;)‪var vec = Array.CreateInstance(typeof(int),4‬‬
‫)‪for (int i=0; i<vec.Length; i++‬‬
‫{‬
‫;)‪vec.SetValue((i*i),i‬‬
‫}‬
‫;‪int[] numbers = (int[])vec‬‬
‫‪...‬‬
‫בשורה האחרונה אנו מבצעים ‪ casting‬ל‪ type-‬של ה‪ reference-‬אשר נמצא בתוך המשתנה ‪ vec‬מ‪ Object-‬ל‪type-‬‬
‫המדויק של המערך שנוצר‪ .‬ה‪ reference-‬ש‪ vec-‬מכיל הוא מה‪ type-‬שצוין בהגדרתה של המתודה ‪ CreateInstace‬כפי‬
‫שהוגדרה במחלקה ‪) Array‬ה‪ type-‬ששמו ‪.(Object‬‬
‫‪© 2009 Haim Michael‬‬
13
String ‫המחלקה‬
.System ‫ ששמו‬namespace-‫ מחלקה זו שייכת ל‬.String ‫כל מחרוזת תווים מתוארת באמצעות אובייקט מהמחלקה‬
System.String ‫ במקום לרשום‬.System.String-‫ אשר מהווה קיצור ל‬keyword-‫ כ‬string ‫ כוללת את‬C# ‫שפת התיכנות‬
.string ‫ניתן פשוט לרשום‬
‫ והן‬string ‫ שמוגדרים במחלקה‬constructors-‫ ניתן לייצור הן באמצעות הפעלת אחד ה‬string ‫אובייקט מטיפוס‬
.‫ דוגמת הקוד הבאה מציגה זאת‬.string ‫באמצעות כתיבת מחרוזת התווים שאנו רוצים שתיוצג על ידי אובייקט מטיפוס‬
using System;
using System.Collections;
namespace abelski.samples
{
public class SimpleStringDemo
{
public static void Main()
{
System.String strA = "abc";
string strB = "abc";
Console.WriteLine(strA);
Console.WriteLine(strB);
}
}
}
:‫הפלט שנקבל הוא‬
© 2009 Haim Michael
‫‪14‬‬
‫שרשור של מחרוזות תווים‬
‫ניתן לשרשר מחרוזות תווים אחת לשנייה באמצעות האופרטור ‪ +‬באופן הבא‪:‬‬
‫;”‪string name = “mike‬‬
‫;”‪string str = name + “ goes home‬‬
‫באמצעות הוספת התו '@' למחרוזת התווים שאנו יוצרים נוכל לפרוש אותה על פני יותר משורה אחת ונוכל לכלול בתוכה‬
‫לוכסנים הפוכים מבלי לדאוג שמא הם יפורשו כסימנים בעלי משמעות מיוחדת )כגון‪.('\n' :‬‬
‫;”‪string str = @”c:\temp\docs‬‬
‫‪© 2009 Haim Michael‬‬
‫‪15‬‬
‫המחלקה ‪StringBuilder‬‬
‫את הטקסט שמייצג אובייקט מסוג ‪ String‬לא ניתן לשנות‪ .‬כאשר משרשרים מחרוזת תווים אחת עם מחרוזת תווים‬
‫אחרת מקבלים אובייקט חדש אשר מייצג מחרוזת תווים חדשה‪ .‬כאשר מבצעים שרשור של מחרוזות תווים תוך כדי‬
‫פעולתה של לולאה נוצרים אובייקטים חדשים רבים‪ .‬יצירה של אובייקטים רבים פוגעת בביצועים של התכנית‪ .‬ניתן‬
‫להתמודד על בעייתיות זו באמצעות יצירת אובייקט מטיפוס ‪ StringBuilder‬אשר מייצג מחרוזת תווים אשר כן‬
‫ניתנת לשינוי‪ .‬שימוש ב‪ StringBuilder-‬במקום שרשור של מחרוזות תווים שונות אחת לשנייה ישפר את ביצועי‬
‫התכנית‪.‬‬
‫דוגמת הקוד הבאה מציגה זאת‪.‬‬
‫;‪using System‬‬
‫;‪using System.Text‬‬
‫‪namespace abelski.samples‬‬
‫{‬
‫‪public class StringBuilderDemo‬‬
‫{‬
‫)(‪public static void Main‬‬
‫{‬
‫;)‪StringBuilder builder = new StringBuilder("23408",100‬‬
‫;)"‪builder.Append("0923492-3942-34‬‬
‫;)"‪builder.Append("823-9324234‬‬
‫;)"‪builder.Insert(4,"XYZ‬‬
‫;)'_'‪builder.Replace('-',‬‬
‫;))(‪Console.WriteLine(builder.ToString‬‬
‫}‬
‫}‬
‫}‬
‫‪© 2009 Haim Michael‬‬
‫‪16‬‬
‫הפלט שנקבל הוא‪:‬‬
‫‪© 2009 Haim Michael‬‬