ROB אודן: היי, אני רוב אודן, ובואו נדבר על quiz0.
>> אז, השאלה ראשונה.
זו השאלה שבי אתה צריך לקודד את המספר
127 בנורות בינארי.
אם אתה רוצה, אתה יכול לעשות את ההמרה הרגילה
מbi-- או, מנקודה העשרונית בינארי.
אבל זה כנראה הולך לקחת הרבה זמן.
אני מתכוון, אתה יכול להבין את זה, אישור, 1 הוא שם, 2 הוא שם,
4 הוא שם, 8 הוא שם.
דרך קלה יותר, 127 היא 128 פחות אחד.
שהנורה השמאלית ביותר היא האור של 128 סיביות.
אז 127 הוא באמת רק כל של נורות האחרות,
מכיוון שזה השמאלי ביותר הנורה מינוס 1.
זהו זה לשאלה הזאת.
>> שאלה אחת.
אז עם 3 חתיכות שאתה יכול לייצג 8 ערכים שונים.
מדוע, אם כן, הוא 7 שאינם שלילי הגדול ביותר מספר שלם עשרוני אתה יכול לייצג?
ובכן, אם אנחנו יכולים רק לייצג 8 ערכים שונים,
אז מה אנחנו הולכים להיות מייצגים הוא 0 עד 7.
0 לוקח את אחד מהערכים.
>> שאלה שתי.
עם חתיכות n, כמה מובחן ערכים אתה יכול לייצג?
אז, עם חתיכות n, יש לך 2 ערכים אפשריים עבור כל ביט.
אז יש לנו 2 ערכים אפשריים עבור קצת הראשון, 2 ערכים אפשריים
לשני, 2 אפשרי לשלישי.
ואז זה 2 כפול 2 כפול 2, ו סופו של דבר התשובה היא 2 עד n.
>> שאלה שלוש.
מה 0x50 בינארי?
אז לזכור שהקסדצימלי יש מאוד המרה פשוטה לינארי.
אז הנה, אנחנו רק צריכים להסתכל על 5 ו0 באופן עצמאי.
אז מה 5 בינארי?
0101, זה קצת 1 ו4 הביט.
מה 0 בינארי?
לא מסובך.
0000.
אז פשוט לשים אותם יחד, ו זה המספר המלא בינארי.
01,010,000.
ואם אתה רוצה אתה יכול תוריד את האפס השמאלי ביותר.
זה לא רלוונטי.
>> אז לחלופין, מה הוא 0x50 עשרוניים?
אם אתה רוצה, אתה could-- אם אתה יותר נוח עם בינארי,
אתה יכול לקחת את זה תשובה בינארית ולהמיר את זה לעשרוני.
או שאנחנו יכולים רק לזכור הקסדצימלי ש.
כך ש0 הוא במקום 0-ה, ו 5 הוא ב-16 למקום הראשון.
אז הנה, יש לנו 5 פעמים 16 ל ראשון, בתוספת 0 פעמים 16 לאפס,
הוא 80.
ומי שהבטת ב כותרת לשאלה,
זה היה 80 CS, שהיה סוג של רמז לתשובה לבעיה זו.
>> שאלה חמש.
יש לנו תסריט Scratch זה, שהוא חוזר 4 פעמים ריבת חמאת בוטנים.
אז איך אנחנו עכשיו קוד שב- C?
ובכן, יש לנו here-- החלק מודגש הוא החלק היחיד שאתה צריך ליישם.
אז יש לנו לולאה 4 זה לולאת 4 פעמים, ריבת חמאת בוטנים ing-printf,
עם קו חדש הבעיה מבקשת.
>> שאלה שש, בעיה שריטה נוספת.
אנחנו רואים שאנחנו נמצאים בלולאה לנצח.
אנחנו אומרים שאני משתנה ולאחר מכן להגדיל כל i ב- 1.
עכשיו אנחנו רוצים לעשות את זה בC. יש מספר דרכים שאנחנו יכולים לעשות את זה.
כאן קרו לנו הקוד לנצח לולאה כזמן (אמיתי).
אז אנחנו מצהירים על המשתנה שאני, רק כמו שהיו לנו אני משתנה בגרד.
להכריז אני משתנה, ועד העולם בזמן (אמיתי), אנחנו אומרים משתנים i.
אז printf% אני- או שאתה יכול השתמשת% d.
אנחנו אומרים שמשתנים, ו אז להגדיל אותו, i ++.
>> שאלה שבע.
עכשיו אנחנו רוצים לעשות משהו דומה מאוד למריו נקודת ג מבעיה להגדיר אחד.
אנחנו רוצים להדפיס hashtags אלה, אנו רוצים להדפיס חמש
על ידי שלושה מלבן של Hash אלה.
אז איך אנחנו הולכים לעשות את זה?
ובכן, אנחנו נותנים לכם את כל חבורה של קוד, ואתה פשוט
צריך למלא את פונקצית רשת הדפסה.
>> אז מה עושה PrintGrid נראה?
ובכן אתה האחרון רוחב והגובה.
אז יש לנו חיצוני 4 לולאה, זה לולאה
על כל השורות של זה רשת שאנחנו רוצים להדפיס.
אז יש לנו 4 הלולאה בין-מקוננת, זה הדפסה על פני כל עמודה.
אז עבור כל שורה, אנחנו מדפיסים ל כל עמודה, חשיש אחת.
ואז בסוף השורה אנחנו מדפיסים הקו חדש יחיד ללכת לשורה הבאה.
וזהו לכל הרשת.
>> שאלה שמונה.
פונקציה כמו PrintGrid הוא אמרה יש תופעת לוואי, אך לא חזרה
ערך.
הסבר את ההבחנה.
אז זה מסתמך עליך לזכור מה הוא תופעת לוואי.
ובכן, תשואה value-- אנחנו יודעים PrintGrid לא
יש ערך מוחזר, מאז כאן זה אומר חלל.
אז כל דבר שחוזר ריק לא ממש מחזיר שום דבר.
אז מה היא תופעת הלוואי?
ובכן, תופעת לוואי הוא כל דבר שסוג של נמשך
לאחר סיום הפונקציה זה היה לא רק חזר,
וזה לא היה רק ​​מהתשומות.
>> כך, למשל, אולי אנחנו לשנות משתנה גלובלי.
זה יהיה תופעת לוואי.
במקרה הספציפי הזה, תופעת לוואי חשוב מאוד
מדפיס על המסך.
כך שהוא תופעת לוואי יש PrintGrid ש.
אנו מדפיסים את הדברים האלה על המסך.
ואתה יכול לחשוב על כי כתופעת לוואי,
מכיוון שזה משהו ש נמשך לאחר פונקציה זו מסתיימת.
זה משהו שמחוץ לתחום של פונקציה זו שסופו של דבר
הוא להיות שונה, תוכן של המסך.
>> שאלה תשע.
קחו למשל את התכנית בהמשך, שלמספרי שורות
נוספו ל לצורך דיון.
אז בתכנית זו אנחנו רק קורא GetString, לאחסן אותו
בסעיף משתנה זה, ולאחר מכן הדפסת שהים משתנה.
אישור.
אז להסביר למה קו אחד הוא הווה.
h נקודת cs50 #include.
למה אנחנו צריכים #include h נקודת cs50?
ובכן אנחנו קוראים GetString פונקציה,
וGetString מוגדר בספריית cs50.
אז אם לא היה לנו h נקודת cs50 #include,
היינו מקבל כי הכרזה משתמעת של שגיאת פונקצית GetString
מהמהדר.
אז אנחנו צריכים לכלול את library-- אנחנו צריכים לכלול את קובץ הכותרת,
או לא אחר מהדר להכיר בכך שGetString קיים.
>> להסביר למה קו שני נוכח.
h נקודת io כך סטנדרטי.
זה בדיוק אותו הדבר כבעיה הקודמת,
אלא שבמקום להתמודד עם GetString, אנחנו מדברים על printf מדברים.
אז אם אנחנו לא אומרים שאנחנו צריכים לכלול h נקודת io הסטנדרטי,
אז אנחנו לא יהיו מסוגלים כדי להשתמש בפונקצית printf,
כי מהדר לא הייתי יודע על זה.
>> Why-- מה המשמעות של החלל בקו ארבעה?
אז הנה יש לנו int main (void).
זה רק אומר לנו ש לא מקבלים שורת פקודת כל
טיעונים לעיקריים.
זכור כי נוכל לומר int סוגריים עיקריים int argc argv המחרוזת.
אז הנה אנחנו רק אומרים חלל לומר שאנחנו מתעלמים טיעוני שורת הפקודה.
>> להסביר, ביחס לזיכרון, בדיוק מה GetString בקו שש חזרות.
GetString חוזר בלוק של זיכרון, מערך של תווים.
זה באמת חוזר מצביע לתו הראשון.
זכור כי מחרוזת היא כוכב char.
אז ככה, שעה הוא מצביע לראשון אופי בכל המחרוזת היא
שהמשתמש נכנס במקלדת.
וזיכרון שקורה להיות malloced, כך הזיכרון שנמצא בערימה.
>> שאלה 13.
קחו למשל את התכנית בהמשך.
אז כל התכנית הזו עושה הוא printf-ing 1 מחולק ב -10.
אז וכאשר נערכו , תכנית שבוצעה זה
פלטים 0.0, למרות ש 1 מחולק ב -10 הוא 0.1.
אז למה זה 0.0?
ובכן, זה בגלל ש של חלוקה של מספרים שלמים.
אז 1 הוא מספר שלם, 10 הוא מספר שלם.
אז 1 חלקי 10, כל מה ש מטופל כמספרים שלמים,
ובC, כאשר אנחנו עושים חלוקה של מספרים שלמים, אנחנו לחתוך כל נקודה עשרונית.
אז 1 חלקי 10 הוא 0, ולאחר מכן אנחנו מנסים
להדפיס כי כלצוף, כך אפס מודפס כמצוף הוא 0.0.
ובגלל זה אנחנו מקבלים 0.0.
>> קחו למשל את התכנית בהמשך.
עכשיו אנחנו מדפיסים 0.1.
אז לא חלוקה של מספרים שלמים, אנחנו רק הדפסת 0.1,
אבל אנחנו מדפיסים אותו עד 28 ספרות אחרי נקודה עשרוניות.
ואנחנו מקבלים 0.1000 זה, כל חבורה של אפסים, 5 5 5, בלה בלה בלה.
אז השאלה כאן היא מדוע עושה את זה להדפיס כי, במקום בדיוק 0.1?
>> אז הסיבה כאן היא עכשיו צף חוסר דיוק נקודה.
זכור כי לצוף הוא רק 32 סיביות.
לכן אנחנו רק יכולים לייצג מספר סופי של ערכי נקודה צפה עם 32 אלה
ביטים.
ובכן יש סופו של דבר לאין שיעור ערכי נקודה צפו רבים,
ויש רבים לאין שיעור צף ערכי נקודה שבבין 0 ו -1,
ואנחנו כמובן יכולים מייצג עוד יותר ערכים מזה.
אז אנחנו צריכים להקריב קורבנות ל תוכל לייצג את רוב הערכים.
>> אז ערך כמו 0.1, ככל הנראה אנחנו לא יכולים לייצג כי בדיוק.
אז במקום לייצג 0.1 אנחנו עושים הכי טוב שאנחנו יכולים לייצג 0.100000 5 5 זה
5.
וזה די קרוב, אבל עבור הרבה יישומים
אתה צריך לדאוג צף חוסר דיוק נקודה,
בגלל שאנחנו פשוט לא יכולים לייצג צפה כולם נקודות בדיוק.
>> שאלה 15.
קחו למשל את הקוד שלהלן.
אנחנו רק הדפסת 1 פלוס 1.
לכן אין שום טריק כאן.
1 פלוס 1 מעריך 2, ו אז אנחנו מדפיסים ש.
זה פשוט מדפיס 2.
>> שאלה 16.
עכשיו אנחנו מדפיסים את התו 1 בתוספת האופי 1.
אז למה עושה את זה לא להדפיס את אותו הדבר?
ובכן האופי 1 בתוספת האופי 1, יש לו את האופי 1 ערך ASCII 49.
אז זה באמת אומר 49 בתוספת 49, ו סופו של דבר זה הולך להדפיס 98.
אז זה לא מדפיס 2.
>> שאלה 17.
השלם את היישום של מוזר מתחת בצורה כזאת
שהפונקציה מחזירה אמת אם n הוא מוזר ושגוי, אם n הוא אפילו.
זוהי מטרה גדולה למפעיל mod.
אז אנחנו לוקחים n הטיעון שלנו, אם n mod 2 שווה 1, גם
זה אומר שמחולק n על ידי 2 הייתה שארית.
אם נחלק n על ידי 2 הייתה שארית, ש משמעות הדבר היא כי n הוא מוזר, ואנחנו חוזרים אמיתיים.
עוד אנחנו בתמורת שווא.
אתה גם יכול לעשות n mod 2 שווים אפס, בתמורת שווא, אחר לחזור נכון.
>> קחו למשל את הפונקציה רקורסיבית להלן.
אז אם n הוא פחות או שווה ל 1, 1 חזור,
תמורה אחרת n פעמים f של n מינוס 1.
אז מה היא פונקציה זו?
ובכן, זה פשוט פונקצית עצרת.
זה יפה מיוצג כעצרת n.
>> אז שאלה של 19 עכשיו, אנחנו רוצים לקחת פונקציה רקורסיבית זה.
אנחנו רוצים לעשות את זה איטרטיבי.
אז איך אנחנו עושים את זה?
ובכן לצוות פתרון, ושוב יש
דרכים רבות שהיה יכול לעשות כי, אנחנו מתחילים עם מוצר int זה
שווה 1.
וכל אותו ללולאה, אנחנו הולכים
להכפלת מוצר לסופו של דבר בסופו של העצרת המלאה.
אז לint i שווה 2, הוא אני קטן או שווה ל- n, i ++.
>> ייתכן שאתה תוהה למה אני שווה 2.
ובכן, תזכור שיש לנו כאן ל לוודא מקרה הבסיס שלנו הוא נכון.
אז אם n הוא פחות או שווה ל1, אנחנו רק חוזרים 1.
אז כאן, אנחנו מתחילים בi שווה 2.
ובכן, אם אני היה 1, ולאחר מכן the-- או אם n היה 1, ולאחר מכן ללולאה
לא לבצע בכלל.
ואז אנחנו פשוט הייתם מוצר תמורה, שהוא 1.
באופן דומה, אם n היו כל דבר פחות מ1--
אם זה היו 0, מינוס 1, whatever-- היינו עדיין אחזור 1,
וזה בדיוק מה גרסה רקורסיבית עושה.
>> עכשיו, אם n הוא גדול יותר מ 1, אז אנחנו הולכים
לעשות לפחות אחד איטרציה של לולאה זה.
אז בואו נגיד שn הוא 5, אז אנחנו הולכים לעשות פעמים מוצר שווה 2.
אז עכשיו מוצר הוא 2.
עכשיו אנחנו הולכים לעשות פעמים מוצר שווה 3.
עכשיו זה 6.
פעמים מוצר שווה 4, עכשיו זה 24.
פעמים מוצר שווה 5, עכשיו זה 120.
אז סופו של דבר, אנחנו חוזרים 120, שהוא בצורה נכונה 5 עצרת.
>> שאלה 20.
זה אחד שבו אתה צריך למלא בטבלה זו עם כל אלגוריתם נתון,
כל דבר שאנחנו רואים, ש מתאים אלה אלגוריתמיים ריצה
פעמים לרוץ פעמים אסימפטוטית אלה.
אז מה הוא אלגוריתם ש הוא אומגה של 1, אבל O הגדול של n?
אז יכול להיות שיש לאין שיעור תשובות רבות כאן.
אחד שראינו כנראה הכי לעתים קרובות הוא רק חיפוש ליניארי.
>> אז במקרה הטוב תרחיש, הפריט שאנחנו
מחפש ב תחילתה של הרשימה
וכך באומגה של 1 צעדים, הדבר הראשון שאנחנו בודקים,
אנחנו פשוט באופן מיידי לחזור שמצאנו את הפריט.
במקרה הגרוע ביותר, הפריט הוא בסופו של הדבר,
או הפריט אינו ברשימה בכלל.
אז יש לנו לחפש כל הרשימה, כל n
אלמנטים, ולכן זה O של n.
>> אז עכשיו זה משהו שהוא גם אומגה של n n יומן, וO הגדול של n n יומן.
ובכן הדבר הרלוונטי ביותר שראינו כאן הוא מיון מיזוג.
אז למזג סוג, לזכור, סופו של הדבר תטא
של n n יומן, שבו תטא מוגדר אם שתי אומגה וO הגדול הם אותו הדבר.
שני n להתחבר n.
>> מה משהו שהוא אומגה של n, ו- O של n בריבוע?
ובכן, שוב יש תשובות אפשריות רבות.
כאן אנו לקרות לומר מיון בועות.
מיון ההכנסה גם יעבוד כאן.
זכור כי מיון בועות יש אופטימיזציה שבי,
אם אתה יכול לקבל לאורך כל הרשימה
ללא צורך לעשות כל עסקות החלף, ולאחר מכן, גם,
אנחנו יכולים מייד לחזור ש הרשימה מוינה מלכתחילה.
אז במקרה הטוב, זה רק אומגה של n.
אם זה לא רק יפה מסודרים על רשימה מלכתחילה,
אז יש לנו O של n בריבוע חילופים.
ולבסוף, יש לנו מיון בחירה עבור n בריבוע, שניהם אומגה וO. הגדול
>> שאלה 21.
מה גלישת מספר שלם?
ובכן שוב, דומה לקודם לכן, יש לנו מספר הסופי של ביטים בלבד
לייצג מספר שלם, אז אולי 32 סיביות.
בואו נגיד שיש לנו מספר שלם שנחתם.
אז סופו של דבר הגבוה ביותר מספר חיובי שאנחנו יכולים לייצג
הוא 2 עד 31 מינוס 1.
אז מה קורה אם אנו מנסים אז להגדיל מספר שלם ש?
ובכן, אנחנו הולכים ללכת בין 2 ל 31 מינוס 1, כל הדרך למטה עד 2 שליליים
ליום 31 ב.
אז גלישת מספר שלם זה כאשר אתה להגדיל כל,
וסופו של דבר אתה לא יכול מקבל רק יותר גבוה, וזה
עוטף את כל הדרך חזרה סביב לערך שלילי.
>> מה לגבי הצפת מאגר?
אז חיץ overflow-- זוכר מה הוא חיץ.
זה פשוט גוש של זיכרון.
משהו כמו מערך הוא חיץ.
אז גלישת מאגר היא כאשר אתה מנסה לגשת לזיכרון
מעבר לסוף המערך ש.
אז אם יש לך מערך של גודל 5 ואתה
תנסה לגשת הסוגר מערך 5 או 6 או הסוגר הסוגר 7,
או כל דבר מעבר ל סוף, או אפילו כל דבר
תושבת מערך below-- 1-- שליליות כל אלה הם גולש חיץ.
אתה נוגע בזיכרון בדרכים רעות.
>> שאלה 23.
אז בזה שאתה צריך ליישם strlen.
ואנו אומרים לך שאתה יכול להניח של לא יהיה ריק,
ולכן אין לך לעשות בדיקה כלשהי לnull.
ויש דרכים רבות אתה יכול לעשות את זה.
כאן אנחנו פשוט לקחת את פשוטים.
אנחנו מתחילים עם דלפק, n. n הוא לספור כמה תווים יש.
אז אנחנו מתחילים ב 0, ולאחר מכן אנו לחזר על כל הרשימה.
>> האם הסוגר של 0 שווה ל אופי שליחות קטלנית null?
זכור שאנחנו מחפשים אופי שליחות קטלנית null
כדי לקבוע כמה זמן המחרוזת שלנו היא.
כי הוא הולך לסיים כל מחרוזת רלוונטית.
אז הוא הסוגר של 0 שווים לשליחות קטלנית null?
אם זה לא, אז אנחנו הולכים ל להסתכל של תושבת 1, של התושבת 2.
אנחנו ממשיכים לנסוע עד ש למצוא את שליחות קטלנית null.
ברגע שמצאנו אותו, ואז n מכיל האורך הכולל של המחרוזת,
ואנחנו יכולים רק לחזור ש.
>> שאלה 24.
אז זה אחד שבו אתה צריך לעשות את הסחר.
אז דבר אחד טוב באחד דרך, אבל באיזה אופן זה רע?
אז הנה, מיון המיזוג נוטה להיות מהיר יותר ממיון בועות.
אחרי שאמר את that-- גם, יש תשובות מרובות כאן.
אבל העיקרי שבן הוא מיון בועות הוא אומגה של n לרשימה ממוינת.
>> זכור את השולחן שרק שראינו קודם לכן.
אז בועה ממיינת אומגה של n, במקרה הטוב
הוא שזה יכול רק לעבור על הרשימה פעם אחת, לקבוע
היי הדבר הזה הוא כבר מסודרים, וחזרה.
מיון מיזוג, לא משנה מה אתה עושה, הוא אומגה של n n יומן.
אז לרשימה ממוינת, בועה סוג זה הולך להיות מהיר יותר.
>> עכשיו מה לגבי רשימות מקושרות?
אז רשימה מקושרת יכולה לגדול ולהתכווץ כדי שיתאים לאלמנטים לפי צורך.
אחרי שאמר את that-- כך בדרך כלל ההשוואה הישירה
הולך להיות קשור רשימה עם מערך.
אז למרות שמערכים יכולים בקלות לגדול ולהתכווץ
כדי שיתאים לאלמנטים רבים במידת צורך, קשור רשימה
בהשוואה לarray-- יש מערך גישה אקראית.
אנחנו יכולים מדד לכל אלמנט מסוים של המערך.
>> אז לרשימה מקושרת, אנחנו לא יכולים פשוט ללכת לאלמנט החמישי,
אנחנו צריכים לעבור מההתחלה עד שנגיע לאלמנט החמישי.
וזה הולך כדי למנוע מאתנו עושה משהו כמו חיפוש בינארי.
אם כבר מדברים על החיפוש בינארי חיפוש, בינארי נוטה להיות מהיר יותר מאשר החיפוש ליניארי.
אחרי שאמר את that-- כך, דבר אחד אפשרי
הוא שאתה לא יכול לעשות בינארי חיפוש ברשימות מקושרות,
אתה יכול לעשות את זה רק על מערכים.
אבל כנראה וחשוב יותר, אתה לא יכול לעשות חיפוש בינארי
במערך שאינו ממוין.
מראש שאולי אתה צריך למיין המערך, ורק אז יכול
אתה עושה את החיפוש בינארי.
אז אם הקטע שלכם הוא לא מיון מלכתחילה,
אז החיפוש ליניארי יכול להיות מהיר יותר.
>> שאלה 27.
לכן קחו בחשבון את התכנית מתחת, אשר יהיה בשקופית הבאה.
ואת זה הוא אחד שבו אנחנו הולך רוצה להצהיר באופן מפורש
הערכים עבור משתנים שונים.
אז בואו נסתכל על זה.
>> אז בשורה אחת.
יש לנו x int שווה 1.
זה הדבר היחיד שקרה.
אז בשורה אחת, שאנו רואים בנו שולחן, y ש, a, b, וtmp כל
הושחר.
אז מה הוא X?
ובכן אנחנו פשוט להגדיר את זה שווה ל -1.
ולאחר מכן בשורה שתיים, גם, אנו רואים כי y מוגדר 2,
והשולחן הוא כבר מילאתי ​​את מקומנו.
אז x הוא 1 ו- Y הוא 2.
>> עכשיו, קו שלוש, אנחנו עכשיו בתוך פונקצית swap.
מה עשה לעבור כדי להחליף?
עברנו x אמפרסנד ל , ו- y אמפרסנד לב.
איפה הבעיה קודם לכן ציין כי כתובתו של x
הוא 0x10, ואת הכתובת של y היא 0x14.
אז A ו- B שווה ל 0x10 ו0x14, בהתאמה.
>> עכשיו בקו שלושה, מה הם x ו- y?
ובכן, שום דבר לא השתנה על x ו- y בנקודה זו.
למרות שהם בתוך מסגרת ערימה העיקרית,
עדיין יש להם את אותו ערכים שהם עשו לפני.
אנחנו לא שונה כל זיכרון.
אז x הוא 1, y הוא 2.
בְּסֵדֶר.
אז עכשיו אנחנו אמרתי tmp int שווה לככב.
אז בקו ארבעה, כל מה ש הוא אותו הדבר מלבד tmp.
לא שינינו את כל ערכים של כל דבר פרט לtmp.
אנו מציבים tmp שווה לככב.
מה הוא כוכב?
ובכן, נקודות לx, אז כוכב הולך x שווה, שהוא 1.
אז כל מה שמועתק מטה, וtmp מוגדר 1.
>> עכשיו השורה הבאה.
כוכבים שווים כוכב ב.
זאת על ידי קו five-- גם שוב, כל מה ש הוא אותו הדבר מלבד מה שכוכב הוא.
מה הוא כוכב?
ובכן, אנחנו פשוט אמרו כוכב הוא x.
אז אנו משנים x לב כוכב שווה.
מהו כוכב ב? y. נקודות ב ל Y.
אז כוכב b הוא y.
אז אנחנו קביעת x שווה ל- y, וכל דבר אחר הוא זהה.
כך אנו רואים בשורה הבאה שx הוא עכשיו 2, והשאר פשוט העתיק קודם.
>> עכשיו בשורה הבאה, כוכב ב שווה tmp.
ובכן, אנחנו פשוט אמרו כוכב b הוא y, לכן אנחנו קביעת y שווה לtmp.
כל השאר הוא אותו הדבר, ככה הכול מועתק.
אנחנו קביעת y שווה לTMP, שהוא אחד, וכל דבר אחר הוא זהה.
>> עכשיו סוף סוף, קו שבע.
אנחנו שוב בפונקציה העיקרית.
אנחנו אחרי ההחלפה נגמרה.
אבד לנו, ב, ו tmp, אבל סופו של דבר אנחנו
לא משנים את כל ערכים של דבר, בשלב זה,
אנחנו פשוט להעתיק x ולמטה y.
ואנו רואים כי x ו- y הם עכשיו 2 ו 1 במקום 1 ו -2.
ההחלפה ביצעה בהצלחה.
>> שאלה 28.
נניח שאתה נתקל ב הודעות השגיאה
להלן בשעתי עבודה בשנה הבאה כCA או TF.
לייעץ איך לתקן את כל השגיאות האלה.
התייחסות כל כך לא מוגדרת לGetString.
מדוע אתה עשוי לראות את זה?
ובכן, אם תלמיד משתמש GetString בקוד שלהם,
הם כראוי לי חשיש כלול cs50 h הנקודה לכלול את ספריית cs50.
>> ובכן, מה לעשות שהם צריך לתקן את השגיאה?
הם צריכים לעשות lcs50 מקף ב שורת הפקודה כאשר הם קומפילציה.
אז אם הם לא עברו את lcs50 מקף צלצול, הם
לא הולך להיות בפועל קוד המיישם GetString.
>> שאלה 29.
במרומז הכרזה פונקצית ספריית strlen.
ובכן זה עכשיו, יש להם לא עשיתי את החשיש הנכון כולל.
במקרה הספציפי הזה, בקובץ הכותרת הם צריכים לכלול הוא h נקודת מחרוזת,
ובכלל זה h נקודת מחרוזת, עכשיו student-- עכשיו מהדר
יש לו גישה ל הצהרות של strlen,
והוא יודע שהקוד שלך הוא strlen באמצעות צורה נכונה.
>> שאלה 30.
המרות אחוזים יותר מאשר טיעוני נתונים.
אז מה זה?
זוכר היטב שאחוזים אלה signs-- איך הן רלוונטיות לprintf.
אז בprintf אולי percent-- אולי להדפיס משהו
כמו אחוזים i קו נטוי n.
או שאולי אנחנו להדפיס כמו שאני אחוזים, מרחב, אני אחוזים, חלל, אחוזים אני.
אז לכל אחד מאלה סימני אחוזים, אנחנו צריכים
להעביר משתנה בסופו של printf.
>> אז אם אנחנו אומרים אחוזים סוגר printf אני קו נטוי קרובים n סוגריים,
בסדר, אנחנו אומרים שאנחנו הולך להדפיס מספר שלם,
אבל אז אנחנו לא עוברים printf מספר שלם כדי להדפיס בפועל.
אז הנה עוד אחוזים המרות מאשר טיעוני הנתונים?
זה אומר שיש לנו חבורה שלמה של אחוזים,
ואין לנו מספיק משתנים למעשה כדי למלא באחוזים אלה.
>> ואז בהחלט, לשאלה 31, בהחלט איבד 40 בתים באחד בלוקים.
אז זה טעות Valgrind.
זה אומר ש אי שם בקוד שלך,
יש לך הקצאה שהיא 40 בתים גדולים, כך שmalloced 40 בתים,
ואתה אף פעם לא שחרר אותו.
סביר להניח שאתה פשוט צריך למצוא דליפת זיכרון,
ולמצוא בו אתה צריך לשחרר את הבלוק הזה של זיכרון.
>> ושאלה 32, כתיבה לא חוקית של גודל 4.
שוב זה שגיאת Valgrind.
זה לא צריך לעשות עם דליפות זיכרון עכשיו.
זה, רוב likely-- אני מתכוון, זה איזה זכויות זיכרון לא חוקיות.
וסביר להניח שזה חלק סוג של הצפת מאגר.
איפה יש לך מערך, אולי מערך של מספרים שלמים, ובוא
אומר שזה בגודל 5, ואתה מנסה לגעת הסוגר מערך 5.
אז אם אתה מנסה לכתוב של הערך, שלא פיסת הזיכרון
כי בעצם יש לך גישה ל, ו כך שאתה הולך לקבל את השגיאה הזו,
אומר כתיבה לא חוקית של גודל 4.
Valgrind הולך להכיר לך מנסה לגעת בזיכרון בצורה בלתי הולמת.
>> וזהו לquiz0.
אני רוב אודן, וזה CS50.