1
00:00:00,000 --> 00:00:00,410

2
00:00:00,410 --> 00:00:03,130
>> דוד י מלאן: אז מתברר כי
העתקת מחרוזת היא לא כמעט כמו

3
00:00:03,130 --> 00:00:05,750
פשוט כמו העתקה פרימיטיבית,
כמו int או לצוף.

4
00:00:05,750 --> 00:00:09,190
אחרי הכל, מתחת למכסת מנוע מחרוזת
הוא תווים ברצף.

5
00:00:09,190 --> 00:00:13,130
אז העתקת מחרוזת, ולכן, יש ל
כרוך בהעתקה שכולו הרצף של

6
00:00:13,130 --> 00:00:14,240
תווים.

7
00:00:14,240 --> 00:00:17,470
>> בואו נפנה את תשומת הלב שלנו אחזור לזה
היישום האחרון ולקרוע את זה

8
00:00:17,470 --> 00:00:21,470
קו, מחרוזת לא שווה S, אשר
ברור שלא היה מספיק.

9
00:00:21,470 --> 00:00:24,440
בואו נחליף אותו בקו ש
נראה, במקום, כמו זה.

10
00:00:24,440 --> 00:00:34,020
לא מחרוזת מקבל malloc של אורך מחרוזת של
בתוספת פעמים 1 שעה בגודל של char.

11
00:00:34,020 --> 00:00:36,320
>> עכשיו יש ציטוט קצת הולכים
בקו הזה של קוד.

12
00:00:36,320 --> 00:00:39,330
ראשית, malloc, קיצור של זיכרון
הקצאה, ו

13
00:00:39,330 --> 00:00:40,700
הפונקציה עושה בדיוק את זה.

14
00:00:40,700 --> 00:00:44,740
בהינתן מספר שלם, מחזיר לך
כתובת של נתח של זיכרון

15
00:00:44,740 --> 00:00:45,960
בתים שרבים.

16
00:00:45,960 --> 00:00:50,090
בינתיים, אורך המחרוזת של ים בתוספת 1
נועד כדי לציין שאנחנו רוצים כמו

17
00:00:50,090 --> 00:00:54,690
בתים רבים כמו ים כבר תופס,
כולל שליחות קטלנית שלה ריקה,

18
00:00:54,690 --> 00:00:57,050
קו נטוי הפוך 0 בסוף המחרוזת.

19
00:00:57,050 --> 00:01:00,170
>> בינתיים, אני לא זוכר שבהכרח
עד כמה גדול הוא char, אפילו

20
00:01:00,170 --> 00:01:04,340
אם כי ברוב המערכות זה פשוט 1
בתים, ולכן אני אקרא גודל של char כדי

21
00:01:04,340 --> 00:01:08,210
להבין באופן דינמי עד כמה גדול
אופי אדם הוא.

22
00:01:08,210 --> 00:01:12,550
ברגע שהתרביתי ביחד, אני חוזר
מספר כולל של בתים שאני צריך.

23
00:01:12,550 --> 00:01:14,680
>> אבל מה אם malloc נכשל
להחזיר את הזיכרון שאנחנו צריכים?

24
00:01:14,680 --> 00:01:16,730
הייתי הטוב ביותר לבדוק שכדלקמן.

25
00:01:16,730 --> 00:01:23,330
אם לא שווה אפס, אז אני הולך ראשון
לים חופשי, חזר הזיכרון על ידי גט

26
00:01:23,330 --> 00:01:27,120
מחרוזת, ולאחר מכן אני הולך
בתמורה 1, כדי לסמן שגיאה.

27
00:01:27,120 --> 00:01:30,360
>> אבל אם הכל טוב, אני הולך להמשיך
להשתמש בארבע לולאה ולחזר

28
00:01:30,360 --> 00:01:31,110
באופן הבא.

29
00:01:31,110 --> 00:01:36,000
עבור int אני מקבל 0, n שווים
אורך המחרוזת של s.

30
00:01:36,000 --> 00:01:40,350
אני הולך לעשות את זה כל עוד הוא אני
קטן או שווה ל-n, כך שאני

31
00:01:40,350 --> 00:01:44,460
לחזר דרך וכולל
אופי המסתיים null בים.

32
00:01:44,460 --> 00:01:47,450
>> ועל כל איטרציה, אני
הולך להגדיל i.

33
00:01:47,450 --> 00:01:52,496
בינתיים, בתוך לולאה זו, העתק
ים של הדמות של i-ה לi-th של t

34
00:01:52,496 --> 00:01:59,310
מיקום, זה מספיק כדי לעשות את t
סוגר אני מקבל ים סוגר i.

41
00:01:59,320 --> 00:02:02,750
>> בואו עכשיו להציל, לקמפל, ו
להפעיל את התכנית חדשה.

42
00:02:02,750 --> 00:02:06,690
הפוך את עותק לוכסן נקודת עותק 1 1.

43
00:02:06,690 --> 00:02:09,460
ואני אגיד משהו כמו
שלום בכל אותיות קטנות.

44
00:02:09,460 --> 00:02:12,280
ותודה לאל, זה זמן שלי
מקורי נשאר ללא שינוי.

45
00:02:12,280 --> 00:02:13,660
שלום בכל אותיות קטנות.

46
00:02:13,660 --> 00:02:15,540
אבל העותק הוא, אכן, באותיות גדולות.

47
00:02:37,120 --> 00:02:38,963