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