קורס סי-שארפ - מערך - Array
new והגודל. לדוגמה int[] grades = new int[7]; יוצר שבעה תאים מסוג int.grades[0] = 80.int[] numbers = { 1, 2, 3 };, והגודל נקבע לפי מספר הערכים.grades.Length. כך משנים את גודל המערך במקום אחד בלבד.for (int i = 0; i < grades.Length; i++), ובכל איטרציה ניגשים ל-grades[i].ref. זו ההתנהגות הרגילה, כי מערך יכול להכיל כמות גדולה של נתונים שלא כדאי להעתיק.int, החלוקה מחזירה מספר שלם. לכן ממירים אחד מהם ל-double. בדוגמה ממוצע המספרים 1 עד 10 מניב 5 בלי ההמרה, ו-5.5 עם ההמרה.Console.WriteLine(grades) לא מציג את כל הערכים של המערך. צריך לולאה שמציגה כל תא בנפרד.פרקי ההרצאה: קורס סי-שארפ - מערך - Array
תמלול ההרצאה: קורס סי-שארפ - מערך - Array
הטקסט המלא של הדקות הראשונות בהרצאה «קורס סי-שארפ - מערך - Array» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו עוברים לחומר מאוד חשוב בעולם האלגוריתמיקה. החומר הזה נקרא arrays בעברית מערכים והוא קיים בהמון שפות תכנות. מה זה בעצם אריי?
אריי זה אוסף של תאים שנמצאים בצורה רציפה בזיכרון ואנחנו יכולים בבת אחת להגדיר כמות גדולה של משתנים בזיכרון. למה זה חשוב לנו?
הסיבה היא כי הרבה פעמים קורה שאנחנו רוצים בבת אחת ליצור המון משתנים בזיכרון. בואו ניקח דוגמה. אנחנו רוצים לקבל ציונים של כיתה שלמה ולחשב ממוצע עבור הציונים.
אם לא היה לנו את היכולת להשתמש במערכים היינו צריכים לבצע דבר כזה int grade1.grade2.grade3.grade4 וכו' וכו' וכו' וכו' עד 30. לאחר מכן grade1=console.readline כמובן עטוף בתוך convert to in32 וזה רק קבלה של ציון אחד לאחר מכן היינו צריכים לחזור על זה עבור גרייד 2 ועבור גרייד 3 ועבור גרייד 4
וכולי וכולי וזה רק 30 ציונים מה היה קורה אם היינו רוצים 100 ציונים אז כאן היינו צריכים להגדיר 100 תאים ולאחר מכן 100 שורות קוד רק בשביל לקלוט את הציונים וקצת too much מבחינת תחשבו מה היה קורה אם הייתם רוצים לקלוט 1,000 מניות בבורסה.
אז אנחנו רואים שזה שיש לנו יכולת להגדיר תא זיכרון אחד ויחיד מסוג מסוים זה אחלה, אבל חסר אפשרות להגדרה של כמות גדולה של נתונים. אבל יש לנו פה את הרייז, אז בעזרת הקונספט של הרייז אנחנו יכולים להגדיר בבת אחת כמות גדולה מאוד של משתנים בזיכרון.
בואו נמחק את כל הקוד הזה ונראה איך עושים את זה. אז מה שאנחנו צריכים לעשות פשוט זה להחליט מהו הסוג נתונים של כל אחד מהתאים הרציפים שיש לנו בזיכרון.
נניח שאנחנו רוצים לקלוט מערך ציונים, כל מה שנשאר לנו לעשות זה להחליט שזה אינטג'ר, אבל אם היינו כותבים int grade, אז היה לנו תא זיכרון אחד ויחיד שבו היינו יכולים להכניס ציון אחד ויחיד.
ובכן אנחנו מגדירים את התחביר הבא: int וסוגריים מרובעים. לאחר מכן שם של כל המערך, כאן לא הגיוני שנקרא לו grade, כי grade זה יחיד, יותר הגיוני שנקרא לו grades.
לאחר מכן אנחנו מכניסים לתוכו את המילה new int, כלומר אותו טיפוס, סוגריים מרובעים ואת הגודל. בואו נגיד שאנחנו רוצים לקלוט רק שבעה ציונים.
זה בעצם התחדיר ומה שעשינו כאן זה פתחנו מערך בגודל שבעה תאים. כל תא במערך הוא מסוג אינטג'ר וכל תא במערך יכול להחזיק מספר אחד ויחיד.
ביחד יש לנו פה שבעה מספרים והם רציפים בזיכרון. איך אנחנו מגיעים לתא מסוים בזיכרון? האם זה הגיוני שנבצע grades שווה נניח את הציון 80?
אז הדבר הזה הוא לא הגיוני מפני שהמערכת לא תיקח את המספר 80 ותכניס את המספר הזה לכל התאים בזיכרון. מה שאנחנו צריכים להבין שקורה כאן ושיש לנו שבעה תאים בזיכרון ולכל תא יש מיקום.
תמיד המיקום של התא הראשון הוא 0 ותמיד המיקום של התא האחרון זה גודל המערך, בוא נקרא לזה 7 פחות 1. זאת אומרת שהתא האחרון המיקום שלו זה 6. איך אנחנו ניגשים לתא בודד grades והאינדקס של התא?
כעת אנחנו ניגשנו לתא שהמיקום שלו זה 0, כלומר התא הראשון. מה אפשר לעשות עם תא? כל מה שאפשר לעשות עם משתנה רגיל. מה אפשר לעשות עם משתנה רגיל?
שני דברים: כתיבה אליו או קריאה ממנו זה כל מה שאפשר לעשות עם משתנה ולכן זה כל מה שאפשר לעשות עם תא במערך או שאני מכניס לתוכו ערך או שאני קורא אותו כעת אנחנו יכולים לראות שיש לנו את ה-80 שנמצא רק בתא הראשון במערך בואו נבצע את אותו הדבר על שאר התאים ונניח שיש לנו פה ציונים
ו-90 ו-85 ו-77 יש לנו פה 60 יש לנו פה 99 ונניח שיש לנו פה 100. עכשיו אם אנחנו רוצים להציג את הכל אז יש לנו פה את grades על 0 1 2 3 4 5 ו-6 נריץ ונראה שיש לנו פה את כל הציונים אוקיי אבל אנחנו רואים שגם כאן יש פה המון שורות קוד שכביכול כתבנו והאם אנחנו יכולים בעצם לקצר את כל הסיפור הזה כלומר כן הצלחנו להגדיר בבת אחת שבעה תאים רציפים בזיכרון
והיינו יכולים גם בבת אחת להגדיר שבע מאות תאים רציפים בזיכרון בלי ללכת ולהגדיר אחד אחד בצורה בודדת. אבל האם יש אפשרות את זה לעשות בפחות קוד?
התשובה כן. מה בעצם שונה בין כל שורה? אז מה ששונה בין כל שורה מבחינת הגישה לתא זה האינדקס וכמובן הפריט שאנחנו קולטים.
בוא נניח שאנחנו רוצים לקלוט מהמשתמש את הערכים האלה ולאחר מכן להדפיס את כולם אז במקום לעשות שורה שורה קליטה מהמשתמש שדרך אגב היה אמור להיות convert to in32 של console readline ואת הדבר הזה היינו צריכים לשכפל בצורה כזאת במקום לעשות את זה בצורה כזאת היינו יכולים פשוט ליצור לולה עד 4 כאן i היה מתחיל מ-0 כל עוד i קטן מ-7
כל מה שאנחנו צריכים לעשות grades על i, ש-i מתחלף מ-0 עד 6 ולכן זה חוסך לנו את כל אלה, שווה לקלט מהמשתמש. והנה לולאה אחת שחוסכת לנו את כל הלולאה הזאת, כל הקודים האלה ליתר דיוק. בואו נשים את כל זה בהערה.
מה בקשר לקודים האלה? האם אנחנו יכולים בעזרת לולאה אחת לבצע את ההדפסה? תשובה כמובן, כל מה שאנחנו צריכים לעשות זה console right line, של גריידז על איי ואנחנו יכולים עכשיו לראות שבבת אחת במקום לבצע שורות בודדות אנחנו בעצם מבצעים משהו שנקרא בעולם הפיתוח
סריקת מערך אנחנו רצים מהתא הראשון עד התא האחרון ומבצעים פעולה כלשהי עם כל אחד מהתאים בגלל שהאינדקס בלולאה משתנה ולכן מתייחס כל איטרציה לתא אחר בלולאה כאן אנחנו קולטים לתא אחר במערך ליתר דיוק ערך מהמשתמש כאן אנחנו מדפיסים תא אחר במערך כל פעם בואו נריץ ונראה שאנחנו יכולים עכשיו לקלוט ערכים מהמשתמש
והנה הדפסנו אותם בואו נדפיס את הכל בשורה אחת ובואו נגיד למשתמש כאן enter 7 rates נריץ משתמש רואה הודעה "הכנס שבעה ציונים", מכניס 90, 100, 80, 77, 98, 95 ובוא נניח גם 89. עכשיו אנחנו רואים את
כל הפריטים מוצגים לו. אנחנו כמובן שומרים את כל הערכים האלה במערך ויכולים לעשות פעולות נוספות להציג את המקסימלית, המינימלית, הממוצע, ותכף נראה איך אנחנו יכולים לבצע זאת.
עכשיו בואו נראה מבחינה סכמטית מה בעצם נפתח בזיכרון? לצורך כך בואו נדגים את זה בעזרת מסמך פשוט. נניח שאנחנו פותחים את המערך הזה בזיכרון וקראנו לו grades.
מה בעצם נפתח לנו בזיכרון? אז אפשר לצייר את זה כאילו שזה מעין טבלה חד-ממדית. זה בעצם מערך חד-ממדי. אנחנו פתחנו טבלה בגודל 7, אז יש לנו 0, 1, 2, 3, 4, 5, 6 תאים.
אוקיי, מה בעצם קורה כאן? נגדיר כאן מעין רווחים כדי שנוכל להגדיר כאן אינדקסים עבור הטבלה. טוב, אז נפתח לנו סדרה נפתחה סדרה של שבעה תאים בזיכרון כאשר לכל תא יש מיקום.
מיקום נקרא אינדקס. המיקום של התא הראשון הוא תמיד 0 תא השני 1 שלישי 2 שימו לב שנהוג לצייר את זה בצורה כזאת סדרה של תאים והאינדקסים מתחתיהם.
כאן יש לנו תא עם אינדקס מספר 4, תא עם אינדקס מספר 5, תא עם אינדקס מספר 6. ואם אנחנו עכשיו בתוכנית כותבים את הדבר הבא, grades במיקום, בוא נניח 3, שווה 90, המחשב ברגע שהוא מגיע לפקודה הזאת אומר דבר כזה:
grades זה כל המערך, זה כל מה שאתם רואים כאן, מיקום 3 זה רק התא שהאינדקס שלו הוא 3. אני לתוכו מכניס 90. בואו נשים את זה קצת יותר אסתטי, נראה בצורה כזאת, ויש לנו 90 בתוך התא שהאינדקס שלו הוא 3.
אם לאחר מכן אנחנו מבצעים console.write rates במיקום 3, אז מה שפישר פה עושה זה שוב פונה למיקום מספר 3 במערך ולוקחת את הערך, כורת אותו.
מה עושים אותו? במקרה הזה מדפיסים אותו. אם אנחנו מבצעים int num שווה grades על 3 זה גם כן פקודה שכורת את הערך שנמצא במיקום 3 כלומר את ה-90 ומכניסה אותו לתוך num אם אנחנו כותבים grades על 0 שווה 80 בעצם הכנסנו 80 לתא הזה אם אנחנו כותבים grades על 6 אנחנו בעצם מכניסים ערך לתא האחרון במקרה הזה 79, נכנס לפה, 79. ככה אתם רואים שיש לנו
יכולת להשתמש בכל אחד מהתאים של המערך בצורה נפרדת. אין לנו יכולת להשתמש עם כולם בבת אחת. זאת אומרת, אנחנו לא יכולים לבצע console.write ולהדפיס grades בצורה כזו.
הדבר הזה לא תופס. אם אנחנו רוצים להתייחס לתא, חובה להתייחס לתא אחד ויחיד בכל פעם במערך. לדוגמה, במקרה הזה פנינו לתא שהאינדקס שלו 3, קראנו ממנו את הערך.
במקרה הזה פנינו לתא שהאינדקס שלו הוא 3, נכנסנו לתוכו הערך. אם אנחנו רוצים בבת אחת לסרוק את כל המערך, זה ראינו בעזרת לולאה. אז מה נותן לנו מערך?
מערך נותן לנו את היכולת להגדיר בבת אחת את כל התאים האלה, בבת אחת סדרה רציפה של תאים בזיכרון, נותן לנו אפשרות לגשת לתא על ידי ציון האינדקס שלו, בגלל זה אנחנו יכולים בעזרת לולאה לבצע סריקה בעזרת לולאה פשוטה עם שורת קוד אחת של כל התאים במערך ולבצע איתם פעולה כלשהי לדוגמה
לכתוב לכולם בבת אחת או לקרוא מכולם בבת אחת כמובן זה מתבצע שלב שלב בלולאה אז זה בעצם הקונספט של מערכים והיכולת שלנו להגדיר בבת אחת את כל התאים בזיכרון ומה שהיה חשוב לראות בסרטוט הזה זה מה בעצם נראה בזיכרון מבחינת התאים עצמם אם אנחנו חוזרים לפה אנחנו רואים שכעת אנחנו יכולים להיפטר מכל השורות האלה, מיותרות לגמרי,
ובעזרת קוד פשוט יצרנו כמות גדולה של תאים. עכשיו, מה קורה אם אנחנו רוצים פתאום להתחרט ולהגיד רגע, שבעה תאים זה לא מספיק לנו, אנחנו רוצים עשרה תאים. האם התוכנית הזאת פתחה לנו מערך בגודל עשרה תאים?
התשובה כן, אבל האם התוכנית טובה לנו כרגע? וכמובן התשובה לא. קודם כל אנחנו רואים enter seven numbers, את זה אנחנו צריכים לשנות.
כל פעם בלולאה אנחנו רצים רק עד 7 וגם אנחנו צריכים לשנות את זה עכשיו. אז בשביל לא לבצע יותר מדי שינויים אם ביצענו שינוי בגודל של המערך, אנחנו צריכים לא להתייחס יותר לגודל שלו בצורה של Hardcoded.
יש לנו אפשרות להגיע לגודל של המערך על ידי grades.length.length.length זה בעצם אורך המערך.