1 00:00:00,000 --> 00:00:02,310 [Powered by Google Translate] [שבוע 4, המשך] 2 00:00:02,310 --> 00:00:04,240 [דוד י מלאן - אוניברסיטת הרווארד] 3 00:00:04,240 --> 00:00:07,290 [זה CS50. - CS50.TV] 4 00:00:07,290 --> 00:00:11,290 >> זה CS50, וזה סוף השבוע 4. 5 00:00:11,290 --> 00:00:14,030 אז קצת חדשות טובות וחדשות רעות. 6 00:00:14,030 --> 00:00:26,240 אין הרצאה ביום שני, אין בעיה להגדיר בשבוע הבא. [תלמידים מריעים] 7 00:00:26,240 --> 00:00:28,680 אתה לא הולך לאוהב לאן זה הולך. 8 00:00:28,680 --> 00:00:31,590 אבל יש לנו את זה במקום ביום רביעי הבא, 9 00:00:31,590 --> 00:00:37,740 ויש גם להרצאת סילבוס יום שישי 1 ביום שישי הבא, כך שנוכל להישאר על מסלול. 10 00:00:37,740 --> 00:00:40,580 אבל הכל יהיה מצולם כרגיל, אז לא לדאוג. 11 00:00:40,580 --> 00:00:44,100 >> ובנוגע לחידון 0 מה שנעשינו לקראת סוף השבוע 12 00:00:44,100 --> 00:00:47,140 הוא לפרסם בדף הבית של cs50.net כמובן הסבר 13 00:00:47,140 --> 00:00:50,160 של איזה סוג של ציפיות צריכים להיות לך כשזה מגיע לחידון הראשון. 14 00:00:50,160 --> 00:00:55,100 באופן כללי, זה יהיה בחירה, תשובה אמיתית, שקר, בקיצור, בעיות קידוד קצרות. 15 00:00:55,100 --> 00:00:57,360 אתה לא הולך להיות צפוי ליישם את המקבילה 16 00:00:57,360 --> 00:01:00,030 של בעיה שהיית רואה על pset, שעבורו יש לך מחשב 17 00:01:00,030 --> 00:01:03,240 והבאגים וכדומה, אבל יהיו בעיות קידוד קטנות. 18 00:01:03,240 --> 00:01:06,900 >> ואכן, המדריך הטוב ביותר כדי לקבל תחושה של מה CS50 חידונים הם כמו 19 00:01:06,900 --> 00:01:09,180 זה ללכת cs50.net, ללכת על קישור בחנים, 20 00:01:09,180 --> 00:01:11,920 ואתה יכול לראות בשנים האחרונות בשווי של החידונים. 21 00:01:11,920 --> 00:01:16,600 רק מבין שתכנית הלימודים לא תמיד הייתה אותו לאורך השנים. 22 00:01:16,600 --> 00:01:18,510 לפעמים אנחנו מוסיפים, לעתים לחסר, 23 00:01:18,510 --> 00:01:20,670 כך שאם אתה רואה כמה נושא באחד מאלה ישנים חידונים 24 00:01:20,670 --> 00:01:25,380 שאין לך מושג מה הוא מדבר עליו, זה או שאנחנו לא מכסים אותו 25 00:01:25,380 --> 00:01:27,210 או שלא כיסה אותו. 26 00:01:27,210 --> 00:01:31,110 אבל בצורה של חוות דעת, ביום ראשון, השני והשלישי 27 00:01:31,110 --> 00:01:34,770 כמו גם חיבור כמובן רחב ביקורת יום ראשון בלילה - 28 00:01:34,770 --> 00:01:37,500 זמן ומיקום שהודיע ​​בעמוד הבית של הקורס - 29 00:01:37,500 --> 00:01:40,120 כולכם יש הזדמנות לבחון עם עמיתי ההוראה של הקורס 30 00:01:40,120 --> 00:01:44,830 חומר לשנה זו, היא בסעיף וככיתה מלאה, 31 00:01:44,830 --> 00:01:48,400 ומי יהיה צולם כרגיל גם כן. 32 00:01:48,400 --> 00:01:53,380 >> בסדר. אז בלי עיכובים נוספים, הערה אחת על עובר / נכשלה ולהוסיף / טיפה. 33 00:01:53,380 --> 00:01:57,980 יכול להיות שראית את הרשימות שלי אתמול בלילה, וזה באמת רק כמה חיזוקים נוספים 34 00:01:57,980 --> 00:02:01,250 שאם אתה בין אלה בעיקר פחות נוחים או איפשהו באמצע 35 00:02:01,250 --> 00:02:04,870 ואתה מרגיש קצת מעל הראש שלך, 36 00:02:04,870 --> 00:02:08,430 להבין שאכן די נורמלי, ויש מבנה תמיכה נרחבת במקום, 37 00:02:08,430 --> 00:02:13,530 אחד מהם השעות עבודה היו כוונה בשיפור עוד יותר ללילה האחרון הדוא"ל שלי, 38 00:02:13,530 --> 00:02:16,520 ומבינים גם שאפשרות כמו עובר / נכשלה למעמד כזה 39 00:02:16,520 --> 00:02:21,540 באמת נועד כמנגנון לקחת את העוקץ של קורס כזה, 40 00:02:21,540 --> 00:02:24,200 כך ששוב, אם אתה מבלה 10, 15, 20 השעות האלה 41 00:02:24,200 --> 00:02:28,160 רק מנסה להשיג קצת pset לעבודה ואתה יודע שאתה 90-95% מהדרך לשם 42 00:02:28,160 --> 00:02:32,100 אבל אתה לא יכול למצוא איזה חיידק ארור, בעובר / נכשלת מודל זה סוג של בסדר. 43 00:02:32,100 --> 00:02:36,230 >> הרעיון הוא שעם אותו מנגנון אז אתה יכול להתמקד בpsets האחר שלך 44 00:02:36,230 --> 00:02:39,530 או לישון או מה שזה לא שאתה רוצה להתמקד. 45 00:02:39,530 --> 00:02:43,390 אז הבנת שיש לך עד יום שלישי הקרוב - טכני ביום שני 5, 46 00:02:43,390 --> 00:02:50,840 אבל זה חג, אז זה יום שלישי הקרוב - כדי לעבור מעובר / נכשל ללהיפך מדורג או סגן. 47 00:02:50,840 --> 00:02:54,450 אם אתם ממש על שפת התהום וחושבים לעזוב לגמרי ו, 48 00:02:54,450 --> 00:02:56,440 אנא תתפוס אותי אחרי הרצאה או ירידה לי פתק. 49 00:02:56,440 --> 00:02:59,990 נשמח לפחות צ'אט בטרם הצעת אדיו. 50 00:02:59,990 --> 00:03:03,470 בסדר. אז התחיל לקחת את גלגלי עזר מהפעם האחרונה. 51 00:03:03,470 --> 00:03:06,030 בפרט, אנו מתמקדים במחרוזת. 52 00:03:06,030 --> 00:03:09,740 מחרוזת היא משהו שהצהיר בספריית CS50, 53 00:03:09,740 --> 00:03:14,340 במיוחד שבקובץ שנקרא cs50.h בו יתחילו להסתכל על השבוע הזה והבא. 54 00:03:14,340 --> 00:03:17,250 אבל מחרוזת היא באמת רק פישוט של משהו 55 00:03:17,250 --> 00:03:20,980 זה קצת יותר arcanely תאר כ* char. 56 00:03:20,980 --> 00:03:24,090 Char אנחנו מכירים. זה רק דמות אחת. 57 00:03:24,090 --> 00:03:28,010 אבל * כשל יום שני מסומן מה? >> [תלמיד] מצביע. 58 00:03:28,010 --> 00:03:31,290 מצביע. ומה מצביע? >> [תלמיד] כתובת. 59 00:03:31,290 --> 00:03:33,420 >> זה כמו כתובת, מיקום בזיכרון. 60 00:03:33,420 --> 00:03:35,910 מה כתובת או מיקום או זיכרון? 61 00:03:35,910 --> 00:03:40,290 שוב, לכולנו יש מחשבים ניידים עם הופעה או 2 ג'יגה בייט של זכרון RAM ככל הנראה בימים אלה, 62 00:03:40,290 --> 00:03:44,160 וזה אומר שיש לך מיליארדים או 2 מליארד בתים בשווי של הזיכרון. 63 00:03:44,160 --> 00:03:46,240 וזה לא ממש משנה מה זה פיזי נראה, 64 00:03:46,240 --> 00:03:51,220 אבל לקחת על אמונה שאתה יכול למספר את כל הבתים הבודדים שבמחשב נייד שלכם יש - 65 00:03:51,220 --> 00:03:54,580 זה ייט 0, זה הוא בית 1, זה בתים 2000000000 - 66 00:03:54,580 --> 00:03:56,100 וזה בדיוק מה שמחשב עושה. 67 00:03:56,100 --> 00:04:00,030 כשאתה להקצות שטח לתו בודד, למשל, 68 00:04:00,030 --> 00:04:02,480 זה ברור שצריך לחיות איפשהו בזכרון המחשב שלך, 69 00:04:02,480 --> 00:04:05,860 ואולי זה במספר בתי 12345, 70 00:04:05,860 --> 00:04:08,470 וזה איפשהו כאן בזכרון המחשב שלך. 71 00:04:08,470 --> 00:04:12,630 ואז הכתובת של שהדמות היא 12345. 72 00:04:12,630 --> 00:04:16,140 >> עכשיו, בשבוע 0 עד עכשיו עד כה, יש לנו לא ממש אכפת 73 00:04:16,140 --> 00:04:19,170 שם בדברי זיכרון מאוחסנים כי אנחנו בדרך כלל משתמשים בסמלים, 74 00:04:19,170 --> 00:04:22,540 משתנה, ומערכים לממש מקבלים בנתונים שלנו. 75 00:04:22,540 --> 00:04:24,950 אבל נכון ליום שני ועוד יותר היום, אתה עכשיו הולך להיות 76 00:04:24,950 --> 00:04:27,710 כל יכולות הבעה יותר עם תוכניות כתיבה 77 00:04:27,710 --> 00:04:31,330 באמת כדי לתפעל הזיכרון של מחשב כפי שאתה רואה לנכון, 78 00:04:31,330 --> 00:04:33,720 למטרות טובות ורעות, 79 00:04:33,720 --> 00:04:39,620 באגים להיות תוצאה נפוצה מאוד בנקודה זו בלימוד החומר הזה. 80 00:04:39,620 --> 00:04:42,460 אבל מה זה באמת אומר להיות * char? 81 00:04:42,460 --> 00:04:46,140 בואו נלך קדימה חזרה - ואנחנו נחזור לינקי כפי שהובטח היום. 82 00:04:46,140 --> 00:04:48,670 בואו נלך לדוגמה פשוטה כאן. 83 00:04:48,670 --> 00:04:53,060 בואו להציל אותי בקובץ זה כcompare.c, ותן לי רק קצת קוד תבנית כאן 84 00:04:53,060 --> 00:05:00,490 לכן כולל stdio.h, הרשה לי גם לתת לעצמי כולל cs50.h. אני להתקרב לשם. 85 00:05:00,490 --> 00:05:05,850 הרשו לי להתחיל לכתוב int הראשי, עיקרי (void), ועכשיו אני רוצה לעשות משהו כזה: 86 00:05:05,850 --> 00:05:13,520 printf ("תן לי את מחרוזת:") ולאחר מכן אני אשתמש במחרוזת של מקבל GetString 87 00:05:13,520 --> 00:05:16,750 כדי לקבל מחרוזת מהמשתמש, ואז אני הולך לשאול את המשתמש לעוד אחד. 88 00:05:16,750 --> 00:05:21,870 ("תן לי את מחרוזת אחרת:") ואני רוצה לשאול אותם דרך GetString לקבל את זה. 89 00:05:21,870 --> 00:05:27,020 אני אתקשר אליו לא משום שלא באתי אחרי זה ואת זה הוא שם יפה למחרוזת אם זה דומה למדי. 90 00:05:27,020 --> 00:05:30,030 אז GetString, ועכשיו אני רק רוצה לעשות בדיקת שפיות ואני הולך לומר 91 00:05:30,030 --> 00:05:39,770 אם (הים == t) אז אני פשוט הולך לספר את משתמש printf ("אתה הקלדת את אותו הדבר \ n"); 92 00:05:39,770 --> 00:05:45,520 עוד אני הולך להדפיס משהו כמו ("אתה מוקלד משהו שונה! \ n") 93 00:05:45,520 --> 00:05:48,460 או מה שלא יהיה המשפט. אז משהו כזה. 94 00:05:48,460 --> 00:05:52,200 אז כרגיל, אני אחזיר 0 שרק סמלתי ששום דבר רע לא קרה, 95 00:05:52,200 --> 00:05:54,400 ואני הולך קדימה, לקמפל ולהריץ תכנית זו. 96 00:05:54,400 --> 00:05:56,540 >> אבל ביום שני רצנו תכנית זו, 97 00:05:56,540 --> 00:06:00,420 ובעצם נאמר להם ששלום הוא לא שלום ולהתראות לא להתראות. 98 00:06:00,420 --> 00:06:03,140 ההתנהגות שראינו הייתה קטן יותר כמו זה. 99 00:06:03,140 --> 00:06:11,450 תן לי ללכת לספריית המקור שלי, זום בכאן, ובואו עושים להשוות. 100 00:06:11,450 --> 00:06:14,570 מלוקט בסדר. תן לי לרוץ להשוות. תן לי את מחרוזת: שלום. 101 00:06:14,570 --> 00:06:16,300 תן לי את מחרוזת אחרת: שלום. 102 00:06:16,300 --> 00:06:18,000 הקלדת משהו שונה! 103 00:06:18,000 --> 00:06:22,650 ובכן, תן לי לנסות משהו פשוט יותר כמו 50, 50. הקלדת משהו שונה! 104 00:06:22,650 --> 00:06:25,740 היי, היי. אז ברור, משהו קורה כאן. 105 00:06:25,740 --> 00:06:28,440 אבל מה היה ההסבר למה? 106 00:06:28,440 --> 00:06:33,850 ככל הנראה, הקו 12 הוא לחלוטין לא מתפקד. 107 00:06:34,300 --> 00:06:39,430 מה הבעיה הבסיסית כאן? כן. >> [תלמיד] זה משווה את הכתובות. 108 00:06:39,430 --> 00:06:41,850 כן, בדיוק. זה באמת משווה את הכתובות 109 00:06:41,850 --> 00:06:44,580 שבו שלום ושלום מאוחסנים. 110 00:06:44,580 --> 00:06:48,290 זה לא משווה את האותיות שלום שוב ושוב, 111 00:06:48,290 --> 00:06:52,370 כי מה שבאמת קרה, כל הזמן הזה אנחנו כבר משתמשים GetString - 112 00:06:52,370 --> 00:06:56,130 לוח זה הוא שוב הזיכרון של המחשב שלנו, 113 00:06:56,130 --> 00:07:00,100 ונניח שאני קורא GetString לאחר ההכרזה של משתנה. 114 00:07:00,100 --> 00:07:01,930 מה הזיכרון שלי נראה? 115 00:07:01,930 --> 00:07:07,070 בואו נגיד שזה שרירותי נראה כך. זה ריבוע. 116 00:07:07,070 --> 00:07:09,040 ופחות או יותר כל פעם שאני נמשך פיסת הזיכרון על המסך 117 00:07:09,040 --> 00:07:12,860 אם זה 32 ביטים אני מצייר ריבועים כמו זה, כי אכן במכשיר, 118 00:07:12,860 --> 00:07:17,380 מצביע, כתובת, הוא 32 סיביים. זה אותו הדבר כמו int. 119 00:07:17,380 --> 00:07:19,420 זה עשוי להשתנות בהתאם למערכת מחשב. 120 00:07:19,420 --> 00:07:24,630 אלה מכם שאינם מוכרים לו את עובדה שMac או PC שלך הוא 64 סיביים, 121 00:07:24,630 --> 00:07:28,120 כי בעצם מציין שהמחשב שלך תוך שימוש במצביעים 64-bit, 122 00:07:28,120 --> 00:07:33,730 כתובות 64-bit, ובין upsides של שהמחשבים שלך 123 00:07:33,730 --> 00:07:35,560 יכול להיות הרבה יותר זיכרון RAM מאשר פעם. 124 00:07:35,560 --> 00:07:39,240 סיפור ארוך קצרים, חזרה ביום שבו השתמשו במחשבים 32 סיביים בלבד 125 00:07:39,240 --> 00:07:42,740 כדי לייצג את הכתובות, המספר הגדול ביותר של בתים שיכול לייצג 126 00:07:42,740 --> 00:07:46,280 במקרה זה היה מה אם יש לך 32 סיבי? 127 00:07:46,280 --> 00:07:49,590 אז 4 מליארד דולרים, נכון, כי 2 עד 32 הם 4 מיליארדים שקל. 128 00:07:49,590 --> 00:07:51,370 מספר זה כבר חוזר לקורס. 129 00:07:51,370 --> 00:07:55,240 >> אז אם יש לך 32 סיביים, רק את המספר הגבוה ביותר שאתה יכול לסמוך להוא בערך 4 מליארד שקל. 130 00:07:55,240 --> 00:07:58,750 אבל זה היה מגבלה בסיסית של מחשבים עד לפני כמה שנים 131 00:07:58,750 --> 00:08:01,180 כי אם אתה יכול לסמוך גבוה כמו שרק עד 4 מיליארדים, 132 00:08:01,180 --> 00:08:05,270 זה לא משנה אם אתה קונה 8 ג'יגה בייט של זכרון RAM או אפילו 5 ג'יגה בייט של זכרון RAM; 133 00:08:05,270 --> 00:08:07,780 אתה לא יכול לספור כל כך הרבה, אז זה היה חסר תועלת. 134 00:08:07,780 --> 00:08:11,430 אתה יכול לגשת ל3 או 4 ג'יגה הראשונה של זכרון המחשב שלך בלבד. 135 00:08:11,430 --> 00:08:14,410 זה פחות בעיה עכשיו, ואתה יכול לקנות יתרונות וDells MacBook 136 00:08:14,410 --> 00:08:17,680 עם 8 ג'יגה RAM של או אפילו יותר בימים אלה. 137 00:08:17,680 --> 00:08:24,100 אבל אם אני להקצות די פשוט בתכנית זו מצביעה, מצביע הנקרא הים, 138 00:08:24,100 --> 00:08:28,370 זה עשוי להיראות כך על המסך, כי אכן אנחנו צריכים לקלף שכבה זו. 139 00:08:28,370 --> 00:08:33,520 אני שומר את המחרוזת אומרת, אבל כמו של יום שני, המחרוזת היא באמת * char, 140 00:08:33,520 --> 00:08:35,590 הכתובת של דמות כלשהי. 141 00:08:35,590 --> 00:08:39,280 אז בואו ניקח את זה גלגל אימונים את למרות שאנחנו נמשיך להשתמש GetString לעת עתה. 142 00:08:39,280 --> 00:08:42,600 אז אני כבר הכרזתי הים, וזה נתח של זיכרון, 32 סיביות. 143 00:08:42,600 --> 00:08:47,370 מה יש בזה בזיכרון כברירת מחדל? >> [תגובת תלמיד לא נשמעה] 144 00:08:47,370 --> 00:08:50,040 מה זה? >> [תלמיד] אשפה. זבל. >> בדיוק. 145 00:08:50,040 --> 00:08:54,610 אם המתכנת לא לשים ערך במשתנה, מי יודע מה זה? 146 00:08:54,610 --> 00:08:57,990 לפעמים יש לך מזל וזה 0, שהוא סוג של ערך ברירת מחדל נחמד, נקי, 147 00:08:57,990 --> 00:09:00,310 אך כפי שראינו יום שני, לפעמים זאת שטות גמורה, 148 00:09:00,310 --> 00:09:04,130 חלק מספר חיובי או שלילי גדול באמת שהגיע משם? 149 00:09:05,350 --> 00:09:07,010 כן. >> [התלמיד] הפונקציה לפני. >> כן. 150 00:09:07,010 --> 00:09:10,170 >> לעתים קרובות פונקציה שקראה לי לפני כי יזכרו, 151 00:09:10,170 --> 00:09:13,920 כפי שאתם קוראים פונקציות בזיכרון, הם תופסים יותר ויותר מקום מלמטה למעלה, 152 00:09:13,920 --> 00:09:17,040 וברגע שמחזיר הפונקציה, שמקבל זכרון שימוש חוזר 153 00:09:17,040 --> 00:09:20,890 על ידי הבחור הבא שקורא, שמשתמש באותה הפרוסה של זיכרון שלך. 154 00:09:20,890 --> 00:09:23,450 ואם יש לך את אשפה שהותיר שם, ערכים קודמים, 155 00:09:23,450 --> 00:09:28,190 אנחנו עלולים לטעות של כבעל ערך כלשהו, ​​אם כי בעצם לא צריך לשים שום דבר שם. 156 00:09:28,190 --> 00:09:30,960 אז זכרון RAM שלנו בשלב זה נראה כך. 157 00:09:30,960 --> 00:09:36,030 עכשיו בצד הימני של קו 7 שאנחנו קוראים GetString, 158 00:09:36,030 --> 00:09:40,150 שאנחנו עושים עכשיו לשבועות, אבל מה היא באמת עושה GetString? 159 00:09:40,150 --> 00:09:43,350 GetString נכתב על ידי צוות CS50 הוא קצת אינטליגנטי 160 00:09:43,350 --> 00:09:46,500 שברגע שמשתמשים מפעיל מפתחות ולהיטים להקליד Enter, 161 00:09:46,500 --> 00:09:50,010 GetString דמויות מתוך כמה הקשות עשתה להיט המשתמש, 162 00:09:50,010 --> 00:09:53,360 כמה תווים אני צריך להקצות זכרון RAM ל. 163 00:09:53,360 --> 00:09:55,660 ואיפה שמגיע מהזיכרון RAM, מי יודע? 164 00:09:55,660 --> 00:09:58,930 זה איפשהו ב2 ג'יגה או מה שלא מזיכרון של המחשב. 165 00:09:58,930 --> 00:10:05,200 אבל בואו נניח שהמחשב מצא מקום למילת שלום ממש כאן. 166 00:10:05,200 --> 00:10:08,710 המילה שהקלדתי הייתה H-E-L-L-O. 167 00:10:08,710 --> 00:10:13,510 ואם אנו מפנים את זה כרצף של תווים, נוכל לצייר את זה ככה. 168 00:10:13,510 --> 00:10:17,860 אבל אני צריך לעשות דבר נוסף 1. מה שייך בסוף כל מחרוזת ב-C? 169 00:10:17,860 --> 00:10:20,710 תו null, שאנו כותבים כ\ 0. 170 00:10:20,710 --> 00:10:23,980 טכני זה המספר 0, אבל עושה את כל הקו הנטוי ברור יותר 171 00:10:23,980 --> 00:10:28,150 כי זה ממש את המספר 0, 0 השלמים; 172 00:10:28,150 --> 00:10:32,440 זה לא, למשל 0, במרכאות, כי ייתכן שתקלידו במקלדת. 173 00:10:32,440 --> 00:10:33,940 אז זה שלום. 174 00:10:33,940 --> 00:10:36,350 >> ומה שאנו אומרים ביום שני כי בפונקציה כמו GetString 175 00:10:36,350 --> 00:10:39,580 למעשה הוא חוזר כל השבועות האלה? 176 00:10:39,580 --> 00:10:43,960 זה לא חוזר מחרוזת כשלעצמה משום שלא באמת יש משמעות 177 00:10:43,960 --> 00:10:47,710 כי מייתרים לא קיימים. הם קצת ייצור בCS50 הספרייה. 178 00:10:47,710 --> 00:10:51,300 מה היא באמת מחרוזת, יותר מבחינה טכנית? >> [תלמיד] זה התו הראשון. 179 00:10:51,300 --> 00:10:55,950 בדיוק. זה די פשוט הכתובת של התו הראשון שמשתמש הקליד פנימה 180 00:10:55,950 --> 00:11:02,810 אז אם המילה שלי שלום מסתיים אותו ב 123 מספר בתים ולאחר מכן במספר בתי 124, 181 00:11:02,810 --> 00:11:08,320 125, 126, וכן הלאה, אם אני רק מספר הבתים שלי מ 0 ומעלה, 182 00:11:08,320 --> 00:11:12,650 מה באמת GetString חוזר הוא, פשוטו כמשמעו, 123 מספר. 183 00:11:12,650 --> 00:11:19,270 אז מה מוכנס זה הוא 123 מספר, ולא באות H, ולא במילת שלום, 184 00:11:19,270 --> 00:11:23,130 פשוט הכתובת שבה אני יכול למצוא את האות הראשונה של שלום. 185 00:11:23,130 --> 00:11:26,500 אבל זה לא נראה לך מספיק. שאלתי אותך למחרוזת, לא דמות. 186 00:11:26,500 --> 00:11:32,970 אז איך אנחנו או המחשב יודעים שello סוג של לבוא יחד עם H? 187 00:11:35,760 --> 00:11:37,460 מה הסוג של הסכם שיש לנו? כן. 188 00:11:37,460 --> 00:11:40,100 [תלמיד] זה כל זמן אומר לי עצמו כדי למצוא עוד כמה דמויות. >> בדיוק. 189 00:11:40,100 --> 00:11:44,570 >> יש אמנה זו מחשב האנושי לפיו כאשר יש לך עסק עם מחרוזות, 190 00:11:44,570 --> 00:11:49,410 הידוע כיום ככוכבי char, אתה פשוט צריך להבין 191 00:11:49,410 --> 00:11:54,350 איפה הסוף של כל מחרוזת בחיים הוא באמת רק על ידי iterating על זה עם ללולאה, 192 00:11:54,350 --> 00:11:57,820 לולאה בזמן, לא משנה מה, כך שכאשר אתה מוצא את סוף המחרוזת 193 00:11:57,820 --> 00:12:02,160 עכשיו אתה יכול להסיק מזה, הו, כל המילה הייתה שלום. 194 00:12:02,160 --> 00:12:04,820 אלה מכם עם ניסיון בתכנות מראש אולי יודעים בג'אווה 195 00:12:04,820 --> 00:12:09,880 אתה יכול פשוט להתקשר. אורך וגם בשפות אחרות אתה יכול לקרוא לאורך או דומה. 196 00:12:09,880 --> 00:12:14,060 זה בגלל בהרבה שפות, ובמיוחד דברים נקראים שפות מונחות עצמים, 197 00:12:14,060 --> 00:12:18,580 אורכו של דבר הוא סוג של בתוך מארז של פיסת המידע עצמו, 198 00:12:18,580 --> 00:12:24,000 הרבה כמו שאנחנו מזהים במארז ושמות ובתוך בתים של סטודנט ביום שני. 199 00:12:24,000 --> 00:12:28,700 אבל C היא רמה נמוכה בהרבה. אין אובייקטים או כיתות, אם שמעו את המונחים האלה קודם. 200 00:12:28,700 --> 00:12:31,490 כל מה שצריך באמת הוא כתובות זיכרון. 201 00:12:31,490 --> 00:12:35,540 אז זה סוג של הדרך המיושנת של ייצוג מבני נתונים מעניינים. 202 00:12:35,540 --> 00:12:38,760 יש לך ערך התחלה כמו הכתובת של התו הראשון 203 00:12:38,760 --> 00:12:42,340 ואז רק חלק מוסכמה שרירותית שכולם מסכים לעקוב אחריו. 204 00:12:42,340 --> 00:12:46,420 אז איך אורך מחרוזת מיושם, האם אנחנו מציעים? 205 00:12:46,420 --> 00:12:51,360 Strlen, strlen, שכמה מכם עכשיו השתמשו כמה פעמים. זה די פשוט, נכון? 206 00:12:51,360 --> 00:12:53,060 זה כמו 2 שורות קוד. 207 00:12:53,060 --> 00:12:56,140 זה די הרבה ללולאה כלשהי, אולי עם משתנית מקומי נוספת. 208 00:12:56,140 --> 00:13:00,540 אבל strlen פשוט צריך לקחת מצביע ולאחר מכן להתחיל לחפש \ 0. 209 00:13:00,540 --> 00:13:05,190 >> וברגע שהוא מוצא אותו, הוא יכול להחזיר את המספר הכולל של צעדים שננקטו בזה שחוט. 210 00:13:05,190 --> 00:13:07,150 אז אנחנו יכולים להסיק מזה מה שקורה בא. 211 00:13:07,150 --> 00:13:11,850 תניחו אם אני מצהיר לא כפי שעשיתי בקו 10. 212 00:13:11,850 --> 00:13:14,280 זה קצת ערך זבל. מי יודע בהתחלה? 213 00:13:14,280 --> 00:13:18,490 אבל בצד הימני של שורה של 10 אני מתקשר GetString שוב. 214 00:13:18,490 --> 00:13:20,050 מי יודע לאן זה יגיע? 215 00:13:20,050 --> 00:13:23,830 בואו שרירותי להגיד שמערכת ההפעלה מצאה מקום לזה בדרך לכאן. 216 00:13:23,830 --> 00:13:28,610 אני במקרה במקרה לסוג H-E-L-L-O שוב, 217 00:13:28,610 --> 00:13:31,260 וכדי שנוכל לצייר את אותו סוג של תמונה. 218 00:13:31,260 --> 00:13:34,290 אבל העובדה שיש לי את התמונה הזאת צוירה מחדש היא מכוונת 219 00:13:34,290 --> 00:13:37,720 כי זה שונה שלום יותר מזאת. 220 00:13:37,720 --> 00:13:43,920 אז הנה זה יכול להיות מיקום 456, זה 457, וכן הלאה. 221 00:13:43,920 --> 00:13:47,170 אז מה מקבל במקום של סימן השאלה שהיה בעבר? 222 00:13:47,170 --> 00:13:50,190 במקרה זה 456. 223 00:13:50,190 --> 00:13:53,540 אנחנו קולטים את המספרים האלה באופן שרירותי כי באמת שאחרי היום 224 00:13:53,540 --> 00:13:57,110 אנחנו לא הולכים כל כך אכפת מה הכתובת של דבר הוא. 225 00:13:57,110 --> 00:14:02,690 כל אכפת לנו הוא שאנחנו יכולים להבין את הכתובת של קטע מסוים של נתונים כמו שלום. 226 00:14:02,690 --> 00:14:07,100 >> אז באמת מה שרוב האנשים עושים במדעי מחשב כאשר מדברים על כתובות זיכרון 227 00:14:07,100 --> 00:14:10,210 ומדבר על מצביעים באופן ספציפי, 228 00:14:10,210 --> 00:14:14,220 ולא טרח לגלות 123 - למי אכפת איפה החומר הזה הוא למעשה, 229 00:14:14,220 --> 00:14:17,440 אנחנו רק יודעים שזה בחלק הכתובת מספרית - 230 00:14:17,440 --> 00:14:22,180 לפשטנו את העולם, ורק אומרים שזה מצביע שלאופי 231 00:14:22,180 --> 00:14:25,080 ולא מצביע על הדמות. 232 00:14:25,080 --> 00:14:27,430 והעובדה שזה חץ היא די מכוונת 233 00:14:27,430 --> 00:14:31,610 כי ממש עכשיו שלו מצביע על H ולא מצביע בH האחר 234 00:14:31,610 --> 00:14:34,720 מכיוון שבסופו של היום, זה לא משנה מה היא הכתובת, 235 00:14:34,720 --> 00:14:40,240 אבל זה עניין שיש לנו את היכולת להביע את הכתובה שעם חלק כלשהו של קוד. 236 00:14:40,240 --> 00:14:42,730 אנחנו לא באמת יש מניפולציות כתובות אלה עדיין 237 00:14:42,730 --> 00:14:47,770 כך אוכל לראות איפה אנחנו יכולים להתערב ולמיין של לעשות דברים עם מצביעים, 238 00:14:47,770 --> 00:14:52,030 אך לעת עתה בקו 12, פשוטו כמשמעו, מה ערכים שאנחנו משווים 239 00:14:52,030 --> 00:14:55,500 על פי הסיפור הזה בקו 12? 240 00:14:56,570 --> 00:15:01,290 אנחנו אומרים הוא 123 שווה שווים 456? וזה בהחלט לא מקרה. 241 00:15:01,290 --> 00:15:05,320 וגם רעיוני, מצביע זה בהחלט לא אותו הדבר כמו זה 242 00:15:05,320 --> 00:15:09,500 משום שהתקשרת GetString פעמים, וGetString אינו מנסה להיות סופר מתוחכם, 243 00:15:09,500 --> 00:15:12,470 זה לא לנסות להבין, הו, שהקלדת שלום לפני 5 דקות; 244 00:15:12,470 --> 00:15:15,090 תן לי לתת לך את אותו מצביע כמו שנתתי לך לפני, 245 00:15:15,090 --> 00:15:18,450 זה פשוט מקצה נתח חדש של זיכרון בכל פעם שאתה קורא לזה. 246 00:15:18,450 --> 00:15:20,350 >> אז איך לתקן את הבעיה הזו? 247 00:15:20,350 --> 00:15:24,270 אם רמה גבוהה יותר אני רוצה להשוות את מייתרי שלום ושלום - 248 00:15:24,270 --> 00:15:28,680 לא אכפת לי על המצביעים - איך אני הולך על תשובה לשאלה, 249 00:15:28,680 --> 00:15:31,980 לא למשתמש להקליד את אותו הדבר? מה שדרוש כאן? כן. 250 00:15:31,980 --> 00:15:35,200 [תלמיד] להשתמש בפונקציה. >> אני יכול להשתמש בפונקציה מחוץ לקופסה. 251 00:15:35,200 --> 00:15:38,170 אני יכול להשתמש בפונקציה שנקראת strcmp, s-t-r-c-מ-p, 252 00:15:38,170 --> 00:15:41,190 רק הגרסה המקוצרת של אומר מחרוזת להשוות. 253 00:15:41,190 --> 00:15:45,070 ואם אנחנו נכנסים, למשל, להשוות 2, שהוא בין דפי המידע של היום, 254 00:15:45,070 --> 00:15:46,690 אני עושה בדיוק את זה. 255 00:15:46,690 --> 00:15:51,750 שמרתי כל דבר אחר מאותו הקו 1 בעד 26 או כך, 256 00:15:51,750 --> 00:15:54,360 ועכשיו שם לב חלק זה השתנה קצת. 257 00:15:54,360 --> 00:15:57,690 בואו נתעלם מקו 28 לרגע ולהתמקד רק בזה. 258 00:15:57,690 --> 00:16:00,410 מה שאנחנו אומרים היום כי str compare עושה? 259 00:16:00,410 --> 00:16:05,200 הוא מטפל בתהליך של לקיחת 2 מצביעים, הים ולא במקרה זה, 260 00:16:05,200 --> 00:16:08,480 סוג של כמעט הניח את האצבע שלה על 2 המכתבים האלה, 261 00:16:08,480 --> 00:16:11,530 ומה עליה לעשות הוא משהו כמו לולאה בזמן או ללולאה, 262 00:16:11,530 --> 00:16:16,050 וזה אומר הם אלה את אותו הדבר? אם כך, זה מעביר את האצבעות או את המצביעים קדימה. 263 00:16:16,050 --> 00:16:17,970 האם אלה זהים, אלה זהים, אלה זהים, 264 00:16:17,970 --> 00:16:22,710 אלה זהים, אלה זהים? ואווה, אני בסוף המחרוזת בהן של ולא. 265 00:16:22,710 --> 00:16:26,780 אני לא מצאתי סתירות. כן, המחרוזות הללו הן אותו הדבר. 266 00:16:26,780 --> 00:16:31,940 ומה str להשוות תמורה אם 2 מחרוזות זהות, כנראה? אפס. 267 00:16:31,940 --> 00:16:35,900 אז 0 הם טוב במקרה זה, כי אם היא מחזירת -1 או +1, 268 00:16:35,900 --> 00:16:40,560 זה אומר שזה קורה רק כדי לבוא לפני לא בסדר אלפביתי או לאחר לא. 269 00:16:40,560 --> 00:16:43,760 ולמה שזה יהיה שימושי יש פונקציה שאומרת לך שבאה לפני מחרוזת 270 00:16:43,760 --> 00:16:46,720 או לאחר במילון? 271 00:16:46,720 --> 00:16:48,740 [תלמיד] חיפוש. >> חיפוש ומיון. 272 00:16:48,740 --> 00:16:51,730 >> אז אתה יכול לעשות דברים כמו חיפוש בינארי או מיון בועות או למזג מיון 273 00:16:51,730 --> 00:16:53,230 בו אתה צריך להשוות את הדברים. 274 00:16:53,230 --> 00:16:56,420 עד כה יש לנו סוג של לחתוך כמה פינות ודברו רק על מיון 275 00:16:56,420 --> 00:16:59,430 בהקשר של מספרים כי זה נחמד וקל לדבר עליו, 276 00:16:59,430 --> 00:17:02,430 אבל אתה בהחלט יכול להשוות מחרוזות, תפוח ובננה, 277 00:17:02,430 --> 00:17:05,349 כי אם התפוח ידוע לבוא לפני הבננה, באופן דומה, 278 00:17:05,349 --> 00:17:09,319 אתה יכול להעביר את מחרוזות בזיכרון בדיוק כמו רוב עשתה עם מעין מיזוג בוידאו 279 00:17:09,319 --> 00:17:15,880 ושעשינו כאן על במה עם מיון בחירה, מיון הכנסה, ומיון בועות. 280 00:17:15,880 --> 00:17:18,710 אז איפה עוד אנחנו יכולים לקחת את זה? בואו ננסה את זה. 281 00:17:18,710 --> 00:17:23,980 סוג של בואו אשכח משיעור זה לרגע ואנסה עכשיו ולהעתיק 1.c לבצע את הפעולות הבאות. 282 00:17:23,980 --> 00:17:26,800 בקו 21 שאני אומר משהו להדפסה, 283 00:17:26,800 --> 00:17:28,520 אז אני מקבל מחרוזת מהמשתמש, 284 00:17:28,520 --> 00:17:30,690 אז אני בודק את זה. 285 00:17:30,690 --> 00:17:33,620 אנחנו לא ממש נכנסנו להרגל הזה, אבל באים נעשה את זה עכשיו. 286 00:17:33,620 --> 00:17:40,990 בואו ממש לקלף שכבה זו. זה באמת * char. הבחור הזה הוא באמת * char. 287 00:17:40,990 --> 00:17:45,690 אז מה זה אומר שיש לבדוק אם של == NULL? 288 00:17:45,690 --> 00:17:48,380 מסתבר שכאשר אתה קורא לפונקציה כמו GetString 289 00:17:48,380 --> 00:17:51,540 או באופן כללי יותר פשוט לשאול את מחשב כדי לתת לך קצת זיכרון, 290 00:17:51,540 --> 00:17:53,030 משהו יכול להשתבש. 291 00:17:53,030 --> 00:17:56,630 אתה יכול להיות מטורף ושאלת את המחשב לטרה של זיכרון 292 00:17:56,630 --> 00:18:01,780 על ידי מבקש טריליון בייטים של זיכרון, שפשוט לא קיימים במחשב, 293 00:18:01,780 --> 00:18:05,130 אבל פונקציות GetString ואחרים זקוקים לדרך צעק עליך 294 00:18:05,130 --> 00:18:06,820 אם בקשת יותר מדי. 295 00:18:06,820 --> 00:18:10,450 ודרך GetString עושה את זה היא אם יש לך שאלה על זיכרון יותר 296 00:18:10,450 --> 00:18:14,250 מ זמין במחשב, גם אם זה הסתברות סופר, סופר נמוכה 297 00:18:14,250 --> 00:18:17,730 כי אף אחד מאיתנו הולכים הקלד טריליון תווים ולאחר מכן על Enter, 298 00:18:17,730 --> 00:18:21,980 אבל הסתברות נמוכה ככל שיהיה, אני עדיין רוצה לבדוק את זה רק במקרה, 299 00:18:21,980 --> 00:18:26,120 והערך המיוחד שGetString, תשובה, ופונקציות אחרות חוזר 300 00:18:26,120 --> 00:18:30,630 אם משהו השתבש הוא NULL בכל הכמוסות. 301 00:18:30,630 --> 00:18:36,520 >> ומה הוא NULL? NULL פשוט קורה כל כך לייצג את מצביע. זה 0 כתובת זיכרון. 302 00:18:36,520 --> 00:18:40,800 העולם החליט כי באופן שרירותי, אם זה הזיכרון של המחשב שלי - אתה יודע מה? - 303 00:18:40,800 --> 00:18:46,260 אנחנו הולכים לגנוב רק בית 1 של הזיכרון של כל מחשב, וזה מיקום 0. 304 00:18:46,260 --> 00:18:49,560 אנחנו הולכים לתת לו כינוי של NULL, ואנחנו הולכים למבטיחים 305 00:18:49,560 --> 00:18:52,660 כי אנחנו למעשה לעולם לא לשים את נתונים אמיתיים שיש 306 00:18:52,660 --> 00:18:56,770 כי אנחנו פשוט צריכים שרירותי ערך מיוחד, 0, NULL aka, 307 00:18:56,770 --> 00:19:00,230 כדי שנוכל לצעוק על משתמשים אם משהו משתבש. 308 00:19:00,230 --> 00:19:03,590 אחרת אתה אולי לא יודע את זה 0 מתכוונים לשים משהו כאן 309 00:19:03,590 --> 00:19:05,490 או זה אומר שמשהו השתבש? 310 00:19:05,490 --> 00:19:09,190 יש לנו את כל להסכים שדבר אמצעי NULL הוחזר, 311 00:19:09,190 --> 00:19:11,700 אין כתובת בפועל הוחזרה. 312 00:19:11,700 --> 00:19:15,210 עכשיו, הנה אני רק אימוץ האמנה האנושית שלי אני חוזר 1 מ עיקרי 313 00:19:15,210 --> 00:19:17,040 אם משהו משתבש. 314 00:19:17,040 --> 00:19:20,650 זה בגלל חזרתו של הכנס העיקרי הוא להחזיר 0 אם טוב, 315 00:19:20,650 --> 00:19:22,990 1 או ערך אחר אם רע. 316 00:19:22,990 --> 00:19:28,200 אבל GetString וכל פונקציה העוסק בהחזרי זכרון NULL אם משהו מתקלקל. 317 00:19:28,200 --> 00:19:33,480 >> אוקיי. אז, למרבה הצער, 27 קו, סופר פשוט ככל שיהיה, נכשל לחלוטין להעתיק את המחרוזת. 318 00:19:33,480 --> 00:19:35,740 למה? אנחנו יכולים לראות את זה באופן בא. 319 00:19:35,740 --> 00:19:40,120 אני טוען בקו 27 ליצירת עותק של הים וקורא לזה לא. 320 00:19:40,120 --> 00:19:45,790 אז אני לא מבקש מהמשתמש 2 מחרוזות הפעם; אני רק אומר את הערך בים 321 00:19:45,790 --> 00:19:47,870 יש לשים בt גם כן. 322 00:19:47,870 --> 00:19:52,890 אז עכשיו רק כדי להדגים כיצד שבור הזה הוא, בשורת 29 ואילך מה אני עושה? 323 00:19:52,890 --> 00:19:56,980 קודם אני בודק אם האורך של t הוא גדול מ 0. 324 00:19:56,980 --> 00:19:59,330 יש איזה חוט שם. משתמש קליד משהו פנימה 325 00:19:59,330 --> 00:20:03,410 מהו קו 32 עושים, כנראה? 326 00:20:03,410 --> 00:20:08,910 [תגובה בלתי נשמעת תלמיד] ימנית. >> אתה סוג של יכול להסיק מזה מה שאמרתי שהוא עושה. 327 00:20:08,910 --> 00:20:13,200 אבל מבחינה טכנית, מה זה עושה? t [0] מייצג את מה? 328 00:20:13,200 --> 00:20:15,140 [תלמיד] דמות 0. >> [מלאן] דמות 0. 329 00:20:15,140 --> 00:20:19,620 או, יותר דמוי אדם, התו הראשון בt, מה שזה, H אולי במקרה זה. 330 00:20:19,620 --> 00:20:24,990 וtoupper עושה מה שהוא אומר. הוא מנצל את האופי של 0 t והוא משנה אותו. 331 00:20:24,990 --> 00:20:28,430 אז זה אומר לקחת את הדמות של 0 t, להפוך אותו לאותיות רישיות, 332 00:20:28,430 --> 00:20:30,320 והחזיר אותו באותו מיקום. 333 00:20:30,320 --> 00:20:35,540 אז אם אני מקליד שלום באותיות קטנות, זה אמור לשנות את האותיות הקטנות h ל"א 334 00:20:35,540 --> 00:20:41,400 אבל הבעיה היא שבקווי 35 ו 36 מה שאני עומד לעשות הוא להדפיס עבורנו זה ולא. 335 00:20:41,400 --> 00:20:43,120 ומה הקטע שלך? 336 00:20:43,120 --> 00:20:47,250 מה בעצם אני הולך לראות אם הקלדתי בשלום בכל האותיות קטנות? 337 00:20:47,250 --> 00:20:52,280 מה קורה ליודפס? >> [תגובת תלמיד לא נשמעה] >> מה זה? 338 00:20:52,280 --> 00:20:58,360 [תלמיד] ביג H והשאר קטן. >> הגדול H והשאר הקטן עבורו, או של t? 339 00:20:58,360 --> 00:21:03,170 [תלמיד] גם וגם. >> גם וגם. בדיוק. אז בואו לראות מה קורה כאן. 340 00:21:03,170 --> 00:21:08,380 >> תן לי ללכת קדימה ולקמפל את זה. זה COPY1, אז לעשות את COPY1. בסדר. 341 00:21:08,380 --> 00:21:14,840 זום פנימה תן לי ללכת קדימה ולהפעיל COPY1, Enter, תגיד משהו: שלום באותיות קטנות. 342 00:21:14,840 --> 00:21:19,570 זה מהוון את העותק, אבל זה כנראה גם מהוון מקורי, 343 00:21:19,570 --> 00:21:22,070 כי מה שקורה עכשיו בסיפור הזה? 344 00:21:22,070 --> 00:21:27,030 בקו 27 שלא ממש נראה שהעתקת המחרוזת, 345 00:21:27,030 --> 00:21:30,450 אבל למרות שאתה יכול לקוות באופן אינטואיטיבי שכדי להיות במקרה, 346 00:21:30,450 --> 00:21:33,680 אם אתם חושבים על התמונה הזאת, מה באמת עשיתי? 347 00:21:33,680 --> 00:21:35,410 חצי מהתמונה הוא אותו הדבר. 348 00:21:35,410 --> 00:21:39,390 אז בואו גלגל אחורה בזמן, כדי שלא עדיין לא קיים בסיפור. 349 00:21:39,390 --> 00:21:43,160 S יכול להתקיים בסיפור, אבל בואו אותיות קטנה שלום שלב זה. 350 00:21:43,160 --> 00:21:46,710 אז בואו תתקנו אותי מה אני הקלדתי ממש פנימה 351 00:21:46,710 --> 00:21:51,280 במקרה זה יש לנו כאן h-E-l-l-o. 352 00:21:51,280 --> 00:21:58,050 אנחנו לצייר אותו כרצף של תווים, לשים קווים המפרידים שלי כאן ו\ 0 שלי. 353 00:21:58,050 --> 00:22:05,980 אז זה המקום שאנחנו נמצאים ברגע ששורה 1 עד 24 איש, פחות או יותר, שהוצא להורג. 354 00:22:05,980 --> 00:22:07,800 זו תמונה של זכרוני. 355 00:22:07,800 --> 00:22:10,800 כשאני מגיע לקו 27, מה קורה? 356 00:22:10,800 --> 00:22:14,730 בדיוק כמו קודם, אני מקבל מצביע, שאני יהיה לצייר כריבוע הזה. 357 00:22:14,730 --> 00:22:19,740 זה נקרא לא. ומה הערך שלה כברירת מחדל? מי יודע? איזה ערך זבל. 358 00:22:19,740 --> 00:22:22,060 >> אז אני מופשט שמרחק כסימן שאלה. 359 00:22:22,060 --> 00:22:27,670 וברגע שהצד הימני של קו 27 מבצע, מה אני מכניס בפנים של t? 360 00:22:27,670 --> 00:22:30,770 אותו הדבר זה בזה. 361 00:22:30,770 --> 00:22:34,120 אז אם לרגע להסיר הפשטה זו של החץ ואנחנו אומרים, 362 00:22:34,120 --> 00:22:40,330 הו, זו כתובת עומס זיכרון 123, כשאתה אומר לא מקבל s, פסיק, 363 00:22:40,330 --> 00:22:42,700 אתה ממש מכניס לי 123 כאן. 364 00:22:42,700 --> 00:22:45,200 עכשיו, אם אנחנו סוג של לפשט את עולמנו שוב עם תמונות, 365 00:22:45,200 --> 00:22:48,750 מה באמת עשית רק הוסיף חץ נוסף לעולם שלך 366 00:22:48,750 --> 00:22:52,910 שמצביע מלא לאותה המחרוזת מדויקת. 367 00:22:52,910 --> 00:22:59,730 לכן, כאשר בקו 31 ו 32, אני גם יוצא על שינוי t [0], 368 00:22:59,730 --> 00:23:05,580 מה היא לא [0] שם נרדף לעכשיו? s [0] 369 00:23:05,580 --> 00:23:07,030 כך שכל מה שקורה זה. 370 00:23:07,030 --> 00:23:09,900 ואף על פי שזה סוג של מרגיש רמה נמוכה מעט ומסתורי 371 00:23:09,900 --> 00:23:12,760 וזה סוג של מרגיש אינטואיטיבית אולי זה היה צריך להיות פשוט עבד - 372 00:23:12,760 --> 00:23:15,410 עשיתי העתקים של דברים בעבר וזה פשוט עבד - 373 00:23:15,410 --> 00:23:18,590 אם אתה באמת חושב על מה שבאמת היא מחרוזת, זה * char. 374 00:23:18,590 --> 00:23:21,700 ובכן, מה זה? זה את הכתובת של דמות כלשהי. 375 00:23:21,700 --> 00:23:24,930 אז אולי זה הגיוני יותר שכשאתה מנסה לעשות משהו 376 00:23:24,930 --> 00:23:29,220 סופר פשוט לכאורה כמו זה, כל מה שאתה עושה הוא העתקת כתובת זיכרון. 377 00:23:29,220 --> 00:23:32,530 אתה לא ממש עושה שום דבר עם המחרוזת עוצמה. 378 00:23:32,530 --> 00:23:37,500 אז גם אם אין לך מושג איך אתה היה פותר את הבעיה בקוד, 379 00:23:37,500 --> 00:23:45,080 רמה גבוהה מבחינה רעיונית, מה שאנחנו צריכים לעשות על מנת להפוך את ת"א עותק אמיתי של הים, כנראה? 380 00:23:46,670 --> 00:23:48,820 כן. >> [תלמיד] תן אותו למיקום חדש? >> בדיוק. 381 00:23:48,820 --> 00:23:50,800 >> אנחנו צריכים לתת t מיקום חדש. 382 00:23:50,800 --> 00:23:55,230 אנחנו צריכים איכשהו ליצור עולם שבו אנחנו מקבלים נתח חדש של זיכרון, 383 00:23:55,230 --> 00:24:00,090 אשר רק למען הבהירות אני אצייר ממש מתחת לזה, אבל זה לא צריך להיות שם. 384 00:24:00,090 --> 00:24:04,880 אבל זה צריך להיות באותו הגודל, אז אני לצייר הקווים אנכיים האלה באותו המקום. 385 00:24:04,880 --> 00:24:09,720 זה בסדר אם זה כל הזבל בתחילה. מי יודע מה הייתה שם? 386 00:24:09,720 --> 00:24:13,850 אבל השלב 1 הולך צריך לתת לי אותה כמות זיכרון שאני צריך 387 00:24:13,850 --> 00:24:18,630 כדי להתאים עותק של שלום, ואז להבין איך להעתיק h כאן, הדואר כאן, 388 00:24:18,630 --> 00:24:20,390 אני כאן וכן הלאה. 389 00:24:20,390 --> 00:24:24,880 אבל את זה כבר צריך להרגיש קצת ברור גם אם חלק מהפרטים עדיין מופשט. 390 00:24:24,880 --> 00:24:28,690 כדי להעתיק מחרוזת זו לתוך זה, זה רק ללולאה או לולאה בזמן 391 00:24:28,690 --> 00:24:31,580 או משהו שאיתו הפך לעוד יותר מוכרת. 392 00:24:31,580 --> 00:24:35,970 אז בואו ננסה את זה. תן לי ללכת לcopy2.c. 393 00:24:35,970 --> 00:24:43,270 בcopy2.c יש לנו כמעט את אותה תכנית, פרט לקו 27. 394 00:24:43,270 --> 00:24:47,260 זה נראה קצת מורכב, אבל אם לפרק אותו חתיכה אחרי חתיכה, 395 00:24:47,260 --> 00:24:48,950 הצד השמאלי הוא זהה. 396 00:24:48,950 --> 00:24:52,790 Char * לא יוצר את הדבר הזה בזיכרון, אם כי עם סימן שאלה 397 00:24:52,790 --> 00:24:54,680 כי אין לנו מושג מה היא שם כברירת מחדל. 398 00:24:54,680 --> 00:24:57,920 בצד הימני שעכשיו אנחנו מציגים פונקצית malloc חדשה, 399 00:24:57,920 --> 00:25:00,640 לזיכרון יקצה, תן לי בזיכרון, 400 00:25:00,640 --> 00:25:06,900 וזה כנראה לוקח כמה ויכוחים, כמה דברים בתוך סוגריים? 401 00:25:09,660 --> 00:25:12,130 שמעתי מלמולים של 1 ו 2, אבל זה רק 1. 402 00:25:12,130 --> 00:25:15,320 אין פסיק, מה שאומר שיש רק דבר 1 בתוך הסוגריים. 403 00:25:15,320 --> 00:25:17,720 למרות שיש סוגריים אחרים, הרשו לי להדגיש 404 00:25:17,720 --> 00:25:21,460 מה שבפנים בסוגריים החיצוניים ביותר, וזה ביטוי זה: 405 00:25:21,460 --> 00:25:25,880 (Strlen (s) + 1) * sizeof (char). 406 00:25:25,880 --> 00:25:29,190 אז אם אנחנו באמת חושבים שזו דרכו, שזה אומר לתת לי אורך של הים. 407 00:25:29,190 --> 00:25:34,440 למה שאני, והוספתי 1 על האורך? >> [תגובת תלמיד לא נשמעה] 408 00:25:34,440 --> 00:25:40,200 בדיוק. אנו זקוקים למקום לבחור הזה בזנב, דמות 6 שאין לו משמעות באנגלית 409 00:25:40,200 --> 00:25:42,250 אבל האם יש משמעות מיוחדת תוכניתית. 410 00:25:42,250 --> 00:25:46,800 >> אז אנחנו צריכים + 1 עבור שבגלל תשואות strlen הציפייה האנושית של אורך, 411 00:25:46,800 --> 00:25:50,890 שלום או 5, זה לא נותן לך תו null הנוסף. 412 00:25:50,890 --> 00:25:52,980 אז להוסיף באופן ידני את זה עם + 1. 413 00:25:52,980 --> 00:25:56,060 ואז זה, גודל של * (char), שלא ראו את זה קודם. 414 00:25:56,060 --> 00:25:57,480 זה לא טכני פונקציה. 415 00:25:57,480 --> 00:26:04,150 זה מילת מפתח מיוחדת שרק אומרת לך מה הוא הגודל של כמה סוג נתונים במחשב 416 00:26:04,150 --> 00:26:06,980 כי במציאות, חלק מאיתנו יש מחשבים של 32-bit. 417 00:26:06,980 --> 00:26:10,900 יש לי מחשב די ישן בבית, והיא משתמשת רק 32 ביטים לייצג מצביעים. 418 00:26:10,900 --> 00:26:13,900 ואז אם אני עשיתי גודל של סוג נתונים, זה יכול להיות 32 סיבי. 419 00:26:13,900 --> 00:26:18,300 אבל אם אני משתמש במחשב המפואר החדש שלי, אני יכול לחזור ערך של 64 סיביים 420 00:26:18,300 --> 00:26:20,510 למשהו כמו כתובת. 421 00:26:20,510 --> 00:26:25,400 אז במקרה הזה, רק כדי להיות בטוח במיוחד, אנחנו לא מתכוונים למשהו קוד קשה כמו - 422 00:26:25,400 --> 00:26:28,740 טוב, מה הוא בגודל של פי מה שאמר לנו עד כה char? 423 00:26:28,740 --> 00:26:34,450 פחות או יותר יש לנו אמרנו בע"פ שזה הבית 1, וזה פחות או יותר נכון על פני הלוח. 424 00:26:34,450 --> 00:26:37,000 אבל שוב, הנחות נוטות להיות רע. 425 00:26:37,000 --> 00:26:40,850 הם מובילים לתוכנת מרכבה אם אנשים משתמשים בתוכנה שלך בדרכים שאתה לא מתכוון. 426 00:26:40,850 --> 00:26:44,750 אז בואו המופשט הזה משם ופשוט יותר הגנרי אומרים 427 00:26:44,750 --> 00:26:46,830 אני זקוק להרבה חתיכות של זיכרון 428 00:26:46,830 --> 00:26:50,210 וכל חתיכה של זיכרון צריכה להיות שווה ערך לגודל של דמות, 429 00:26:50,210 --> 00:26:54,870 שהוא בעצם שווה ל 1 במקרה הזה, אבל זה דרך כללית יותר של כתיבתו. 430 00:26:54,870 --> 00:27:00,460 אז אם המילה היא שלום, כמה בתים לא malloc כנראה להקצות לשלום? 431 00:27:00,460 --> 00:27:04,980 [תלמיד] שישה ימים. >> שישה ימים. בדיוק רב כמו שיש לנו סימני שאלה על המסך. 432 00:27:04,980 --> 00:27:07,800 ואז לקחת לנחש עכשיו מבוסס על ההבנה שלך GetString 433 00:27:07,800 --> 00:27:12,790 מה malloc כנראה לחזור? >> [תלמיד] כתובת. 434 00:27:12,790 --> 00:27:17,020 כתובת של מה? של הגוש הראשון של זיכרון. 435 00:27:17,020 --> 00:27:20,670 >> אין לנו מושג מה יש שם, מפני שחלק תפקיד אחר 436 00:27:20,670 --> 00:27:23,010 אפשר היה להשתמש בזיכרון הזה בעבר. 437 00:27:23,010 --> 00:27:28,380 אבל malloc, כמו GetString, מחזיר את הכתובת של הבית הראשון של זיכרון 438 00:27:28,380 --> 00:27:30,540 שיש להפריש עבורך. 439 00:27:30,540 --> 00:27:38,380 עם זאת, מה זה לא לעשות הוא למלא את הפער הזה עם תו null קו נטוי 440 00:27:38,380 --> 00:27:43,030 כי מסתבר שאתה יכול להשתמש malloc להקצות כל דבר: ints, מחרוזות, מערכים, 441 00:27:43,030 --> 00:27:45,700 צף, מבני סטודנטים. 442 00:27:45,700 --> 00:27:47,750 אתה יכול להשתמש בשמה הגנרי malloc לחלוטין. 443 00:27:47,750 --> 00:27:51,470 זה לא אכפת או צריך לדעת מה אתה הקצאת זיכרון ל. 444 00:27:51,470 --> 00:27:55,810 כך שזה יהיה חצוף מצד malloc לשים \ 0 445 00:27:55,810 --> 00:27:58,340 בסוף כל נתח של זיכרון זה נותן לך 446 00:27:58,340 --> 00:28:02,620 בגלל \ 0 הדבר הזה הוא פשוט אמנה למייתרים. 447 00:28:02,620 --> 00:28:06,310 זה לא משמש לints, זה לא משמש לצפים, זה לא משמש לתלמידים. 448 00:28:06,310 --> 00:28:11,730 וכך תפס אותך עם malloc הוא שהניטל הוא לחלוטין עליך המתכנת 449 00:28:11,730 --> 00:28:16,790 לזכור כמה בתים שהוקציתם ולא פעם להשתמש בלולאה 450 00:28:16,790 --> 00:28:21,570 או לולאה בזמן ועובר את הגבול מגוש הזיכרון שניתן לכם. 451 00:28:21,570 --> 00:28:23,540 במילים אחרות, ברגע שאתה להקצות זיכרון, 452 00:28:23,540 --> 00:28:28,510 אתה לא יכול לבקש ממערכת ההפעלה, הו, דרך אגב, כמה גדול מנתח של זיכרון זה היה? 453 00:28:28,510 --> 00:28:32,080 זה לגמרי תלוי בך לזכור אם אתה צריך את הערך. 454 00:28:32,080 --> 00:28:34,330 >> אז בואו לראות איך אני ממשיך להשתמש בזיכרון הזה. 455 00:28:34,330 --> 00:28:38,430 בקו 28 ו 29 למה אני עושה את זה? 456 00:28:39,850 --> 00:28:42,260 סך הכל רק לבדוק את השפיות. 457 00:28:42,260 --> 00:28:45,110 רק למקרה שמשהו ישתבש, אני מבקש ממך כמות מטורפת של זיכרון 458 00:28:45,110 --> 00:28:48,690 או יש לי כל כך הרבה דברים פועלים במחשב שפשוט אין מספיק זיכרון, 459 00:28:48,690 --> 00:28:51,780 משהו כזה, אני לפחות רוצה לבדוק לאפס. 460 00:28:51,780 --> 00:28:55,260 במציאות, רוב המחשבים ינתנו לך את האשליה שכל תכנית 461 00:28:55,260 --> 00:28:57,080 ניתן להשתמש במכלול של זכרון RAM שלך, 462 00:28:57,080 --> 00:29:00,740 אבל אפילו כך, אם המשתמש מקליד בחלק המחרוזת ארוכה מטורפת אולי בגלל שהם רעים 463 00:29:00,740 --> 00:29:03,440 והם באמת מנסים לקרוס התכנית או הגרזן שלך לתוך זה, 464 00:29:03,440 --> 00:29:07,300 אתה רוצה לפחות לבדוק את ערך ההחזרה של malloc והאם זה שווה אפס. 465 00:29:07,300 --> 00:29:11,630 ואם כן, בואו פשוט להפסיק ברגע זה, כי אני לא יודע מה לעשות במקרה זה. 466 00:29:11,630 --> 00:29:13,950 כיצד ניתן להעתיק את המחרוזת? יש כמה דרכים לעשות זאת. 467 00:29:13,950 --> 00:29:18,850 יש str להעתיק פונקציות ב-C, אבל זה סופר פשוט לנו לעשות בדרך הישנה הזה. 468 00:29:18,850 --> 00:29:23,110 >> ראשית הרשה לי להבין מה אורכו של הים הוא. 469 00:29:23,110 --> 00:29:26,930 הייתי יכול לשים את זה בלולאה, אבל במקום זה אני פשוט שמתי אותו כאן לבהירות. 470 00:29:26,930 --> 00:29:30,610 אז n כעת מאחסן את האורך של המחרוזת המקורית, שהוא כנראה 5. 471 00:29:30,610 --> 00:29:35,290 ואז בלולאה עבורי אני iterating מ 0 בעד n, 472 00:29:35,290 --> 00:29:40,940 ועל כל איטרציה אני שם את זה [i] בתוך t [i]. 473 00:29:40,940 --> 00:29:45,060 אז זה מה שמשתמע עם 2 אצבעותיי המצביעות על המייתרים לפני. 474 00:29:45,060 --> 00:29:49,260 כמו זה ללולאה סובב ככה, אני הולך להיות העתקת h לכאן, 475 00:29:49,260 --> 00:29:52,890 דואר לכאן, אני לכאן בגלל זה הוא החרא, זה לא. 476 00:29:52,890 --> 00:29:58,770 ואז לבסוף, בקו 35 למה אני עושה את זה? 477 00:29:58,770 --> 00:30:03,770 אני צריך לוודא שאני לא מסיים את המחרוזת. 478 00:30:03,770 --> 00:30:06,170 ואני עשיתי את זה בדרך זו להיות סופר מפורש. 479 00:30:06,170 --> 00:30:09,510 אבל להציע, מישהו, אם אתה יכול, דרך שונה לעשות את זה. 480 00:30:09,510 --> 00:30:13,930 אני לא באמת צריך את קו 35. יש דרך נוספת לעשות את זה. 481 00:30:13,930 --> 00:30:18,880 כן. >> [תגובת תלמיד לא נשמעה] >> יגיד את זה בקול רם יותר. 482 00:30:18,880 --> 00:30:20,960 [תלמיד] קטן או שווה ל. >> בדיוק. 483 00:30:20,960 --> 00:30:24,450 אנחנו רק יכולים לומר פחות או שווים ל-n, אשר באופן כללי היה רע 484 00:30:24,450 --> 00:30:28,190 משום שכמעט תמיד כאשר אנו הולכים עד שווים הדבר אנחנו בונים 485 00:30:28,190 --> 00:30:30,000 אנחנו הולכים שלב 1 רחוק מדי. 486 00:30:30,000 --> 00:30:32,170 אבל זכרו, כמה בתים לא אנו מקצים? 487 00:30:32,170 --> 00:30:37,210 אנו הוקצינו strlen של הים, ולכן 5 + 1 עבור סכום כולל של 6. 488 00:30:37,210 --> 00:30:39,980 אז במקרה הזה אנחנו יכולים לעשות משהו כזה 489 00:30:39,980 --> 00:30:46,450 כך שאנו מעתיקים לא רק שלום, אלא גם את \ 0 בסוף מאוד. 490 00:30:46,450 --> 00:30:49,860 לחלופין, נוכל להשתמש בפונקציה שנקראת str להעתיק, strcpy, 491 00:30:49,860 --> 00:30:51,700 אבל זה לא יהיה כמעט כמו כיף. 492 00:30:51,700 --> 00:30:54,000 אבל זה כל מה שהיא עושה מתחת למכסת המנוע. 493 00:30:54,000 --> 00:30:56,050 אז לבסוף, אנחנו עושים את אותו דבר כמו קודם. 494 00:30:56,050 --> 00:31:01,620 אני לא להוון ואז אני טוען שהמקור נראה כך והעותק נראה ככה. 495 00:31:01,620 --> 00:31:08,570 אז בואו ננסה את זה עכשיו. תן לי ללכת לכאן. הפוך COPY2. אנחנו להתקרב ולהפעיל COPY2. 496 00:31:08,570 --> 00:31:13,840 אני הולך להקליד בשלום באותיות קטנות, ואכן אני מקבל את האותיות קטנה לשלום כמו המקורי 497 00:31:13,840 --> 00:31:16,930 אבל הון שלום לעותק. 498 00:31:16,930 --> 00:31:20,300 אבל אני לא עשיתי עדיין. אני צריך לעשות את הדבר אחרון ש1 כאן. 499 00:31:20,300 --> 00:31:28,000 46 ו 47 באופן ברור הם משחררים זיכרון, אבל מה זה בעצם אומר? 500 00:31:28,000 --> 00:31:33,250 מה אני עושה, האם אתה חושב, על ידי קורא קו 46 וקו 47? 501 00:31:33,250 --> 00:31:38,900 מה השפעה של שיש? כן. 502 00:31:38,900 --> 00:31:43,140 [תגובת תלמיד לא נשמעה] >> בדיוק. 503 00:31:43,140 --> 00:31:46,380 >> אתה פשוט אומר לי מערכת ההפעלה, היי, תודה על הזיכרון הזה. 504 00:31:46,380 --> 00:31:48,320 עכשיו אתה יכול להשתמש בו למישהו אחר. 505 00:31:48,320 --> 00:31:50,790 והנה דוגמה מושלמת של ערכי זבל. 506 00:31:50,790 --> 00:31:55,430 יש לי רק זיכרון בשימוש זה כדי לכתוב את מילת שלום ב 2 מקומות, 507 00:31:55,430 --> 00:31:57,490 כאן, כאן, כאן, וכאן. 508 00:31:57,490 --> 00:32:00,910 אז זהו ש-E-l-l-O-\ 0. 509 00:32:00,910 --> 00:32:06,960 אבל אז אני קורא קו 46 וקו 47, ואתה יודע מה קורה שם מבחינת התמונה? 510 00:32:06,960 --> 00:32:10,010 בעצם, חכה, תמונה זו היא ישנה. 511 00:32:10,010 --> 00:32:12,550 ברגע שאנחנו עושים את העותק, הבחור הזה הוא בעצם מצביע לכאן, 512 00:32:12,550 --> 00:32:16,110 אז הבה ותוציא את המספרים ורק במרחק כחצים המופשט שוב. 513 00:32:16,110 --> 00:32:19,370 מה קורה בתמונה הזאת, כשאני מתקשר בחינם? 514 00:32:19,370 --> 00:32:22,750 [תגובה בלתי נשמעת תלמיד] >> אפילו לא. 515 00:32:22,750 --> 00:32:29,510 אם אני קורא חופשי בים ולא - סוג של שאלה מכשילה - תמונה זו אינה משתנה כלל 516 00:32:29,510 --> 00:32:33,880 כי לקרוא זה וקורא לא רק מספר את מערכת ההפעלה, 517 00:32:33,880 --> 00:32:39,010 היי, אתה יכול להשתמש בזיכרון זה שוב, אבל זה לא ישנה את זה לnull 518 00:32:39,010 --> 00:32:41,840 או איזו דמות מיוחדת, זה לא ישנה את זה, 519 00:32:41,840 --> 00:32:47,350 זה לא משנה את השעות או דואר או אני או אני או o באף אחד ממקומות לכל דבר אחר. 520 00:32:47,350 --> 00:32:51,610 במונחים של התמונה, ברגע שאתה קורא, שום דבר לא משתנה חופשי. 521 00:32:51,610 --> 00:32:56,570 ובכך טמון המקור של ערכי אשפה כי אם אז מאוחר יותר בתכנית זו 522 00:32:56,570 --> 00:33:01,010 ישאל את מערכת ההפעלה לזיכרון יותר עם GetString או malloc או משהו כזה 523 00:33:01,010 --> 00:33:04,900 ומערכת ההפעלה אומרת, בטח, יש לי עד 12 בייטים של זיכרון פשוט ששוחררו, 524 00:33:04,900 --> 00:33:08,080 להשתמש אלה, מה אתה עומד לקבל לידי? 525 00:33:08,080 --> 00:33:10,830 אתה הולך להימסר נתח של זיכרון שאנחנו בדרך כלל הייתם מצייר 526 00:33:10,830 --> 00:33:13,700 עם סימני שאלה, אבל מה הם סימני השאלה האלה? 527 00:33:13,700 --> 00:33:17,000 הם קורים להיות ש-E-l-l-o, h-E-l-l-o. 528 00:33:17,000 --> 00:33:20,940 אלה הם ערכי הזבל החדש שלנו ברגע שאתה לשחרר את הזיכרון הזה. 529 00:33:20,940 --> 00:33:22,750 >> יש לזה משמעות בעולם אמיתי גם כאן. 530 00:33:22,750 --> 00:33:24,720 זה קורה לעשות עם זכרון RAM, אבל המחשבים שלך 531 00:33:24,720 --> 00:33:26,720 למעשה עושה את אותו דבר עם דיסק. 532 00:33:26,720 --> 00:33:30,620 נידבר על זה במיוחד עם סט בעית עתיד המתמקד בזיהוי פלילי. 533 00:33:30,620 --> 00:33:36,170 אבל מה שקורה בפועל, אם יש לך קצת קובץ פיננסי רגיש על שולחן העבודה שלך 534 00:33:36,170 --> 00:33:39,600 או JPEG דל ואתה גוררים אותו לזבל שלך, 535 00:33:39,600 --> 00:33:44,390 מה קורה כשאתה גורר אותו לפח או לסל המחזור? 536 00:33:44,390 --> 00:33:47,240 אתה יודע מה אני מדבר. [שחוק] 537 00:33:47,240 --> 00:33:52,370 מה קורה כאשר יש לך ראיות לכך שגרר אל תוך פח האשפה או המחזור יכול? 538 00:33:52,370 --> 00:33:55,920 [תגובת תלמיד לא נשמעה] 539 00:33:55,920 --> 00:33:58,000 ובכן, כל כך זהיר. מה קורה כשאתה עושה את זה? 540 00:33:58,000 --> 00:34:01,030 התשובה הקצרה היא לא, נכון? 541 00:34:01,030 --> 00:34:04,790 קובץ רפרף או רגיש עדיין פשוט יושב שם איפשהו בכונן הקשיח. 542 00:34:04,790 --> 00:34:07,940 רובנו לפחות למד בדרך הקשה, כי אתה צריך לרוקן את האשפה שלך 543 00:34:07,940 --> 00:34:10,429 או את סל המחזור כדי למעשה מוחק קבצים. 544 00:34:10,429 --> 00:34:13,440 ואכן, כשאתה לוחץ לחיצה ימני או בקרה לחץ על הזבל שלך יכול 545 00:34:13,440 --> 00:34:15,580 או לבחור קובץ אשפה, ריקה או מה 546 00:34:15,580 --> 00:34:21,420 ואתה בעצם לרוקן את פח אשפה או סל המחזור, מה שקורה בפועל אז לתמונה הזאת? 547 00:34:22,810 --> 00:34:25,969 לא יותר מזה. כך ששום דבר שקורה בפועל בדיסק. 548 00:34:25,969 --> 00:34:30,880 >> ואם רק באופן זמני לסטות מנושא ולכתוב - I'll פשוט להשתמש בחלק האחורי של זה. 549 00:34:30,880 --> 00:34:34,639 אז עכשיו הסיפור משתנה מזכרון RAM, אשר בו קיימות תוכניות 550 00:34:34,639 --> 00:34:39,250 בזמן שאתה מפעיל אותם, לדיסק, שהוא בו הם מאוחסנים לטווח ארוך 551 00:34:39,250 --> 00:34:42,920 גם כאשר הכח יצא, לעת עתה - ואנחנו נחזור לזה בעתיד - 552 00:34:42,920 --> 00:34:46,380 בואו פשוט להעמיד פן שזה מייצג בתוך הכונן הקשיח של המחשב שלך 553 00:34:46,380 --> 00:34:50,110 כי עוד ביום שהיה אמור להיות דיסקים מעגליים, בדומה לדיסקטים. 554 00:34:50,110 --> 00:34:55,130 אז אם יש לך איזה קובץ Excel רגיש, זה עלול לקחת את הנתח הזה של זיכרון 555 00:34:55,130 --> 00:34:59,770 בדיסק של המחשב שלך, ואני רק ציור אותו 1s ו 0s שרירותי. 556 00:34:59,770 --> 00:35:03,970 בעת גרירת הקובץ כזה לפח האשפה שלך יכול או סל מחזור, 557 00:35:03,970 --> 00:35:07,750 ממש שום דבר לא קורה, כי אפל ומיקרוסופט פשוט החליטו 558 00:35:07,750 --> 00:35:10,450 פח האשפה וסל המחזור הוא באמת רק מציין מיקום זמני. 559 00:35:10,450 --> 00:35:14,710 אולי סופו של דבר את מערכת הפעלת תרוקן את זה בשבילך, אבל בדרך כלל, זה לא עושה כלום, 560 00:35:14,710 --> 00:35:17,090 לפחות עד שאתה באמת נמוך בחלל. 561 00:35:17,090 --> 00:35:20,870 >> עם זאת, כשאתה הולך לפח ריק או סל מחזור ריק, 562 00:35:20,870 --> 00:35:23,460 באופן דומה, שום דבר לא קורה לתמונה זו. 563 00:35:23,460 --> 00:35:28,590 כל מה שקורה הוא במקום אחר במחשב שלך, יש סוג כלשהו של שולחן. 564 00:35:28,590 --> 00:35:35,400 זה כמו סוג של סדין רמאי קטן שאומר את זה, יניח, resume.doc, 565 00:35:35,400 --> 00:35:40,920 כך קורות החיים שלך בקובץ Word של מיקרוסופט נהג לגור במיקום 123 בדיסק הקשיח, 566 00:35:40,920 --> 00:35:43,710 לא בזיכרון ולא בזכרון RAM אבל בדיסק הקשיח, 567 00:35:43,710 --> 00:35:49,050 וחייך הטרומיים JPEG ב456, וקובץ Excel שלך חיים ב789 או בכל מקום. 568 00:35:49,050 --> 00:35:53,640 כאשר אתה מוחק קבצים על ידי ריקון האשפה או סל המחזור בפועל, 569 00:35:53,640 --> 00:35:59,530 תמונה זו אינה משתנית. 0s ו 1s בכונן הקשיח שלך לא ילך לשום מקום. 570 00:35:59,530 --> 00:36:03,930 אבל טבלה זו, הנתונים הקטנים הזה של מיני, עושה שינוי. 571 00:36:03,930 --> 00:36:08,750 כאשר אתה מוחק את קורות החיים שלך, זה כאילו הקובץ נמחק במובן מסוים, 572 00:36:08,750 --> 00:36:12,790 אבל כל המחשב שבו עושה הוא לשכוח דבר שחי על הכונן הקשיח. 573 00:36:12,790 --> 00:36:17,870 0s ו 1s שמרכיב את קורות החיים או כל הקבצים האחרים האלה שלך הם עדיין שלמים. 574 00:36:17,870 --> 00:36:21,960 >> אז אם אתה עשית את זה בטעות, יש עדיין הסתברות שאינה אפס 575 00:36:21,960 --> 00:36:25,800 שאתה יכול לשחזר את הנתונים שלך באמצעות Norton Utilities או כמה תוכנות מסחריות 576 00:36:25,800 --> 00:36:29,810 מטרתו בחיים היא למצוא 0s ו 1s שהתייתם סוג של, 577 00:36:29,810 --> 00:36:33,300 שכח כאן, אבל יצא מכאן, כך שתוכל לקבל את הנתונים חזרה. 578 00:36:33,300 --> 00:36:38,410 או חוקרי זיהוי פליליים במשטרה או ה-FBI למעשה היו לוקחים את כונן קשיח 579 00:36:38,410 --> 00:36:42,550 ובאמת נראה לדפוסים של 0s ו 1s שנראה כמו תמונות JPEG, נראה כמו קבצי Excel, 580 00:36:42,550 --> 00:36:46,400 ולשחזר אותם בדרך שגם אם המחשב ששכח אותם שם. 581 00:36:46,400 --> 00:36:49,820 כך שהדרך היחידה באמת למחוק נתונים, כפי שנדונונו בעתיד, 582 00:36:49,820 --> 00:36:54,190 הוא לשפשף או לנגב את הקובץ או דיסק קשיח - 583 00:36:54,190 --> 00:36:56,540 אתה לא באמת יכול להיפטר מ0s ו 1s 584 00:36:56,540 --> 00:36:59,440 כי אחרת היית מתחיל עם כונן קשיח ג'יגה 585 00:36:59,440 --> 00:37:02,380 והיית מגיע עם כונן קשיח מגה אם אתה כל זמן מחיקה, 586 00:37:02,380 --> 00:37:04,380 פשוטו כמשמעו, 0s ו 1s. 587 00:37:04,380 --> 00:37:06,310 אז מה היית עושה אם אתה באמת רוצה לכסות את הרצועות שלך 588 00:37:06,310 --> 00:37:10,510 והבעיה הבסיסית היא שיש עדיין 0s ו 1s בדיסק? 589 00:37:10,510 --> 00:37:14,930 אני רואה מישהו שמנופף בידות פיזית תשבור את המכשיר. זה יעבוד. 590 00:37:14,930 --> 00:37:19,600 [שחוק] אבל אם זה סוג של פתרון יקר, מה יהיה יותר הגיוני? 591 00:37:19,600 --> 00:37:23,270 כן. >> [תלמיד] דרוס אותם. >> דרוס אותם עם מה? >> [תלמיד] נתונים אחרים. 592 00:37:23,270 --> 00:37:29,070 נתונים אחרים. אתה יכול פשוט להחליף את הדיסק שלך עם 0s או 1s או כל 0s, כל 1s. 593 00:37:29,070 --> 00:37:31,230 >> וזה אכן מה שחלק מהתוכנה עושה. 594 00:37:31,230 --> 00:37:33,570 אתה יכול לקנות את תוכנה או אפילו לקבל תוכנה חופשיה, 595 00:37:33,570 --> 00:37:36,610 ואפילו בנה בל-Mac OS בימים אלה, פחות מכך ב-Windows, 596 00:37:36,610 --> 00:37:38,660 היא היכולת מאובטחת למחוק. 597 00:37:38,660 --> 00:37:41,960 למעשה, אם אתה רוצה את כל הריצה הביתה היום, אם יש לכם מק ולעשות את זה, 598 00:37:41,960 --> 00:37:45,740 אם יש לך כמה דברים באשפה שלך יכול, אתה יכול לעשות רוקןאשפה מאובטחת, 599 00:37:45,740 --> 00:37:47,610 שעושה בדיוק את זה. 600 00:37:47,610 --> 00:37:53,350 ולא רק קבצים למחוק כאן, זה לא מוחק כאן 0s ו 1s, 601 00:37:53,350 --> 00:38:01,240 ולא, זה פשוט משנה את כולם, למשל, ל0s ונקודה, נקודה, נקודה. 602 00:38:01,240 --> 00:38:05,330 אז האחת psets העתיד שלך יהיה דווקא בכוונה כדי לשחזר נתונים - 603 00:38:05,330 --> 00:38:08,430 תצלומים שאנו כבר נלקחנו מאנשים, מקומות ודברים בקמפוס 604 00:38:08,430 --> 00:38:12,810 עבורו יעשו את תמונה משפטית של כרטיס הזיכרון של מצלמה דיגיטלית, 605 00:38:12,810 --> 00:38:17,120 שפירושו הרעיון בדיוק - ואתה צריך להיות מאותגר דווקא למצוא 606 00:38:17,120 --> 00:38:20,160 את הדפוסים המייצגים תמונות JPEG בכונן הקשיח, 607 00:38:20,160 --> 00:38:23,610 כמו שהתלמיד לשעבר דוא"ל שקראתי לפני כמה שבועות עשו 608 00:38:23,610 --> 00:38:25,860 לשחזר תמונותיה של אחותו. 609 00:38:25,860 --> 00:38:30,300 למה שלא תיקחו הפסקה של 5 דקות הליכה כאן, ואנחנו נתאחד מחדש עם יותר בזיכרון. 610 00:38:33,030 --> 00:38:38,610 אז הנה מקום שבו דברים מקבלים כיפוף מוחו קצת, אבל זה צעד מאוד חזק 611 00:38:38,610 --> 00:38:40,480 לקראת הבנה זה עוד יותר. 612 00:38:40,480 --> 00:38:42,900 הנה תכנית בשם pointers.c. 613 00:38:42,900 --> 00:38:45,430 זה בין הקוד לדוגמא של היום. 614 00:38:45,430 --> 00:38:51,280 שימו לב שבשורות הראשונות, 19 עד 22, כל מה שאנחנו עושים הם משהו כמו GetString 615 00:38:51,280 --> 00:38:54,460 וחוזר כתובת, לאחסן אותו בים. 616 00:38:54,460 --> 00:38:58,380 מכאן ואילך לpset אפילו 3 אם אתה רוצה, אבל pset 4 ועל 617 00:38:58,380 --> 00:39:01,030 שבו אתה יכול להתחיל לקחת את גלגלי העזר האלה בעצמך, 618 00:39:01,030 --> 00:39:04,030 אין שום סיבה להעמיד פן שמחרוזות קיימות יותר. 619 00:39:04,030 --> 00:39:07,030 זה בהחלט בסדר פשוט להתחיל להגיד * char. 620 00:39:07,030 --> 00:39:12,610 >> במאמר מוסגר, באזכורים באינטרנט ובספרים שאתה יכול לעתים קרובות לראות את הכוכב בא למשתנה. 621 00:39:12,610 --> 00:39:15,600 אתה יכול לראות אפילו את החללים ששני הצדדים שלו. 622 00:39:15,600 --> 00:39:17,680 כל אלה הם פונקציונליים נכונים. 623 00:39:17,680 --> 00:39:21,180 לעת עתה, אם כי, אנחנו סטנדרטיזציה על גישה זו כדי להפוך סופר ברור 624 00:39:21,180 --> 00:39:24,000 שדמות * זה כמו לומר מצביע אופי. 625 00:39:24,000 --> 00:39:25,680 זה סוג הנתונים. 626 00:39:25,680 --> 00:39:28,730 ולאחר מכן את השם של המשתנה הוא זה במקרה זה. 627 00:39:28,730 --> 00:39:31,180 אז קבלתי מחרוזת ושכינינו אותו הים. 628 00:39:31,180 --> 00:39:35,180 ואז כאן תבחין שאני עושה קצת רמאות ממש. 629 00:39:35,180 --> 00:39:39,080 זה נקרא פעולות אריתמטיות על מצביעים, שהיא סוג של סופר פשוט. 630 00:39:39,080 --> 00:39:41,790 זה רק אומר להוסיף ולהחסיר מספרים למצביעים. 631 00:39:41,790 --> 00:39:43,660 אבל זה באמת עובד. 632 00:39:43,660 --> 00:39:49,170 תכנית זו כנראה מדפיסה תו של מחרוזת 1 לכל קו כזה שהתוצאה הסופית - 633 00:39:49,170 --> 00:39:54,920 רק כדי שנוכל לקלקל לאן זה הולך, להפוך את מצביעים, לרוץ מצביעים, בואו להתקרב פנימה 634 00:39:54,920 --> 00:39:58,940 עכשיו תן לי להקליד משהו כמו שלום וסוג הזן 635 00:39:58,940 --> 00:40:01,080 והוא מדפיס את הדמות 1 בכל שורה. 636 00:40:01,080 --> 00:40:04,730 עד לפני שנייה, היינו עושה את זה עם כיתוב סוגר מרובע. 637 00:40:04,730 --> 00:40:09,760 היה לנו ללולאה ואנחנו נעשה את של printf של [i] ואנחנו היינו עושים את זה שוב ושוב ושוב 638 00:40:09,760 --> 00:40:11,950 עם n קו נטוי בסוף כל שורה. 639 00:40:11,950 --> 00:40:16,800 אבל התכנית הזו היא שונה. תכנית זו משתמשת, פשוטו כמשמעו, בחשבון. 640 00:40:16,800 --> 00:40:18,860 אז מה קורה כאן? 641 00:40:18,860 --> 00:40:24,720 קודם כל, לפני שהלולאה הזו אפילו מבצעת, מה, רק שיהיה ברור, היא בעצם של? 642 00:40:24,720 --> 00:40:27,270 S הוא? >> [תלמיד] כתובת. >> כתובת. 643 00:40:27,270 --> 00:40:32,980 >> וזה הכתובת של, במקרה של שלום, בתו הראשון שבמילה, שהוא h. 644 00:40:32,980 --> 00:40:37,370 אז זה הוא, בדוגמא הספציפית הזה, הכתובת של שעות. 645 00:40:37,370 --> 00:40:41,850 אז מה זה אומר לעשות s + i? 646 00:40:41,850 --> 00:40:46,280 ובכן, אני מתחיל ב0 בזה ללולאה. אנחנו עשינו את זה פעמים רבות. 647 00:40:46,280 --> 00:40:49,760 אני הולך לעלות לאורכו של החוט, כנראה. 648 00:40:49,760 --> 00:40:53,950 אז באיטרציה הראשונה של לולאה זה, אני כמובן 0. 649 00:40:53,950 --> 00:41:01,740 לכן ביטוי שזה אומר שלי + - אדרבה, +0--ברור שזה רק זה. 650 00:41:01,740 --> 00:41:04,320 אז מה הוא * של כאן? 651 00:41:04,320 --> 00:41:08,530 עכשיו אנחנו משתמשים בכוכב בדרך מעט שונה. 652 00:41:08,530 --> 00:41:13,080 תן לי ללכת קדימה ולהיפטר מלא בגלל שאנחנו מדברים על לעשות t והעתקים של. 653 00:41:13,080 --> 00:41:15,540 עכשיו אנחנו רק רוצים לספר סיפור המעורב של. 654 00:41:15,540 --> 00:41:20,090 וכך ברגע זה, לאחר שסוג המחרוזת, העולם שלנו נראה ממש כמו שעשה לפני 655 00:41:20,090 --> 00:41:26,630 רק עם של אחסון הכתובת של שעות ויותר בדרך כלל מצביע על מחרוזת שלום. 656 00:41:26,630 --> 00:41:33,170 אם אני עכשיו עושה קו כמו * (הים + i), בואו ננסה את זה. 657 00:41:33,170 --> 00:41:40,140 אז * (הים + i). תן לי לפשט את זה כי זה הוא 0, אז זה * (הים +0). 658 00:41:40,140 --> 00:41:43,790 ובכן, חכה רגע. לפשט עוד יותר. זה * (ים). 659 00:41:43,790 --> 00:41:47,020 ובכן, עכשיו את הסוגריים הם סוג של טיפשים, אז עכשיו בואו רק * לעשות בנידון. 660 00:41:47,020 --> 00:41:50,540 אז באיטרציה הראשונה של לולאה זו, קו שמודגש, 26, 661 00:41:50,540 --> 00:41:53,650 הוא פחות או יותר שווה ערך להדפסה זו. 662 00:41:53,650 --> 00:41:56,040 מהו סוג הנתונים של * הים? 663 00:41:56,040 --> 00:42:00,770 בהקשר זה, כי הכוכב קורה להיות לצדו של עצמו, 664 00:42:00,770 --> 00:42:04,930 אבל באופן ספציפי יותר, כי אנחנו כבר לא מכריזים s, 665 00:42:04,930 --> 00:42:09,730 אנחנו לא יוצרים משתנים יותר, אבל אין שום אזכור לדמות * בקו 26, 666 00:42:09,730 --> 00:42:14,280 אין כל אזכור ממילת המפתח, אנחנו רק באמצעות משתנים בשם של, 667 00:42:14,280 --> 00:42:19,650 מתברר כעת הכוכבים יש מעט שונים, ויש להודות, מבלבלים משמעות. 668 00:42:19,650 --> 00:42:26,590 * זה אומר ללכת לכאן את הכתובת ובהדפסה של כל מה שיש. 669 00:42:26,590 --> 00:42:33,750 אז זה הוא כאן, * זה הוא - כמו סוג של מצנחים וסולמות, בצע את החץ - כאן. 670 00:42:33,750 --> 00:42:35,850 אז זה * s. 671 00:42:35,850 --> 00:42:39,060 >> אז מה מקבל מודפס על החזרה הראשונה של לולאה בקו 26? 672 00:42:39,060 --> 00:42:42,170 אני מדפיס את ג%, שהוא מציין המיקום עבור תו, 673 00:42:42,170 --> 00:42:48,520 אז \ n לשורה חדשה. * (הים + i) שבו אני הוא 0 הוא בדיוק זה. 674 00:42:48,520 --> 00:42:53,670 אז מה char למקם בג%? ח 675 00:42:53,670 --> 00:42:56,900 באיטרציה הבאה של הלולאה - כנראה שאתה יכול לראות לאן זה הולך - 676 00:42:56,900 --> 00:43:01,350 איטרציה הבאה אני כמובן 1, כך שזה אומר של +1, 677 00:43:01,350 --> 00:43:05,580 ואז עכשיו אני צריך את הסוגריים כי עכשיו הכוכב צריך לומר 678 00:43:05,580 --> 00:43:08,620 ללכת לכתובת זיכרון של 1. 679 00:43:08,620 --> 00:43:14,170 מה זה? בואו נגלגל אחורה בזמן ואומרים החץ הזה עכשיו הוא לא ממש עושה לנו טוב. 680 00:43:14,170 --> 00:43:18,450 תן יותר ספציפי לומר כי זה אחסון 123 מספר 681 00:43:18,450 --> 00:43:25,110 בגלל ההתחלה של מחרוזת זו שלום, זו כתובת 123, זה 124, וכן הלאה. 682 00:43:25,110 --> 00:43:30,550 אז על החזרה השנייה כשאני אומר של +1, זה כמו להגיד ש123 1, 683 00:43:30,550 --> 00:43:35,340 הידוע גם 124, אז מה char מקבל מודפס על החזרה השנייה? 684 00:43:35,340 --> 00:43:37,850 E בכתובת הזיכרון 124. 685 00:43:37,850 --> 00:43:44,440 ואז שוב +, 125, 126, 127, וזה לולאת שמחה מפסיקה לפני שנגיע לכאן 686 00:43:44,440 --> 00:43:49,040 כי אני משתמש strlen כדי לוודא שאני לא נחשב גבוה מדי. 687 00:43:49,040 --> 00:43:50,810 אז גם זה את זה. 688 00:43:50,810 --> 00:43:55,000 שוב, זה בדיוק כמו שאנחנו עשינו לפני שבוע. 689 00:43:55,000 --> 00:43:59,200 תן לי לכתוב את זה בשורה מתחת למרות שאנחנו לא רוצים לעשות את שניהם. 690 00:43:59,200 --> 00:44:02,500 זה זהה לזה עכשיו. 691 00:44:02,500 --> 00:44:08,310 >> אז למרות שזה הוא מחרוזת, כפי שכבר כינו אותו במשך שבועות, זה באמת * char. 692 00:44:08,310 --> 00:44:13,270 אז אם אנחנו רוצים להיות סופר אנאלי, זה באמת נכון לכתוב את התו הספציפי 693 00:44:13,270 --> 00:44:17,490 במיקום ה-i באמצעות כתובות אלה מספריים ומפעיל כוכבים זה, 694 00:44:17,490 --> 00:44:20,470 אבל בכנות, זה פשוט כל כך הרבה יותר נקי. אז זה לא רע. 695 00:44:20,470 --> 00:44:26,720 אין שום סיבה להפסיק לעשות את הקו 27 כאן, אך 26 הן פונקציונליים זהים, 696 00:44:26,720 --> 00:44:31,570 וזה תפקודי זהה בדיוק מהסיבות שאנחנו כבר דנים עד כה. 697 00:44:31,570 --> 00:44:33,650 ולבסוף, 29 הם בפועל רק טוב. 698 00:44:33,650 --> 00:44:38,420 שיחות חינם משל הפירוש שעכשיו אתה נותן בחזרה את הזיכרון שGetString נתן לך 699 00:44:38,420 --> 00:44:41,630 כי שוב, כפי שציינתי יום שני, GetString לשבועות 700 00:44:41,630 --> 00:44:44,180 כבר מציג באג בקוד שלך. 701 00:44:44,180 --> 00:44:46,490 הקוד שלך במשך שבועות יש לו דליפות זיכרון 702 00:44:46,490 --> 00:44:49,970 לפי ששאלת GetString לזיכרון, אבל אתה אף פעם לא היה נותן לו בחזרה. 703 00:44:49,970 --> 00:44:53,410 ושנבחר במכוון על ידי בנו מבחינה פדגוגית 704 00:44:53,410 --> 00:44:55,880 כי זה פשוט יותר מדי לחשוב על שלב מוקדם. 705 00:44:55,880 --> 00:44:57,710 אבל עכשיו אנחנו צריכים יותר סימטריה. 706 00:44:57,710 --> 00:45:00,830 אם אתה שואל את המחשב לזיכרון, כפי שקורה לGetString, 707 00:45:00,830 --> 00:45:02,820 כמו במקרה כנראה לmalloc, 708 00:45:02,820 --> 00:45:07,970 אתה חייב עכשיו ל4 ואילך pset גם ללא כל זיכרון כזה. 709 00:45:07,970 --> 00:45:11,650 שים לב זה שונה מלומר n int. 710 00:45:11,650 --> 00:45:15,040 אתה לא צריך לשחרר את זה, כי אתה לא קורא GetString 711 00:45:15,040 --> 00:45:16,890 ואתה לא קורא malloc. 712 00:45:16,890 --> 00:45:20,610 >> ואפילו אם היית קורא GetInt כפי שסופו של דבר יראה, 713 00:45:20,610 --> 00:45:25,520 GetInt אינו מקצה זיכרון עבורך, כי אתה בעצם יכול לעבור סביב מספרים שלמים 714 00:45:25,520 --> 00:45:29,430 וצוף תווים בדיוק כפי שאנחנו כבר עושים במשך שבועות. 715 00:45:29,430 --> 00:45:33,960 מייתרים, אם כי, הם מיוחדים בגלל שהם באמת השרשור של תווים מרובים. 716 00:45:33,960 --> 00:45:37,450 אז הם פשוט שונים מתווים וצף ints וכדומה. 717 00:45:37,450 --> 00:45:39,980 אבל אנחנו נחזור לזה לפני זמן רב. 718 00:45:39,980 --> 00:45:44,920 יש שאלות אז בהתחלה זה של מצביעים? כן. 719 00:45:44,920 --> 00:45:49,690 [שאלת תלמיד לא נשמעה] 720 00:45:49,690 --> 00:45:51,440 אה, שאלה טובה מאוד. 721 00:45:51,440 --> 00:45:55,790 אחד הדברים הבודדים C למעשה עושה בשבילך, וזה נוח, 722 00:45:55,790 --> 00:46:00,110 האם זה דמוי בשבילך מה גודלו של סוג הנתונים 723 00:46:00,110 --> 00:46:03,060 ואז עושה סוג של כפל בשבילך. 724 00:46:03,060 --> 00:46:06,610 זה לא רלוונטי במקרה של תווים, כי כמעט תמיד char הוא בית 1, 725 00:46:06,610 --> 00:46:08,150 אז זה פשוט עובד. 726 00:46:08,150 --> 00:46:11,220 אבל לשם דיון, אם אתה באמת היה מדפיס מספרים שלמים 727 00:46:11,220 --> 00:46:15,500 ואתה מנסה להדפיס את הערך כלשהו של שמצביע על מספר שלם, 728 00:46:15,500 --> 00:46:20,720 אתה דומה לא צריך לעשות + 4 * אני רק בגלל int הוא 4 בתים. 729 00:46:20,720 --> 00:46:25,780 פעולות אריתמטיות על מצביעים אומרות שC והמהדר לעשות את כל מתמטיקה זה בשבילך. 730 00:46:25,780 --> 00:46:29,190 כל מה שאתה צריך לדאוג הוא הספירה בסוג של התחושה האנושית. כן. 731 00:46:29,190 --> 00:46:35,200 [תלמיד] אם אתה מצהיר מחרוזת בתוך לולאה for, יש לך לשחרר אותו מאוחר יותר? 732 00:46:35,200 --> 00:46:36,760 שאלה טובה. 733 00:46:36,760 --> 00:46:41,390 >> אם הצהרת בתוך מחרוזת של ללולאה, אתה צריך לשחרר אותו מאוחר יותר? 734 00:46:41,390 --> 00:46:47,520 אתה רק צריך לשחרר זיכרון שאתה מקצה עם GetString או עם malloc. 735 00:46:47,520 --> 00:46:53,110 אז אם אתה רק רוצה לומר משהו - תן לי להכניס סוגריים מסולסלים עכשיו אז כל הקוד קשור. 736 00:46:53,110 --> 00:46:58,580 אם עשית משהו, גם אם buggily, כמו זה, char * t = s, 737 00:46:58,580 --> 00:47:03,450 אתה לא צריך לא בחינם, כי לא לא היה כרוך בכל אזכור של malloc או GetString. 738 00:47:03,450 --> 00:47:08,960 אם לעומת זאת אתם עשיתם את זה, GetString, אז כן, היית צריך לא חינמי. 739 00:47:08,960 --> 00:47:14,350 ולמעשה, הסיכוי היחיד שלך לעשות זאת הוא עכשיו בתוך לולאה זו, לאותו הנושא של היקף 740 00:47:14,350 --> 00:47:16,060 ששוחחנו בעבר. 741 00:47:16,060 --> 00:47:18,830 אחרת היה הקצאת זיכרון, הקצאת זיכרון, הקצאת זיכרון, 742 00:47:18,830 --> 00:47:21,230 ובסופו של התכנית בגלל שאתה מחוץ ללולאה ש, 743 00:47:21,230 --> 00:47:24,240 לא לא קיים, אבל אתה אף פעם לא ספרת את מערכת ההפעלה 744 00:47:24,240 --> 00:47:26,750 שאתה לא צריך את זה יותר זיכרון. 745 00:47:26,750 --> 00:47:30,430 ולא עבר זמן רב, לpset 4 או 5 אנחנו לצייד אתכם בתכנית בשם Valgrind, 746 00:47:30,430 --> 00:47:34,160 אשר דומה בהרוח לGDB שביש לזה במידה מסוימת של ממשק מיושן כל כך, 747 00:47:34,160 --> 00:47:35,750 אבל את מטרתו בחיים היא לעזור לך. 748 00:47:35,750 --> 00:47:39,380 וValgrind הוא תכנית שיהיה בעתיד לחפש את התוכניות שלך 749 00:47:39,380 --> 00:47:42,550 מחפש דליפות זיכרון, בין אם מGetString או malloc, 750 00:47:42,550 --> 00:47:47,800 בו יתחילו להשתמש בכל שכפי שאנו מפסיקים להשתמש CS50 הספרייה באותה המידה. 751 00:47:47,800 --> 00:47:53,030 אנחנו סוף הסוף עכשיו יש סוג של אוצר המילים וסוג של מודל מנטלי בתאוריה 752 00:47:53,030 --> 00:47:55,170 עם שכדי לפתור התכנית השבורה הזה. 753 00:47:55,170 --> 00:47:59,410 >> אז בתכנית השבורה הזה, החלפה עובדת בתוך ההחלף, 754 00:47:59,410 --> 00:48:05,280 אבל זה לא ממש עבד בעיקרי משום עיקרי עבר בx ו-y, כזכור, 755 00:48:05,280 --> 00:48:07,260 ואלו הועברו על ידי ערכים, כביכול. 756 00:48:07,260 --> 00:48:09,330 עותקים שלהם ניתנו להחליף. 757 00:48:09,330 --> 00:48:12,520 בסוף ההחלפה, ואכן ב הוחלפו, 758 00:48:12,520 --> 00:48:16,120 אבל כמובן X ו-Y, כפי שדנו ביום שני, לא היו. 759 00:48:16,120 --> 00:48:19,940 אז אני מציע בירוק כאן שמדובר למעשה בפתרון כאן. 760 00:48:19,940 --> 00:48:22,640 ולמעשה, לתת לי לזוז הכוכבים שלי רק כדי להיות עקבי 761 00:48:22,640 --> 00:48:24,440 למרות, שוב, מבחינה תפקודית זה לא משנה. 762 00:48:24,440 --> 00:48:28,730 בשבועות הבאים אנו נסביר מתי ולמה זה משנה. 763 00:48:28,730 --> 00:48:30,600 אז בירוק כרגע הוא פתרון. 764 00:48:30,600 --> 00:48:33,700 למען אמת, זה נראה הרבה יותר מבולגן כי יש לי את כל הכוכבים הללו. 765 00:48:33,700 --> 00:48:35,380 בואו להצביע לי דבר אחד. 766 00:48:35,380 --> 00:48:40,040 השורה העליונה כאן איפה זה אומר int * וint * b 767 00:48:40,040 --> 00:48:42,820 יסודו עושה את אותו הדבר כמו תמיד. 768 00:48:42,820 --> 00:48:47,070 הוא מכריז 2 טיעונים או פרמטרים להחלפה, 769 00:48:47,070 --> 00:48:49,940 הראשון שבם הוא מצביע int נקרא, 770 00:48:49,940 --> 00:48:53,100 השני הוא שמצביע int בשם b. 771 00:48:53,100 --> 00:48:55,770 דבר היחיד שחדש בשלב זה, הוא העובדה שיש לכוכב שם. 772 00:48:55,770 --> 00:48:59,340 >> מה זה אומר? לא int, b הוא לא int. 773 00:48:59,340 --> 00:49:04,100 היא הכתובת של int ו b הוא הכתובת של int שונה. 774 00:49:04,100 --> 00:49:06,980 כאן למטה, זה שבו אני מודה C מתחיל לבלבל. 775 00:49:06,980 --> 00:49:09,790 עכשיו אנחנו משתמשים בכוכב, אבל יש לו משמעות שונה בהקשר זה. 776 00:49:09,790 --> 00:49:13,150 כי אנחנו לא מכריזים מצביעים כמו שאנחנו כאן, 777 00:49:13,150 --> 00:49:15,500 כאן אנו ביטול הפנית דברים. 778 00:49:15,500 --> 00:49:21,520 אז מבחינה טכנית, את הכוכב בהקשר זה של השורה הראשונה, שנייה ושלישית תוך החלפה 779 00:49:21,520 --> 00:49:24,560 הוא מפעיל dereference, שרק אומר שילך לשם. 780 00:49:24,560 --> 00:49:27,400 אז בדיוק כפי שהאצבע שלי אחרי חץ השעות, 781 00:49:27,400 --> 00:49:31,100 * אמצעי להגיע לכתובת זו ולמצוא לי int שיש שם. 782 00:49:31,100 --> 00:49:34,250 * אמצעי b ללכת לכתובת ויעביר לי מה שיש. 783 00:49:34,250 --> 00:49:40,730 אז בואו לצייר מחדש את התמונה מיום השנייה כיום באמצעות מחסנית של מסגרות, 784 00:49:40,730 --> 00:49:43,130 אחד התחתון שהולך להיות ראשי, 785 00:49:43,130 --> 00:49:47,600 העליון אחת שהולך להיות עסקת ההחלף, 786 00:49:47,600 --> 00:49:50,880 כך שהעולם שלנו נראה, בדיוק כמו יום שני, כמו זה. 787 00:49:50,880 --> 00:49:53,620 הנה הוא נתח העיקרי של זיכרון שהולך לשימוש. 788 00:49:53,620 --> 00:49:56,520 >> כזכור, מיום שנייה כי התכנית פשוט הייתי 2 משתנית, 789 00:49:56,520 --> 00:50:01,930 אחד שנקרא X ואחד בשם Y, ואני הכנסתי את מספרי 1 ו 2 שם. 790 00:50:01,930 --> 00:50:06,580 עכשיו כשאני קורא להחליף כמו שאני עשיתי ביום שני, 791 00:50:06,580 --> 00:50:11,000 בעבר כשהשתמשתי בגרסה האדומה של תכנית זו, שנראה כמו זה, 792 00:50:11,000 --> 00:50:17,470 יש לי 2 פרמטרים, ו-B, ומה שאנחנו כותבים כאן וגם כאן? 793 00:50:17,470 --> 00:50:21,160 רק 1 ו 2, פשוטו כמשמעו, עותקים של x ו-y. 794 00:50:21,160 --> 00:50:23,070 היום אנחנו נשנה את זה. 795 00:50:23,070 --> 00:50:28,510 היום במקום לעבור בints וב אנחנו הולכים לעבור 2 כתובות ב. 796 00:50:28,510 --> 00:50:34,290 כתובות אלה יקרו להצביע על ints, אבל אותן כתובות לא ints עצמם. 797 00:50:34,290 --> 00:50:37,330 הם כתובות. זה כמו כתובת למשלוח דואר במקום. 798 00:50:37,330 --> 00:50:40,580 אז עכשיו אנחנו צריכים פשוט לתת לעצמי קצת יותר פרטים על המסך. 799 00:50:40,580 --> 00:50:43,250 זה הזיכרון של המחשב שלי כמו שזה היה כל היום. 800 00:50:43,250 --> 00:50:45,120 עכשיו אנחנו צריכים קצת שיטת מספור שרירותית. 801 00:50:45,120 --> 00:50:50,580 אז בואו רק אומרים, רק במקרה, שזאת כתובת של זיכרון 123, 124. 802 00:50:50,580 --> 00:50:55,660 בואו רק נגיד שזה 125, זה 126, וכן הלאה, אבל זה שרירותי לחלוטין. 803 00:50:55,660 --> 00:50:58,590 אנחנו רק צריכים קצת שיטת מספור בזכרוני. 804 00:50:58,590 --> 00:51:04,030 אז עכשיו כשאני באמת אעבור בx ו-y, אני לא מתכוון לעבור בx ו-y; 805 00:51:04,030 --> 00:51:08,400 אני הולך לעבור בכתובת הדואר שלו, כביכול, של x ושל y 806 00:51:08,400 --> 00:51:11,870 כך שמה מאוחסן כאן וכאן הוא לא 1 ו 2, 807 00:51:11,870 --> 00:51:16,030 אבל אם אתה יכול לראות את הטקסט הקטן שלי, את מה שעבר במקבל כאן וגם כאן? 808 00:51:16,030 --> 00:51:23,340 [תגובת תלמיד לא נשמעה] >> בדיוק. 123 מקבל לשים כאן ומקבל 124 לשים כאן. 809 00:51:23,340 --> 00:51:28,910 >> עכשיו, כי הייתי הכוכב בדרך הראשונה את הקו הזה כאן למעלה בראש, 810 00:51:28,910 --> 00:51:34,340 התכנית שלי פשוט יודעת ש123 ו 124, למרות שהם כמובן מספרים שלמים 811 00:51:34,340 --> 00:51:40,160 כי כל אדם יכול להבחין בכך, הם צריכים להתפרש ככתובות, כתובות מספריות. 812 00:51:40,160 --> 00:51:43,250 הם לא בעצמם ושל ints, הם כתובות, 813 00:51:43,250 --> 00:51:46,120 וזה בגלל שיש לי את במפורש את הכוכבים שם. 814 00:51:46,120 --> 00:51:51,360 אז עכשיו בשורה הראשונה, שנייה ושלישית שלי בקוד עצמו מה קורה כאן? 815 00:51:51,360 --> 00:51:53,380 בואו נצייר את שאר התמונה. 816 00:51:53,380 --> 00:51:56,980 Tmp הוא בדיוק כמו שזה היה ביום שני. שום דבר מיוחד tmp. 817 00:51:56,980 --> 00:52:03,060 זה משתנה רק 32 סיביים מקומי, ובתוך שכנראה אני אחסון הערך *. 818 00:52:03,060 --> 00:52:08,580 עכשיו, אם אני רק אמרתי tmp =, מה הייתי לשים כאן? >> [תלמיד] 123. 819 00:52:08,580 --> 00:52:10,370 123. אבל זה לא מה שאני עושה. 820 00:52:10,370 --> 00:52:13,670 אני אומר tmp = *. אמצעי הכוכבים ללכת לשם. 821 00:52:13,670 --> 00:52:19,370 אז הנה הוא, 123. כיצד אני יכול ללכת לשם? להעמיד פן כאילו יש חץ. 822 00:52:19,370 --> 00:52:24,460 ובכן, זה מה שיש, 1. אז מה מאוחסן בtmp, כנראה? רק 1. 823 00:52:24,460 --> 00:52:29,620 אז במילים אחרות, הוא tmp * a, * אמצעים ללכת לכתובת שנמצאה כעת ב, 824 00:52:29,620 --> 00:52:31,320 אשר ככל הנראה 123. 825 00:52:31,320 --> 00:52:33,910 >> אוקיי, הנה אנחנו במיקום 123, אני רואה את המספר 1, 826 00:52:33,910 --> 00:52:35,670 אז אני הולך לשים את המספר 1 שם. 827 00:52:35,670 --> 00:52:39,020 עכשיו מה שאני עושה בקו 2, * = * ב? 828 00:52:39,020 --> 00:52:44,570 זה אחד הוא קצת יותר מעורב, כי עכשיו מה? זה 123. 829 00:52:44,570 --> 00:52:50,220 אז * הוא איפה? בדיוק היכן שהייתי בעבר. אז ללכת לשם. אוקיי. 830 00:52:50,220 --> 00:52:53,420 עכשיו, דבר אחרון, ואז סוף הסוף זה יתחיל להיות הגיוני, בתקווה, 831 00:52:53,420 --> 00:53:00,280 * ב פירושו מה שיש בב? 124. אז אני צריך ללכת לשם, שהוא 2. 832 00:53:00,280 --> 00:53:03,430 אז מה ישים שם? 833 00:53:03,430 --> 00:53:10,100 2 נכנסו לכאן כי ב * נכנס *. אז אני אעשה את זה. 834 00:53:10,100 --> 00:53:13,120 ואתה כבר יכול לראות, אולי, שאנחנו כל כך קרובים 835 00:53:13,120 --> 00:53:17,710 לפתרון בעיה זו טפשה, פשוט בצורה נכונה בפעם הראשונה 836 00:53:17,710 --> 00:53:20,920 כי עכשיו יש לנו עדיין זוכר מה היה x, 837 00:53:20,920 --> 00:53:23,230 יש לנו 2 עותקים, יש להודות, של Y, 838 00:53:23,230 --> 00:53:25,850 אבל בשורה 3 עכשיו אומרת * ב. 839 00:53:25,850 --> 00:53:31,080 אז הנה ב. * אמצעי b ללכת לשם. אז איפה הוא מיקום 124? 840 00:53:31,080 --> 00:53:35,560 זה כנראה כאן. אז מה אני שם פה? ברור, tmp. 841 00:53:35,560 --> 00:53:39,600 אז עכשיו אני עושה את זה. אז יש לי 1 כאן וכאן 2. 842 00:53:39,600 --> 00:53:43,560 ועכשיו מה עם כל זה, 123, 124, ו1? 843 00:53:43,560 --> 00:53:47,910 ברגע שחוזר swap, הזיכרון הזה הוא טוב כמו אבד 844 00:53:47,910 --> 00:53:51,070 כי ברגע שחוזר להחלפה, מערכת ההפעלה 845 00:53:51,070 --> 00:53:54,190 הוא חופשי להשתמש בזיכרון זה שוב בעתיד. 846 00:53:54,190 --> 00:53:58,870 רק זיכרון של עיקרי בתחתית הערימה כביכול הזה נשאר. 847 00:53:58,870 --> 00:54:01,470 >> וכך סוף סוף יש גרסה עובדת עכשיו. 848 00:54:01,470 --> 00:54:06,310 תן לי ללכת לswap.c, ושימו לב שלאחר מכן. 849 00:54:06,310 --> 00:54:11,280 בחלק העליון של התכנית ששיניתי את אב הטיפוס שלי להיות int * וint * ב. 850 00:54:11,280 --> 00:54:15,000 אז הדבר היחיד שאני השתניתי ללכת מאדום, שהיה רע, לירוק, וזה טוב, 851 00:54:15,000 --> 00:54:17,350 הוא הוספתי הכוכבים האלה היום. 852 00:54:17,350 --> 00:54:21,520 אבל אז כאן בעצמו להחליף הייתי צריך להעתיק, להדביק את מה שהיה רק ​​בשקופית. 853 00:54:21,520 --> 00:54:24,140 יש לי כאן כוכב, כוכב כאן - התואם את אב הטיפוס - 854 00:54:24,140 --> 00:54:27,930 ואז כל הדברים האלה עכשיו יש כוכבי פרט לtmp 855 00:54:27,930 --> 00:54:30,680 בגלל השימוש במשתנה זמנית, אין שום דבר חדש שם. 856 00:54:30,680 --> 00:54:33,040 אני רק צריך אחסון זמני עבור int. 857 00:54:33,040 --> 00:54:34,820 אז אנחנו לא צריכים אותו כוכב שם. 858 00:54:34,820 --> 00:54:39,310 אנחנו פשוט צריכים את הכוכב, כך שנוכל לעבור את זה סוג של גבול שרירותי 859 00:54:39,310 --> 00:54:42,900 בין 2 המסגרות הללו בזיכרון של המחשב שלי. 860 00:54:42,900 --> 00:54:45,630 אבל הדבר האחרון שיש לשנות, ושאולי הבחין בו כבר. 861 00:54:45,630 --> 00:54:48,810 מה קו השני הוא כמובן שונה עכשיו? >> [תלמיד] & x. 862 00:54:48,810 --> 00:54:53,270 >> כן, אז 25 הן בשורה האחרונה של קוד אני צריך לשנות כדי שזה יעבוד. 863 00:54:53,270 --> 00:54:58,360 לפני שבוע וגם ביום שני 25 השורה נראתה כך, להחליף X ו-Y, 864 00:54:58,360 --> 00:55:02,020 וזה פשוט נשבר, כי אם אתה אומר ההחלף (x, y) 865 00:55:02,020 --> 00:55:05,660 אתה נותן עותקים של X ו-Y כדי להחליף, אז זה עושה את שלו, 866 00:55:05,660 --> 00:55:09,080 אבל אתה אף פעם לא באמת משתנה x ו-y עצמו. 867 00:55:09,080 --> 00:55:12,880 אז גם אם אתם אף פעם לא ראיתם את זה קודם עם אופי האמפרסנד בקוד, 868 00:55:12,880 --> 00:55:15,860 פשוט לקחת את ניחוש. מה האמפרסנד עושה, כנראה? 869 00:55:15,860 --> 00:55:17,890 [תלמיד] לוקח את הכתובת. >> לוקח את הכתובת. 870 00:55:17,890 --> 00:55:21,160 אז האמפרסנד אומר תן לי את הכתובת של x. 871 00:55:21,160 --> 00:55:25,590 מי יודע איפה זה? זה קורה להיות 123. לא אכפת לי. רק תן לי את הכתובת של x. 872 00:55:25,590 --> 00:55:28,340 & Y פירושו לתת לי את הכתובת של y. 873 00:55:28,340 --> 00:55:34,450 ובשלב זה הוא הסיפור מושלם בקנה אחד עם התמונה שציירנו לפני רגע. 874 00:55:34,450 --> 00:55:38,310 >> אז אני מודה מצביעים, בוודאי בשבילי כשהתחלתי ללמוד את זה, 875 00:55:38,310 --> 00:55:40,570 היו בהחלט אחד הדברים הכי הקשים לתפוס את דעתי בסביבה. 876 00:55:40,570 --> 00:55:43,760 אבל תבין, במיוחד כשאנו להמשיך לשחק עם דברים כאלה, 877 00:55:43,760 --> 00:55:48,030 אם אתה לשבור אותו לאלה סוג פשוט של הסופר אינטלקטואלי לא מעניין בעיות 878 00:55:48,030 --> 00:55:52,270 מעתה נע סביב מספרים, את התשובה להרבה בלבול עם מצביעים 879 00:55:52,270 --> 00:55:56,590 באמת ניתן לגזור מהמכניקה בסיסית מאוד האלה. 880 00:55:56,590 --> 00:55:59,070 הנה כתובת. ללכת לשם עם הכוכב. 881 00:55:59,070 --> 00:56:03,830 או לחלופין, הנה אמפרסנד. להבין מה הכתובת באמת. 882 00:56:03,830 --> 00:56:06,270 בסדר. 883 00:56:06,270 --> 00:56:09,000 אז איפה כל הזיכרון הזה מגיע? 884 00:56:09,000 --> 00:56:12,360 אנחנו כבר צוירנו התמונה הזאת כמה פעמים, ואני שומר מבטיח שנחזור אליו, 885 00:56:12,360 --> 00:56:14,920 אבל כאן הוא הייצוג של זכרון המחשב שלך 886 00:56:14,920 --> 00:56:17,420 זה קצת יותר מהלוח שהכותרת שלנו הוא כאן. 887 00:56:17,420 --> 00:56:21,590 קטע הטקסט בחלק העליון מייצג את מה ביחס לתכנית שלך? 888 00:56:21,590 --> 00:56:26,090 [תגובת תלמיד לא נשמעה] >> מצטער? תגיד את זה שוב. 889 00:56:26,090 --> 00:56:28,660 [התלמיד] התכנית בפועל. >> התכנית בפועל. 890 00:56:28,660 --> 00:56:32,430 >> אז 0s ו 1s שיש לך הידור לאחר כתיבת קוד C ולאחר מכן פועל קלאנג 891 00:56:32,430 --> 00:56:35,910 ולייצר עד קצות 0s ו 1s מקבל תקוע שם בזיכרון 892 00:56:35,910 --> 00:56:38,570 משום שכאשר אתה לוחץ לחיצה כפולה על סמל Mac או PC שלך 893 00:56:38,570 --> 00:56:43,010 או להפעיל פקודה כמו מריו בפקודה, 0s ו 1s מהדיסק 894 00:56:43,010 --> 00:56:45,700 נטען לזיכרון, כך שהמחשב יכול לתפעל אותם 895 00:56:45,700 --> 00:56:47,540 ולבצע אותם במהירות רבה יותר. 896 00:56:47,540 --> 00:56:50,880 נתונים אותחלו אז ונתונים מאותחלים, אנחנו לא מדברים הרבה על אלה, 897 00:56:50,880 --> 00:56:52,420 אבל אלה הם רק משתנים גלובליים. 898 00:56:52,420 --> 00:56:54,710 אותחל משמעות משתנים הגלובליים שנתת לערכים; 899 00:56:54,710 --> 00:56:59,300 לא מאותחל משמעות משתנים הגלובליים שעדיין לא נותנים לערכים. 900 00:56:59,300 --> 00:57:01,900 אז יש משתני הסביבה האלה שאני מניף את הידות לחלוטין, 901 00:57:01,900 --> 00:57:04,860 אבל הם שם, ושדברי חנויות כמו שם המשתמש שלך 902 00:57:04,860 --> 00:57:08,090 וסוג אחר של פרטים ברמה נמוכים יותר. 903 00:57:08,090 --> 00:57:12,880 אבל הפיסות העסיסיות של הפריסה של הזיכרון שלך היא הדבר הזה שנקרא המחסנית והערימה. 904 00:57:12,880 --> 00:57:17,470 הערימה שוב, שיהיה ברור, היא הזיכרון המשמש בכל פעם שפונקציות נקראות, 905 00:57:17,470 --> 00:57:19,710 בכל פעם יש משתנים מקומיים 906 00:57:19,710 --> 00:57:22,120 וכל פעם שיש פרמטרים שעברו בסביבה. 907 00:57:22,120 --> 00:57:24,490 כל זה קורה במחסנית. 908 00:57:24,490 --> 00:57:29,570 הגל שלא דבר עליו, אבל לקחת ניחוש מי שמשתמש בערימה. 909 00:57:31,120 --> 00:57:32,690 פשוט גוש אחר של זיכרון. 910 00:57:32,690 --> 00:57:36,620 זה קורה שיש להפיק כאן בראש, אבל זה כנס ציורי שרירותי. 911 00:57:36,620 --> 00:57:41,670 שכנראה כבר משתמש בזיכרון מהערימה לשבועות? 912 00:57:41,670 --> 00:57:44,830 טכני זה אבל בעקיפין. >> [תלמיד] GetString. 913 00:57:44,830 --> 00:57:47,950 GetString וmalloc. אז הנה ההבדל המהותי. 914 00:57:47,950 --> 00:57:51,300 >> אתה יודע לשבועות האחרונים כי אם אתה צריך זיכרון, רק מצהיר על משתנה. 915 00:57:51,300 --> 00:57:54,560 אם אתה זקוק להרבה זיכרון, להצהיר על מערך ממש בתוך הפונקציה שלך. 916 00:57:54,560 --> 00:57:59,620 אבל הבעיה ששמרנו פונה היא אם להצהיר על משתנה מקומי בתוך פונקציות, 917 00:57:59,620 --> 00:58:05,340 ברגע שחוזר לתפקד, מה קורה לזיכרון והמשתנים האלה? 918 00:58:05,340 --> 00:58:09,620 פשוט סוג שלו כבר לא שלך, נכון? זה פשוט נעלם סוג של מושגית. 919 00:58:09,620 --> 00:58:13,950 זה עדיין פיזי קיים, כמובן, אבל זה כבר לא זכותך להשתמש. 920 00:58:13,950 --> 00:58:17,160 זה כמובן בעייתי אם אתה רוצה לכתוב פונקציות בחיים 921 00:58:17,160 --> 00:58:20,440 כי בעצם להקצות זיכרון ולא להחזיר אותו באופן מיידי. 922 00:58:20,440 --> 00:58:24,180 מקרה לדוגמה: המטרה של GetString בחיים הוא אין לי מושג מראש 923 00:58:24,180 --> 00:58:26,390 עד כמה גדול של מחרוזת אני הולך להקליד במקלדת, 924 00:58:26,390 --> 00:58:30,390 אבל זה חייב להיות מסוגל להקצות זיכרון להחזיק דוד או שלום 925 00:58:30,390 --> 00:58:32,860 או כל מאמר שייתכן שהמשתמש הקליד פנימה 926 00:58:32,860 --> 00:58:35,280 אז GetString כבר באמצעות malloc. 927 00:58:35,280 --> 00:58:38,910 Malloc לכן יש שימוש לא המחסנית; 928 00:58:38,910 --> 00:58:40,770 במקום זאת משתמשת בדבר הזה שנקרא הערימה. 929 00:58:40,770 --> 00:58:44,430 אין שום דבר שונה בזיכרון. זה לא מהר או לאט יותר או משהו כזה. 930 00:58:44,430 --> 00:58:46,570 זה רק פיזי במקום אחר. 931 00:58:46,570 --> 00:58:50,120 >> אבל הכלל הוא שהזיכרון זה מוקצה על הערימה 932 00:58:50,120 --> 00:58:56,180 לעולם לא יילקח ממך עד שאתה קורא - תיקח ניחוש - בחינם. 933 00:58:56,180 --> 00:59:00,510 לעומת זאת, כל זיכרון שאתה מבקש במחסנית רק על ידי הכרזה על מערך 934 00:59:00,510 --> 00:59:03,320 או הצהרה על משתנה כמו שעשינו במשך שבועות, 935 00:59:03,320 --> 00:59:05,640 כי כברירת מחדל בסופו במחסנית. 936 00:59:05,640 --> 00:59:09,550 וזה עובד 90% מהזמן רבים, אך במקרים נדירים אלה 937 00:59:09,550 --> 00:59:12,470 שבו אתה רוצה להקצות זיכרון ולשמור על הסביבה, 938 00:59:12,470 --> 00:59:14,730 אז אתה צריך להשתמש בפונקציה כמו malloc. 939 00:59:14,730 --> 00:59:19,370 או יש לנו להשתמש בפונקציה כמו GetString, אשר בתורו משתמש malloc. 940 00:59:19,370 --> 00:59:23,300 בואו נראים לאן זה עלול להישבר ואז להציץ בינקי. 941 00:59:23,300 --> 00:59:25,820 אנחנו נחזור לזה בעתיד. 942 00:59:25,820 --> 00:59:29,270 הנה תכנית סופר פשוטה שב 2 השורות הראשונות מה הוא עושה? 943 00:59:29,270 --> 00:59:33,460 באנגלית, מה 2 השורות הראשונות אלה של קוד לעשות בתוך ראשיות? 944 00:59:33,460 --> 00:59:35,600 [תגובת תלמיד לא נשמעה] 945 00:59:35,600 --> 00:59:37,880 זהיר. זה לא נותן לי את הכתובת של x או y. 946 00:59:37,880 --> 00:59:41,840 [תלמיד] נותן עצות לints. >> טוב. תן לי 2 מצביעים למספרים שלמים. 947 00:59:41,840 --> 00:59:45,130 במילים אחרות, תן לי 2 נתחי זיכרון שאני שומר ציור היום, 948 00:59:45,130 --> 00:59:46,950 למרות שמחקתי אותו עכשיו, כריבועים. 949 00:59:46,950 --> 00:59:50,000 תן לי 2 גושים של זיכרון, אחד בשם x, y אחד שנקרא - 950 00:59:50,000 --> 00:59:54,320 מוקדם יותר התקשרתי אליהם ולא של - ומהו סוג שהנתח של זיכרון? 951 00:59:54,320 --> 00:59:57,160 זה הולך לאחסון כתובת. 952 00:59:57,160 --> 00:59:59,110 זה מסוג int *. 953 00:59:59,110 --> 01:00:01,630 >> אז הכתובת של int סופו של דבר לחיות בx, 954 01:00:01,630 --> 01:00:03,860 הכתובת של int סופו של דבר לחיות בy, 955 01:00:03,860 --> 01:00:08,460 אבל בהתחלה, מה שבפנים של x ו-y? מי יודע? ערכי זבל. 956 01:00:08,460 --> 01:00:10,180 אין לזה שום קשר עם מצביעים. 957 01:00:10,180 --> 01:00:12,720 אם אנחנו לא צריכים לשים שם משהו, מי יודע מה בעצם יש? 958 01:00:12,720 --> 01:00:18,950 עכשיו, x. מה קורה כאן? זה חוקי עכשיו כי x הוא מצביע. זה * int. 959 01:00:18,950 --> 01:00:21,870 אז זה אומר שאני יכול לשים בx הכתובת של נתח חלק מזיכרון. 960 01:00:21,870 --> 01:00:25,120 מה malloc לא מחזיר? מושלם, היא מחזירה את כתובות, 961 01:00:25,120 --> 01:00:28,510 את הכתובת של הבית הראשון בכל נתח של זיכרון. 962 01:00:28,510 --> 01:00:31,140 כמה בתים הוא כנראה זה הקצאה, למשל, במכשיר? 963 01:00:31,140 --> 01:00:33,510 מה הגודל של int? 4. 964 01:00:33,510 --> 01:00:36,600 אם אתה חושב שתחזור ל1 שבוע, זה לא סופר חשוב תמיד לזכור כי, 965 01:00:36,600 --> 01:00:38,870 אבל במקרה הזה זה שימושי לדעת, 4 בתים. 966 01:00:38,870 --> 01:00:41,770 אז זו הקצאה על 4 בתי הערימה 967 01:00:41,770 --> 01:00:46,110 וזה מחזיר את הכתובת של הראשון אליי באופן שרירותי. 968 01:00:46,110 --> 01:00:47,700 עכשיו, מה עושה X? 969 01:00:47,700 --> 01:00:52,200 * X = 42 עושים מה? 970 01:00:52,200 --> 01:00:57,150 אם בנקודה זו בסיפור שיש לנו X, שנראה כמו זה עם קצת ערך זבל, 971 01:00:57,150 --> 01:01:04,120 זה עכשיו y עם קצת ערך זבל, עכשיו בקו 3 שהוקציתי 4 בתים. 972 01:01:04,120 --> 01:01:06,950 תמונה זו למעשה נראית כך. 973 01:01:06,950 --> 01:01:12,010 או לייתר דיוק, אם זו כתובת שרירותית 123, זה מה הסיפור שלנו עכשיו נראה. 974 01:01:12,010 --> 01:01:23,940 * X = 42 עכשיו מה זה אומר? זה אומר ללכת ל123 כתובת ואת המספר 42 שם. 975 01:01:23,940 --> 01:01:26,220 אני לא צריך לצייר הקווים האלה כי אנחנו לא עושים את המייתרים. 976 01:01:26,220 --> 01:01:29,480 >> הייתי צריך פשוט כתבתי את זה ככה, ורק לצורך ההפגנה, 977 01:01:29,480 --> 01:01:33,240 42 כסוג של int תופסים הרבה מקום, 4 בתים. 978 01:01:33,240 --> 01:01:35,960 אז זה מה שקרה שם, אבל יש בעיה עכשיו. 979 01:01:35,960 --> 01:01:40,580 * Y = 13. מה שהולך לקרות כאן? 980 01:01:40,580 --> 01:01:46,470 הבעיה היא * y בעולם המפושט רק אומר ללכת לכתובת בy. 981 01:01:46,470 --> 01:01:48,590 מה בy? זה קצת ערך זבל. 982 01:01:48,590 --> 01:01:53,150 אז בואו נניח שזה ערך זבל 5551212, משהו מטורף כזה. 983 01:01:53,150 --> 01:01:56,750 * אמצעי y ללכת לטפל 5551212. 984 01:01:56,750 --> 01:02:00,450 זה כמו כאן. זה לא קיים, למשל. 985 01:02:00,450 --> 01:02:05,310 אז * y מקבל 13 אמצעי שאני מנסה לצייר כאן 13. זה לא קיים. 986 01:02:05,310 --> 01:02:08,790 אני חרגתי מהקטע של הלוח. מה אני מקבל? 987 01:02:08,790 --> 01:02:14,930 שאשמת פילוח ההודעה הסודית בגלל שאני מנסה לשים בזיכרון 988 01:02:14,930 --> 01:02:19,470 ערך כמו 13 במקום שאינו קיימים. 989 01:02:19,470 --> 01:02:23,900 שאר התכנית יכול לעבוד בסדר, אבל עד שזה לא נקודה. 990 01:02:23,900 --> 01:02:25,350 אז בואו ננסה לספר את הסיפור הזה. 991 01:02:25,350 --> 01:02:27,830 אנחנו נחזור לזה פעם אחת שדברנו עליו קללה. 992 01:02:27,830 --> 01:02:30,290 בואו נחזור לזה, ולהשלים עם הדבר הזה שנקרא בינקי, 993 01:02:30,290 --> 01:02:33,710 שההיזכרות היא פרוף בסטנפורד יושב בבית ולשחק בפלסטלינה, 994 01:02:33,710 --> 01:02:36,380 כדי לספר את הסיפור הזה בדיוק אותה תכנית. 995 01:02:36,380 --> 01:02:40,580 זה רק כ 3 דקות ארוכות. כאן יש לנו בינקי. 996 01:02:40,580 --> 01:02:45,030 [דובר גברי בוידאו] היי בינקי, יתעורר. זה זמן בשביל כיף מצביע. 997 01:02:45,030 --> 01:02:50,080 [ינקי] מה זה? למד על מצביעים? או, יופי! 998 01:02:50,080 --> 01:02:53,700 [דובר זכר] ובכן, כדי להתחיל בעבודה, אני מניח שאנחנו הולכים צריכים כמה עצות. 999 01:02:53,700 --> 01:02:57,890 >> [ינקי] אוקיי. קוד זה מקצה 2 מצביעים אשר יכול להצביע על מספרים שלמים. 1000 01:02:57,890 --> 01:03:02,220 [דובר זכר] אוקיי. ובכן, אני רואה את 2 מצביעים, אבל הם לא נראים שהצבעה לכל דבר. 1001 01:03:02,220 --> 01:03:05,550 [ינקי] זה נכון. בתחילה, מצביעים אינם מצביעים על שום דבר. 1002 01:03:05,550 --> 01:03:09,270 את הדברים שהם יצביעו לנקראים pointees, ולהגדיר אותן היא צעד נפרד. 1003 01:03:09,270 --> 01:03:12,330 [דובר זכר] אה, נכון, נכון. ידעתי את זה. את pointees הם נפרדים. 1004 01:03:12,330 --> 01:03:15,630 אה, אז איך אתה להקצות pointee? 1005 01:03:15,630 --> 01:03:21,510 [ינקי] אוקיי. קוד זה מקצה pointee שלם חדש, וחלק זה מגדיר x כדי להצביע על זה. 1006 01:03:21,510 --> 01:03:23,500 [דובר זכר] היי, זה נראה טוב יותר. 1007 01:03:23,500 --> 01:03:26,030 אז להפוך אותו לעשות משהו. >> [ינקי] אוקיי. 1008 01:03:26,030 --> 01:03:30,300 אני יהיה dereference x המצביע כדי לאחסן את המספר 42 לpointee. 1009 01:03:30,300 --> 01:03:34,410 על הטריק הזה אני צריך שרביט הקסמים שלי לביטול הפניה. 1010 01:03:34,410 --> 01:03:38,610 [דובר זכר] שרביט הקסם שלך ביטול הפניה? זה נהדר. 1011 01:03:38,610 --> 01:03:44,230 [ינקי] זה מה שנראה כמו הקוד. אני רק להגדיר את המספר ו... [Popping צליל] 1012 01:03:44,230 --> 01:03:46,100 [דובר זכר] היי, יראה, הנה זה הולך. 1013 01:03:46,100 --> 01:03:50,990 אז עושה dereference על x כדלקמן החץ לגשת pointee, 1014 01:03:50,990 --> 01:03:53,230 במקרה זה כדי לאחסן 42 שם. 1015 01:03:53,230 --> 01:03:57,630 היי, נסה להשתמש בו כדי לאחסן את המספר 13 באמצעות מצביע האחר, y. 1016 01:03:57,630 --> 01:04:03,250 [ינקי] אוקיי. אני פשוט אלך לכאן כדי לקבל את y והמספר 13 הקים 1017 01:04:03,250 --> 01:04:08,360 ואז לקחת את השרביט של ביטול הפניה ופשוט ... [זמזום] וואו! 1018 01:04:08,360 --> 01:04:10,980 [דובר זכר] הו היי, זה לא עבד. 1019 01:04:10,980 --> 01:04:14,870 >> תגיד, בינקי, אני לא חושב שביטול הפנית y הוא רעיון טוב 1020 01:04:14,870 --> 01:04:17,880 בגלל הגדרת pointee היא צעד נפרד 1021 01:04:17,880 --> 01:04:19,850 ואני לא חושב שאי פעם עשינו את זה. 1022 01:04:19,850 --> 01:04:21,770 [ינקי] הממ, נקודה טובה. 1023 01:04:21,770 --> 01:04:26,640 [דובר זכר] כן. אנחנו הקצינו את y המצביע אבל לא להגדיר אותו כדי להצביע על pointee. 1024 01:04:26,640 --> 01:04:28,780 [ינקי] הממ, אדוק ביותר. 1025 01:04:28,780 --> 01:04:30,690 [דובר זכר] היי, אתה נראה טוב שם, בינקי. 1026 01:04:30,690 --> 01:04:34,160 אתה יכול לתקן אותו כך שנקודתי y לאותו pointee כ x? >> [ינקי] בטח. 1027 01:04:34,160 --> 01:04:37,100 אני אשתמש שרביט הקסמים שלי למשימת מצביע. 1028 01:04:37,100 --> 01:04:39,070 [דובר זכר] זאת הולכת להיות בעיה כמו בעבר? 1029 01:04:39,070 --> 01:04:40,840 [ינקי] לא, זה לא נוגע לpointees. 1030 01:04:40,840 --> 01:04:44,780 זה פשוט משנה את מצביע אחד למצביע על אותו הדבר כמו אחר. [Popping צליל] 1031 01:04:44,780 --> 01:04:48,570 [דובר זכר] הו, אני רואה. עכשיו נקודתי y לאותו המקום כמו x. 1032 01:04:48,570 --> 01:04:51,140 אז תחכה. עכשיו y הוא קבוע. יש pointee. 1033 01:04:51,140 --> 01:04:54,520 אז אתה יכול לנסות את השרביט של ביטול הפניה שוב לשלוח 13 מעל. 1034 01:04:54,520 --> 01:04:58,130 [ינקי] אה, בסדר. הנה זה בא. [Popping צליל] 1035 01:04:58,130 --> 01:05:01,250 [דובר זכר] היי, תראה את זה. עכשיו עובד על ביטול הפנית y. 1036 01:05:01,250 --> 01:05:05,200 ומכיוון שהמצביעים משתפים שpointee אחד, שניהם רואים 13. 1037 01:05:05,200 --> 01:05:06,910 [ינקי] כן, שיתוף. לא משנה מה. 1038 01:05:06,910 --> 01:05:08,880 >> אז אנחנו הולכים להתחלף עכשיו? 1039 01:05:08,880 --> 01:05:11,420 [דובר זכר] אה, יראה, נגמרנו לנו זמן. >> [ינקי] אבל - 1040 01:05:11,420 --> 01:05:13,880 [דובר זכר] רק יזכור את 3 כללים המצביעים. 1041 01:05:13,880 --> 01:05:18,630 מספר 1, המבנה הבסיסי הוא שיש לך ומצביע הוא מצביע אל pointee. 1042 01:05:18,630 --> 01:05:23,120 אבל המצביע וpointee הם נפרדים, והטעות הנפוצה היא להגדיר מצביע 1043 01:05:23,120 --> 01:05:25,680 אבל לשכוח לתת לזה pointee. 1044 01:05:25,680 --> 01:05:29,580 מספר 2, ביטול הפנית המצביע מתחיל במצביע ועוקב אחריה במשך החץ 1045 01:05:29,580 --> 01:05:31,060 כדי לגשת pointee. 1046 01:05:31,060 --> 01:05:34,340 כפי שכולנו יודעים, זה עובד רק אם יש pointee, 1047 01:05:34,340 --> 01:05:36,460 איזה סוג של חוזר לכלל מס '1. 1048 01:05:36,460 --> 01:05:39,870 מספר 3, הקצאת מצביע לוקח מצביע אחד ומשנה אותו 1049 01:05:39,870 --> 01:05:42,390 להצביע לאותו pointee כמצביע אחר. 1050 01:05:42,390 --> 01:05:45,890 אז אחרי המשימה, את 2 המצביעים יצביעו לאותו pointee. 1051 01:05:45,890 --> 01:05:47,800 לפעמים זה נקרא שיתוף. 1052 01:05:47,800 --> 01:05:50,910 >> וזה כל מה שיש בו באמת. להתראות. 1053 01:05:50,910 --> 01:05:55,840 זה בינקי. זה CS50. ניראה אותך בשבוע הבא. [מחיאות כפות] 1054 01:05:55,840 --> 01:05:59,000 >> [CS50.TV]