[Powered by Google Translate] בואו נדבר על מערכים.
אז למה שאי פעם אנו רוצים להשתמש במערכים?
ובכן בואו נגיד שיש לך תכנית שזקוקה לאחסון 5 תעודות סטודנט.
זה אולי נראה סביר יש 5 משתנים נפרדים.
מסיבות שנראות בקצת, תתחילו לספור מ 0.
המשתנים שאנחנו נאלץ יהיו id0 int, ID1 int, וכן הלאה.
כל היגיון שאנו רוצים לבצע בתעודת סטודנט יהיה הצורך להעתיק ולהדביק
לכל אחד ממזהי הסטודנטים אלה.
אם אנחנו רוצים לבדוק שתלמידים במקרה בCS50,
אנחנו קודם כל צריכים לבדוק אם id0 מייצג את הסטודנט בקורס.
ואז לעשות את אותו הדבר לתלמיד הבא, תצטרכו להעתיק ולהדביק את הקוד לid0
ולהחליף את כל המופעים של id0 עם ID1 וכן הלאה עבור id2, 3 ו 4.
>> ברגע שאתה שומע שאנחנו צריכים להעתיק ולהדביק,
אתה צריך להתחיל לחשוב שיש פתרון טוב יותר.
עכשיו מה אם אתה מבין שאתה לא צריך 5 מזהי סטודנטים אלא 7?
אתה צריך לחזור לקוד המקור שלך ולהוסיף בid5, id6,
ולהעתיק ולהדביק את ההיגיון לבדיקה אם את המזהים שייכים למעמד עבור 2 תעודות חדשות.
אין שום דבר שהמחבר בין כל התעודות הללו יחד, ולכן אין דרך לשאול
התכנית שתעשה זאת עבור מזהים 0 עד 6.
ובכן עכשיו אתה מבין שיש לך 100 תעודות סטודנט.
זה מתחיל להיראות פחות אידיאלי לצריך להצהיר בנפרד כל אחד ממזהים אלה,
ולהעתיק ולהדביק כל היגיון לתעודות חדשות.
אבל אולי אנו נחושים, ואנחנו עושים את זה לכל 100 התלמידים.
אבל מה אם אתה לא יודע כמה סטודנטים יש דווקא הם?
יש רק כמה סטודנטי n והתכנית שלך יש לשאול את המשתמש מה שn הוא.
אה אה. זה לא הולך לעבודה טובה מאוד.
התכנית שלך עובדת רק עבור חלק מספר קבוע של תלמידים.
>> פתרון כל הבעיות הללו הוא היופי של מערכים.
אז מה הוא מערך?
בחלק משפות תכנות סוג מערך עלול להיות מסוגל לעשות קצת יותר,
אבל כאן אנו נתמקד במבנה נתוני המערך הבסיסי בדיוק כפי שתראה אותו בג
מערך הוא רק גוש גדול של זיכרון. זה הכל.
כאשר אנו אומרים שיש לנו מערך של 10 מספרים שלמים, שרק אומר שיש לנו כמה בלוק
זיכרון שהוא גדול מספיק כדי להחזיק 10 מספרים שלמים נפרדים.
בהנחה שמספר שלם הוא 4 בתים, זה אומר שמערך של 10 מספרים שלמים
הוא בלוק רציף של 40 בתים בזיכרון.
גם כאשר אתה משתמש במערכים רבים ממדים, שאנו לא הולכים לכאן,
זה עדיין רק גוש גדול של זיכרון.
סימון הרב הממדי הוא רק נוחות.
אם יש לך 3 על ידי מערך רב ממדי של מספרים שלמים 3,
אז התכנית שלך תהיה באמת פשוט להתייחס לזה כמו גוש גדול של 36 בתים.
המספר הכולל של מספרים שלמים הוא 3 פעמים 3, וכל המספר שלם תופס 4 בתים.
>> בואו נסתכל על דוגמה בסיסית.
אנחנו יכולים לראות כאן 2 דרכים שונות של מערכים המכריזים.
נצטרך להגיב 1 מתוכם לתכנית להדר
מאז אנו מצהירים x פעמים.
אנחנו נסתכל על כמה מההבדלים בין 2 סוגים אלה של הצהרות בקצת.
שתי שורות אלה להצהיר על מערך של N גודל,
יש לנו שם # define N כמו 10.
אנחנו יכולים בקלות שאלנו את המשתמש למספר חיובי
ומשמש כשלם שמספר האלמנטים במערך שלנו.
רוצה דוגמא תעודת הסטודנט שלנו לפני, זה כמו סוג של הכרזת 10 נפרדים לחלוטין
משתנים דמיוניים; X0, x1, x2, וכן הלאה עד xn-1.
התעלמות מהקווים שבו אנו מצהירים המערך, להבחין בסוגריים המרובעים שלמים
בתוך לולאות.
כאשר אנו כותבים משהו כמו x [3], שאני אקרא רק כx 3 הסוגר
אתה יכול לחשוב על זה כמו לבקש x3 הדמיוני.
שים לב מאשר עם מערך בגודל n, זה אומר שמספר בתוך הסוגריים,
שאנחנו קוראים למדד, יכול להיות כל דבר מ0 עד N-1,
שהנו בסך של מדדי N.
>> לחשוב על איך זה עובד באמת
לזכור שהמערך הוא גוש גדול של זיכרון.
בהנחה שמספר שלם הוא 4 בתים, x המערך כולו הוא בלוק 40 בייט של זיכרון.
אז x0 מתייחס ל4 הבתים הראשונים של השכונה.
X [1] מתייחס ל4 הבתים הבאים וכך הלאה.
משמעות הדבר הוא כי תחילתו של x היא כל התכנית אי פעם צריך לעקוב אחריו.
אם ברצונך להשתמש x [400], ולאחר מכן את התכנית יודעת שזה שווה ערך
רק 1,600 בתים לאחר תחילת x.
איפה ישיג 1,600 בתים מ? זה רק 400 פעמים 4 בתים לכל מספר שלם.
>> לפני שתמשיך, זה מאוד חשוב להבין כי בג
אין אכיפה של המדד שאנו משתמשים במערך.
הבלוק הגדול שלנו הוא ארוך רק 10 מספרים שלמים, אבל שום דבר לא צועק עלינו אם נכתוב X [20]
או אפילו x [-5].
המדד אפילו לא חייב להיות מספר.
זה יכול להיות כל ביטוי שרירותי.
בתכנית אנו משתמשים אני משתנה מלולאה לאינדקס לתוך המערך.
זהו דפוס נפוץ מאוד, המתעקלים מi = 0 עד האורך של המערך,
ואז אני משתמש כמדד למערך.
בדרך זו אתה למעשה לולאה על כל המערך,
ואתה גם יכול להקצות לכל מקום במערך או להשתמש בו לחישוב מסוים.
>> בראשון ללולאה, אני מתחיל ב0,
וכך זה יהיה להקצות ל0 מקום במערך, הערך פעמים 0 2.
אז אני מרווחים, ואנחנו מקצים המקום הראשון במערך 1 פעמי הערך 2.
אז מרווחים שוב וכן הלאה עד שאנו מקצים למצב N-1 במערך
ערך N-1 פעמים 2.
משום כך יצרו מערך עם 10 מספרים הזוגיים הראשונים.
אולי מאזן הייתה שם קצת יותר טובות למשתנים מ-X,
אבל זה היה נותן לי דברים.
השני ללולאה ואז פשוט מדפיס את הערכים שכבר מאוחסנים בתוך המערך.
>> בואו ננסה להפעיל את התכנית בשני הסוגים של הצהרות מערך
ותסתכל בפלט של התכנית.
ככל שאנחנו יכולים לראות, התכנית מתנהגת באותה הצורה לשני הסוגים של הצהרות.
בואו גם להעיף מבט על מה שקורה אם נשנה את הלולאה הראשונה לא לעצור בN
אלא אומר 10,000.
הרבה מעבר לקצה של המערך.
אופס. אולי ראה את זה בעבר.
אשמת פילוח משמעות התכנית שלך התרסקה.
אתה מתחיל לראותם, כשאתה נוגע באזורי הזיכרון אתה לא צריך להיות נוגע.
כאן אנו נוגעים ב10,000 מקומות שמעבר תחילתו של x,
שכנראה הוא מקום בזיכרון, אנחנו לא צריכים להיות נוגעים ללב.
אז רובנו כנראה לא הייתי מכניס את 10000 בטעות במקום N,
אבל מה אם אנחנו עושים משהו עדין יותר כמו כתיבה אומר פחות או שווה ל N
במצב הלולאה לעומת פחות מ נ
זכור כי יש מערך מדדים בין 0 ל N-1 בלבד,
מה שאומר שהמדד N הוא מעבר לסוף המערך.
התכנית אולי לא לקרוס במקרה הזה, אבל זה עדיין שגיאה.
למעשה, טעות זו היא כל כך נפוצה שיש לו שם משלו,
את השגיאות על ידי 1.
>> זהו לדברים הבסיסיים.
אז מה הם ההבדלים העיקריים בין 2 הסוגים של הצהרות מערך?
הבדל אחד הוא שבו הגוש הגדול של זיכרון הולך.
בהצהרה הראשונה, שאני אתקשר סוג הסוגר-מערך,
אם כי זה בהחלט לא שם קונבנציונלי,
זה ילך במחסנית.
ואילו במקרה השני, שבו אני קורא את סוג המצביע-מערך, זה ילך בערימה.
זה אומר שכשאת חוזר לתפקד, מערך הסוגר באופן אוטומטי deallocated,
בעוד כעליך להתקשר חינם באופן מפורש על מערך המצביע
או שיש לך דליפת זיכרון.
בנוסף, מערך הסוגר הוא לא ממש משתנה.
זה חשוב. זה רק סמל.
אתה יכול לחשוב על זה כקבוע שהמהדר בוחר בשבילך.
זה אומר שאנחנו לא יכולים לעשות משהו כמו x + + עם סוג הסוגר
למרות שזה חוקי לחלוטין עם סוג המצביע.
>> סוג המצביע הוא משתנה.
לסוג המצביע, יש לנו 2 בלוקים נפרדים של זיכרון.
משתנה עצמו מאוחסן במחסנית ורק מצביע יחיד,
אבל הגוש הגדול של זיכרון מאוחסן בערימה.
X משתנה על הערימה פשוט שומר את הכתובה
של הגוש הגדול בזיכרון על הערימה.
אחת משמעויות של זה הוא בגודלו של מפעיל.
אם אתה שואל על הגודל של מערך הסוגר, זה ייתן לך את הגודל של הבלוק הגדול של זיכרון,
משהו כמו 40 בתים,
אבל אם אתה שואל על הגודל של סוג המצביע של מערך,
זה ייתן לך את הגודל של x משתנה עצמו, שעל המכשיר הוא סביר רק 4 בתים.
השימוש בסוג המצביע-המערך, אי אפשר ישירות לבקש
גודלו של הגוש הגדול של זיכרון.
זה לא בדרך כלל הרבה יותר מהגבלה מאז שלעתים רחוקות מאוד רוצים את הגודל
של הגוש הגדול של זיכרון, ואנחנו בדרך כלל יכולים לחשב את זה אם אנחנו צריכים אותו.
>> לבסוף, מערך הסוגר קורה לספק לנו קיצור לאתחול מערך.
בואו לראות איך אנחנו יכולים לכתוב את 10 מספרים שלמים אפילו הראשונים באמצעות initilization הקיצור.
עם מערך המצביע, אין דרך לעשות קיצור כזה.
זה רק הקדמה למה שאתה יכול לעשות עם מערכים.
הם מופיעים כמעט בכל תכנית שאתה כותב.
אני מקווה שאתה יכול לראות עכשיו דרך טובה יותר לעשות דוגמא תעודות הסטודנט
מההתחלה של וידאו.
>> השם שלי הוא רוב אודן, וזה CS50.