>> [השמעת מוסיקה]
דאג LLOYD: בסדר.
עבודה עם אחד משתנים הוא די כיף.
אבל מה אם אנחנו רוצים לעבוד עם הרבה משתנה,
אבל אנחנו לא רוצים שיהיו לי חבורה של שמות שונים עפים הקוד שלנו?
במקרה זה, הם מערכים הולך לבוא בבאמת שימושי.
מערכים הם נתונים באמת בסיסיים מבנה לכל שפת תכנות
שבו ישתמש.
והם באמת, באמת שימושיים, במיוחד, כפי שאנו תראו, ב -50 CS.
>> אנו משתמשים במערכים להחזיק ערכים מאותו סוג נתונים
במקומות זיכרון רציפים.
כלומר, זה דרך שנוכל קבוצה
חבורה של מספרים שלמים ביחד ב זיכרון או חבורה של דמויות
או צף בזיכרון באמת לסגור ביחד ועבודה
עם אותם מבלי לתת לכל שם אחד ייחודי משלו, שיכול
לקבל מסורבל לאחר זמן קצר.
>> עכשיו, דרך אחת להקיש מערכים הוא לחשוב על הפוסט המקומי שלך
משרד לשנייה.
אז להתרחק מתכנות ורק לעצום את העיניים שלך
ולדמיין בראש שלך סניף הדואר המקומי שלך.
בדרך כלל, ברוב הפוסט משרדים, יש בנק גדול
תיבות דואר על הקיר.
>> מערך הוא גוש ענק של זיכרון רציף,
באותו אופן שדואר בנק בסניף הדואר שלך
חלל גדול ב קיר של סניף הדואר.
מערכים כבר מחולקים לקטנים, זהה בלוקים בגודל של שטח,
כל אחד מהם נקרא אלמנט, ב באותו אופן שבו הקיר של הפוסט
משרד כבר מחולק לקטן, זהה בלוקים בגודל של שטח,
שאנו מכנים תיבת דואר.
של המערך כל אלמנט יכול לאחסן כמות מסוימת של נתונים,
בדיוק כמו כל תיבת דואר יכולה להחזיק כמות מסוימת של דואר.
>> מה יכול להיות מאוחסן בכל רכיב של המערך הוא משתנים של אותם נתונים
סוג, כגון int או char, רק כמו בתיבת הדואר שלך,
אתה יכול רק להתאים דברים מסוג דומה,
כגון מכתבים או חבילות קטנות.
לבסוף, אנו יכולים לגשת לכל אלמנט של המערך ישירות על ידי מספר אינדקס,
בדיוק כפי שאנו יכולים לגשת לסניף הדואר שלנו תיבה על ידי לדעת מספר תיבת הדואר שלה.
יש לקוות, כי אנלוגיה עוזר לך לקבל את הראש שלך
סביב הרעיון של מערכים על ידי אנלוגיה למשהו אחר
כי אתה כנראה כבר מכיר.
>> ב- C, האלמנטים של מערך הם האינדקס מתחיל מ -0, לא מ1.
וזה באמת חשוב.
ולמעשה, זו הסיבה שאנחנו, ב -50 CS, ומדעני מחשב לעתים קרובות למה
יספור מ -0, הוא בגלל המערך של C
אינדקס, שתמיד מתחיל ב 0.
אז אם מערך מורכב מאלמנטי n, האלמנט הראשון של מערך ש
ממוקם במדד 0, ו האלמנט האחרון של המערך
ממוקם בn מדד מינוס 1.
שוב, אם יש אלמנטי n בנו מערך, המדד האחרון הוא n מינוס 1.
>> אז אם יש לנו מערך של 50 אלמנטים, האלמנט ראשון ממוקם במדד 0,
והאלמנט האחרון ממוקם במדד 49.
לרוע המזל, או למרבה המזל, בהתאם לנקודת המבט שלך,
C הוא מאוד מקל כאן.
זה לא ימנע ממך הולך מחוץ לתחום של המערך שלך.
אתה יכול לגשת למינוס 3 אלמנט של המערך שלך
או אלמנט ה -59 של המערך שלך, אם המערך שלך יש רק 50 אלמנטים.
זה לא יעצור את התכנית שלך מ קומפילציה, אבל בזמן הריצה,
אתה עשוי להיתקל אשמת פילוח מפחידה
אם אתה מתחיל לגשת לזיכרון שנמצא מחוץ לגבולות של מה
שאל את התכנית שלך לתת לך.
אז אל יהיה זהיר.
>> מה עושה מערך הכרזה נראה?
איך קוד מערך לקיום כמו שאנחנו קוד כל משתנה אחרים?
ישנם שלושה חלקים למערך declaration-- סוג, שם,
וגודל.
זה דומה מאוד ל הצהרה משתנה, ש
הוא רק סוג ושם, להיות אלמנט הגודל
המקרה המיוחד למערך, כי אנחנו מקבלים חבורה שלהם
באותו הזמן.
>> אז הסוג הוא איזה סוג של משתנה רוצה כל אלמנט של המערך להיות.
רוצה את זה למערך של מספרים שלמים?
ואז, סוג הנתונים שלך צריך להיות int.
האם אתה רוצה שזה יהיה מערך של זוגות או צף?
סוג הנתונים צריך להיות כפול או לצוף.
שם זה מה שאתה רוצה לקרוא למערך שלך.
מה אתה רוצה שם זה ענק בנק של מספרים שלמים או צף או תווים
או זוגות, או מה שיש לך?
מה אתה רוצה לקרוא לזה?
די מסביר עצמי.
>> לבסוף, גודל, אשר הולך בתוך סוגריים מרובעים,
הוא כמה אלמנטים שהיית כמו המערך שלך להכיל.
כמה מספרים שלמים אתה רוצה?
כמה צף אתה רוצה?
>> כך למשל, int ציוני סטודנט 40.
זה מגדיר מערך בשם סטודנטים ציונים, אשר מורכב 40 מספרים שלמים.
די מסביר עצמי, אני מקווה.
הנה דוגמא נוספת.
מחירי תפריט זוגיים 8.
זה יוצר מערך בשם מחירי תפריט, אשר מורכב
של חדר בזיכרון לשמונה זוגות.
>> אם אתה חושב על כל אלמנט מערך של טיפוס נתונים מסוג,
כך למשל, אלמנט יחיד של מערך של int הסוג, באותו אופן ש
יחשוב על כל דבר אחר משתנה מסוג int,
כל הפעולות שאנחנו מכירים דן בעבר בתפעול
וידאו יהיה הגיוני.
אז הנה, אנחנו יכולים להצהיר על מערך של Booleans נקרא Truthtable,
אשר מורכב מחדר למשך 10 Booleans.
>> ואז, בדיוק כמו שאנחנו יכולים פשוט להקצות ערך לכל משתנה אחרים מהסוג
בוליאנית, אנחנו יכולים לומר משהו כמו הסוגר מרובע Truthtable
2, אשר הוא איך אנחנו מצביעים, שאלמנט של טבלת האמת?
המרכיב השלישי של טבלת אמת, כי יזכור,
אנחנו סופרים מ0.
אז ככה אנחנו מצביעים מרכיב שלישי של טבלת האמת.
Truthtable 2 שווה שווא, בדיוק כמו שאנחנו יכולים declare--
או שאנחנו יכולים להקצות, ולא, כל משתנים מסוג בוליאני ככוזב.
>> כמו כן, אנו יכולים להשתמש בו בתנאים.
אם (7 == truthtable אמיתי), כלומר,
אם האלמנט השמיני של Truthtable נכון,
אולי אנחנו רוצים להדפיס הודעה למשתמש, printf ("n נכון!") ;.
שגורם לנו לומר Truthtable 10 שווים אמיתיים, נכון?
ובכן, אני יכול, אבל זה די מסוכן, כי תזכור,
יש לנו מערך של 10 Booleans.
אז המדד הגבוה ביותר ש מהדר נתן לנו הוא 9.
>> תכנית זו תהיה לקמפל, אבל אם משהו בזיכרון אחר
קיים בו אנחנו הייתם מצפה Truthtable 10 ללכת,
אנחנו יכולים לסבול אשמת פילוח. אנחנו אולי לצאת מזה, אבל באופן כללי,
די מסוכן.
אז מה אני עושה כאן הוא C המשפטי, אך לא בהכרח הצעד הטוב ביותר.
עכשיו, כשאתה מצהיר ו לאתחל מערך בו זמנית,
יש למעשה די תחביר מיוחד ש
יכול להשתמש בו כדי למלא את המערך עם ערכי ההתחלה שלה.
זה יכול להגיע למסורבל להצהיר על מערך בגודל 100,
ואז יש לי לומר, אלמנט 0 שווה את זה; אלמנט 1 שווה זה;
אלמנט 2 שווה את זה.
מה הטעם, נכון?
>> אם זה מערך קטן, יכול לעשות משהו כזה.
בול truthtable 3 שווה פתוח סד מתולתל ולאחר מכן פסיק
להפריד את הרשימה של אלמנטים שאתה רוצה לשים במערך.
ואז לסגור פסיק סד מתולתל.
זה יוצר מערך של גודל שלושה נקראים Truthtable,
עם אלמנטי שווא, נכון, ואמיתי.
ואכן, המופע תחביר יש לי כאן הוא
בדיוק כמו עושה תחביר מרכיב בודד בהמשך.
שתי דרכים אלה של קידוד היית לייצר בדיוק את אותו המערך.
>> כמו כן, אנו יכולים לחזר על כל האלמנטים
של מערך באמצעות לולאה, אשר, ב למעשה, הוא מומלץ מאוד מאוד
תרגיל בבית.
איך אתה יוצר מערך של 100 מספרים שלמים, שבו
כל אלמנט של המערך הוא המדד שלה?
כך למשל, יש לנו מערך של 100 מספרים שלמים, ובאלמנט הראשון,
אנחנו רוצים לשים 0.
במרכיב השני, אנחנו רוצים לשים 1.
באלמנט השלישי, אנחנו רוצים לשים 2; וכן הלאה וכן הלאה.
זה ממש טוב בבית התרגיל לעשות את זה.
>> הנה, זה לא נראה כמו גם הרבה השתנה.
אבל שם לב שבבין סוגריים מרובעים, זה זמן,
למעשה אני כבר השמטתי את המספר.
אם אתה משתמש בזה מאוד מופע מיוחד
תחביר כדי ליצור מערך, שאתה עושה בעצם לא
צריך לציין את הגודל של המערך מראש.
מהדר הוא מספיק חכם לדעת שאתה באמת
רוצה מערך של גודל 3, כי אתה שם את שלושה אלמנטים
בצד הימין של סימן השוויון.
אם הכניס ארבעה, תהיה לו נתתי לך טבלת אמת של גודל ארבעה;
וכן הלאה וכן הלאה.
>> מערכים אינם מוגבלים ליחיד ממד, וזה די מגניב.
למעשה אתה יכול לקבל כמה שיותר מצייני צד כרצונך.
כך למשל, אם ברצונך ליצור לוח למשחק צוללות, אשר,
אם אי פעם שיחקת, הוא משחק שהוא שיחק עם יתדות על 10 ב -10 רשת,
אתה יכול ליצור מערך כזה.
אפשר לומר בול כיכר תושבת קרב 10
כיכר הסוגר מרובעת סגורה תושבת 10 סגורה סוגריים מרובעים.
>> ואז, אתה יכול לבחור לפרש את זה בראש שלך כמו 10
ב -10 רשת של תאים.
עכשיו, למעשה, בזיכרון, זה באמת פשוט
תישאר אלמנט 100, מערך ממדי אחת.
וזה, למעשה, הולך לאם אתה יש שלושה ממדים או ארבעה או חמש.
זה באמת פשוט להכפיל כל indices--
או כל הגודל specifiers-- יחד,
ואתה פשוט מקבל חד-ממדי מערך של גודל ש.
>> אבל במונחים של ארגון ו הדמיה ותפיסה אנושית,
יכול להיות שזה הרבה יותר קל לעבוד עם רשת
אם אתה עובד על משחק כמו איקס עיגול או צוללות,
או משהו כזה.
זה הפשטה גדולה, במקום שיש
לחשוב על איקס עיגול לוח כקו של תשע
ריבועים או לוח הקרב כקו של 100 ריבועים.
10 על ידי 10 רשת או שלוש על ידי שלוש רשת היא כנראה
הרבה יותר קל לתפוס.
>> עכשיו, משהו באמת חשוב על מערכים.
אנחנו יכולים להתייחס לכל פרט אלמנט של המערך כמשתנה.
ראינו שקודם לכן כשהיינו הקצאה
הערך האמיתי לBooleans מסוים או בדיקתם בתניות.
אבל אנחנו לא יכולים לטפל בכל מערכים עצמם כמשתנים.
אנחנו לא יכולים, למשל, להקצות מערך אחד למערך אחר באמצעות ההקצאה
מפעיל.
זה לא ג המשפטי
>> אם אנחנו רוצים, לexample-- מה אנחנו היו עושים בדוגמא ש
יהיה להעתיק מערך אחד למשנו.
אם אנחנו רוצים לעשות את זה, אנחנו באמת צריך להשתמש בלולאה להעתיק מעל
כל רכיב בודד אחד בכל פעם.
אני יודע שזה מעט זמן רב.
>> כך למשל, אם יש לנו זוג אלה שורות קוד, היית עבודה זו?
ובכן, לא, לא היית זה, נכון?
מכיוון שאנחנו מנסים כדי להקצות מזון לבר.
זה לא הולך לעבודה, כי זה מערך,
ואנחנו רק תיארנו שזה לא ג המשפטי
>> במקום זאת, אם אנחנו רוצים להעתיק את התוכן של מזון
בשורת, וזה מה ש אנחנו מנסים לעשות כאן,
היינו צריך תחביר כמו זה.
יש לנו ללולאה שעוברת מJ שווה 0 עד 5,
ואנחנו להגדיל J בכל איטרציה של הלולאה ואלמנטים להקצות כזה.
הדבר יביא גם בר להיות אחד, שתיים, שלוש, ארבעה, חמש,
אבל אנחנו צריכים לעשות את זה זה מאוד דרך איטית אלמנט-ידי-יסוד,
במקום רק על ידי העתקת כל המערך.
בתכנות אחר שפות, מודרני יותר,
אתה יכול, למעשה, לעשות בדיוק שפשוט שווה תחביר.
אבל C, למרבה הצער, אנחנו אסור לעשות את זה.
>> עכשיו, יש אחד אחר דבר שאני רוצה לדבר
על מערכים שיכול להיות קצת קצת מסובך בפעם הראשונה ש
לעבוד איתם.
דנו בוידאו על היקף משתנה,
כי רוב המשתנים ב- C, כאשר אתה קורא שלהם בפונקציות, מועברים על ידי ערך.
האם אתה זוכר מה זה אומר להעביר משהו בערך?
זה אומר שאנחנו עושים עותק של משתנה זה מועבר ב.
פונקצית callee, הפונקציה שמקבל משתנה,
אינו מקבל את עצמו משתנה.
זה נהיה מקומי שלה עותק ממנו לעבוד איתו.
>> מערכים, כמובן, לעשות לא פעל כלל זה.
במקום זאת, מה שאנחנו קוראים לזה עובר על ידי התייחסות.
Callee למעשה אין לקבל את המערך.
זה לא לקבלו עותק מקומי של שלו.
ואם אתה חושב על זה, זה הגיוני.
אם מערכים באמת גדולים, זה לוקח זמן ומאמץ כל כך הרבה
כדי ליצור עותק של מערך של 100 או 1,000 או 10,000 אלמנטים,
שזה לא שווה את זה ל לתפקד לקבל עותק שלו,
לעשות קצת עבודה עם זה, ולאחר מכן רק להיעשות עם העותק;
זה לא צריך להיות זה מסתובב יותר.
>> בגלל מערכים כמה מגושם ומסורבל,
אנחנו פשוט להעביר אותם על ידי התייחסות.
אנחנו פשוט סומכים על פונקציה ש ל, לא לשבור שום דבר.
אז זה ממש מקבל את המערך.
הוא אינו מקבל העותק המקומי שלה שלה.
>> אז מה זה אומר, לאחר מכן, כאשר callee
מתפעל אלמנטים של המערך?
מה קורה?
לעת עתה, אנו לחפות על למה בדיוק זה
קורה, למה מערכים הם עברו על ידי התייחסות
וכל דבר אחר הוא עבר על ידי ערך.
אבל אני מבטיח לך, שיהיו לחזור ולתת לך את התשובה
לזה בוידאו בהמשך.
>> הנה תרגיל יותר עבורך לפני שלעטוף את הדברים על מערכים.
החבורה של קוד כאן, זה לא במיוחד סגנון טוב,
רק אני אעשה את האזהרה ש.
אין תגובות לכאן, אשר היא צורה די רעה.
אבל זה רק בגלל שאני רוצה להיות תוכל להתאים את הכל על המסך.
>> בחלק העליון, אתה יכול לראות שיש לי שתי הצהרות פונקציה למערך קבוצה
ולהגדיר int.
מערך סט כנראה לוקח מערך של ארבעה מספרים שלמים כקלט שלה.
וint סט לוקח כנראה שלם אחת כקלט שלה.
אבל שניהם אין לי פלט.
התפוקה, התמורה הקלד, של כל אחד הוא חלל.
בראשים, שיש לנו כמה שורות של קוד.
אנו מצהירים משתנים שלמים נקרא ולהקצות לו את הערך 10.
אנו מצהירים מערך של ארבעה מספרים שלמים בשם B ולהקצות את האלמנטים 0, 1,
2, ו- 3, בהתאמה.
אז, יש לנו שיחה להגדיר int ושיחה להגדיר מערך.
ההגדרות של מערך קבוצה וסט int הם למטה, בתחתית.
>> וכך, שוב, אני שואל אותך את השאלה.
מה מקבל הדפסת כאן בסוף הראשי?
יש col תדפיס. אני להדפיס את שני מספרים שלמים.
אני מדפיס את התוכן של ו התוכן של הסוגר המרובע ב '0.
להשהות את הווידאו כאן ולקחת דקות.
אתה יכול להבין מה זה פונקציה תדפיס בסוף?
יש לקוות, אם אתה זוכר הבחנה בין פטירתו של ערך
ועובר על ידי התייחסות, זה הבעיה לא הייתה מסובכת מדי בשבילך.
ואתה היית התשובה מצאתי היא זו.
אם אתה לא ממש בטוח כמו ל מדוע זה המקרה, לקחת שני,
לחזור, לסקור את מה שאני היה רק דיון על העברת מערכים
על ידי התייחסות, לעומת עובר משתנים אחרים על ידי ערך,
ובתקווה, זה יעשה קצת יותר הגיוני.
>> אני דאג לויד, וזה CS50.