1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 הספרייה]

2
00:00:02,490 --> 00:00:04,220
[נייט Hardison] [אוניברסיטת הרווארד]

3
00:00:04,220 --> 00:00:07,260
[זה CS50. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
ספריית CS50 היא כלי מועיל שהתקנו על המכשיר

5
00:00:11,510 --> 00:00:15,870
כדי לעשות את זה יותר קל לך לכתוב תוכניות שיוזמי קלט.

6
00:00:15,870 --> 00:00:21,670
בסרטון הזה, אנחנו מסיטים את הווילון ומסתכלים על מה בדיוק נמצא בספריית CS50.

7
00:00:21,670 --> 00:00:25,520
>> בוידאו בספריות C, אנחנו מדברים על איך אתה כולל קבצי כותרות #

8
00:00:25,520 --> 00:00:27,570
של הספרייה בקוד המקור שלך,

9
00:00:27,570 --> 00:00:31,150
ואז אתה מקשר עם קובץ בינארי ספרייה בשלב הקישור

10
00:00:31,150 --> 00:00:33,140
של תהליך ההידור.

11
00:00:33,140 --> 00:00:36,440
את קבצי הכותרת לציין את הממשק של הספרייה.

12
00:00:36,440 --> 00:00:41,280
כלומר, הם מפרטים את כל המשאבים שיש בספרייה זמינה עבורך לשימוש,

13
00:00:41,280 --> 00:00:45,250
כמו הצהרות פונקציות, קבועים, וסוגי נתונים.

14
00:00:45,250 --> 00:00:48,890
הקובץ בינארי הספרייה מכיל את היישום של הספרייה,

15
00:00:48,890 --> 00:00:54,580
הנאסף מקבצי הכותרת של הספרייה והספרייה של קבצי קוד מקור. ג.

16
00:00:54,580 --> 00:00:59,820
>> קובץ ספריית בינארי הוא לא מאוד מעניין להסתכל על זה מאז, ובכן, בינארי.

17
00:00:59,820 --> 00:01:03,300
אז, בואו נסתכל על קבצי הכותרת לספרייה במקום.

18
00:01:03,300 --> 00:01:07,710
במקרה זה, יש רק אחד בשם קובץ הכותרת cs50.h.

19
00:01:07,710 --> 00:01:11,040
אנחנו כבר התקנו אותו בספריית המשתמש כולל

20
00:01:11,040 --> 00:01:15,150
יחד עם כותרת קבצים בספריות האחרות במערכת.

21
00:01:15,150 --> 00:01:21,530
>> אחד הדברים הראשונים שתבחינו הוא שcs50.h # כולל קבצי כותרת מספרית אחרות -

22
00:01:21,530 --> 00:01:25,670
לצוף, גבולות, סטנדרטי בול, וlib הסטנדרטי.

23
00:01:25,670 --> 00:01:28,800
שוב, בעקבות העיקרון שלא להמציא את הגלגל מחדש,

24
00:01:28,800 --> 00:01:33,490
בנינו ספריית CS0 שימוש בכלים אחרים שספקו לנו.

25
00:01:33,490 --> 00:01:38,690
>> הדבר הבא שתראו בספרייה הוא שאנחנו מגדירים סוג חדש בשם "מחרוזת".

26
00:01:38,690 --> 00:01:42,330
קו זה באמת רק יוצר כינוי לטיפוס * char,

27
00:01:42,330 --> 00:01:46,000
כך שזה לא פלא להחדיר סוג המחרוזת החדש עם תכונות

28
00:01:46,000 --> 00:01:49,650
נפוץ הקשורים אובייקטי מחרוזת בשפות אחרות,

29
00:01:49,650 --> 00:01:50,850
כגון אורך.

30
00:01:50,850 --> 00:01:55,180
הסיבה שעשינו זאת היא כדי להגן על מתכנתים חדשים מאת הפרטים העסיסיים

31
00:01:55,180 --> 00:01:57,580
של מצביעים עד שהם מוכנים.

32
00:01:57,580 --> 00:02:00,130
>> החלק הבא של קובץ הכותרת הוא ההכרזה על הפונקציות

33
00:02:00,130 --> 00:02:04,410
שCS50 הספרייה מספקת יחד עם תיעוד.

34
00:02:04,410 --> 00:02:06,940
שים לב לרמת פירוט בהערות כאן.

35
00:02:06,940 --> 00:02:10,560
זה סופר חשוב, כך שאנשים יודעים כיצד להשתמש בפונקציות אלה.

36
00:02:10,560 --> 00:02:19,150
אנו מצהירים, בתורו, מתפקד להציג למשתמש ותווים חוזרים, זוגות, המרחף, ints,

37
00:02:19,150 --> 00:02:24,160
עוד מתגעגע, ומחרוזות, באמצעות טיפוס המחרוזת שלנו.

38
00:02:24,160 --> 00:02:26,260
בעקבות העיקרון של הסתרת מידע,

39
00:02:26,260 --> 00:02:31,640
יש לנו את ההגדרה שלנו בקובץ נפרד יישום ג -. cs50.c--

40
00:02:31,640 --> 00:02:35,110
ממוקם בספריית מקור המשתמש.

41
00:02:35,110 --> 00:02:38,040
אנו מספקים קובץ, כך שאתה יכול להעיף מבט על זה,

42
00:02:38,040 --> 00:02:41,490
ללמוד ממנה, והדר אותו על מחשבים שונים, אם תרצה,

43
00:02:41,490 --> 00:02:45,510
למרות שאנחנו חושבים שעדיף לעבוד על המכשיר במעמד הזה.

44
00:02:45,510 --> 00:02:47,580
בכל אופן, בואו נסתכל על זה עכשיו.

45
00:02:49,020 --> 00:02:54,620
>> פונקציות getchar, GetDouble, GetFloat, GetInt, וGetLongLong

46
00:02:54,620 --> 00:02:58,160
כולם נבנו על גבי פונקצית GetString.

47
00:02:58,160 --> 00:03:01,510
מתברר שכולם בצעו את אותו הדפוס במהות.

48
00:03:01,510 --> 00:03:04,870
הם משתמשים בלולאה תוך כדי לבקש ממשתמש שורה אחת של קלט.

49
00:03:04,870 --> 00:03:08,430
הם חוזרים ערך מיוחד אם תשומות משתמש קו ריק.

50
00:03:08,430 --> 00:03:11,750
הם מנסים לנתח את הקלט של המשתמש כסוג המתאים,

51
00:03:11,750 --> 00:03:15,010
יהיה זה char, כפול, מצוף, וכו '

52
00:03:15,010 --> 00:03:18,710
ואז הם גם מחזירים את התוצאה אם ​​הקלט היה מנותח בהצלחה

53
00:03:18,710 --> 00:03:21,330
או שהם reprompt המשתמש.

54
00:03:21,330 --> 00:03:24,230
>> ברמה גבוהה, אין שום דבר ממש מסובך כאן.

55
00:03:24,230 --> 00:03:28,760
היית יכול לכתוב קוד דומה מובנה עצמך בעבר.

56
00:03:28,760 --> 00:03:34,720
אולי החלק הכי מסתורי למראה הוא שיחת sscanf שמנתח הקלט של המשתמש.

57
00:03:34,720 --> 00:03:38,160
Sscanf הוא חלק ממשפחת המרה לפורמט הקלט.

58
00:03:38,160 --> 00:03:42,300
הוא חי בio.h הסטנדרטי, ואת העבודה שלה היא לנתח מחרוזת C,

59
00:03:42,300 --> 00:03:46,520
על פי פורמט מסוים, אחסון תוצאות הניתוח במשתנה

60
00:03:46,520 --> 00:03:48,720
המסופק על ידי המתקשר.

61
00:03:48,720 --> 00:03:53,570
מאז את פונקציות המרת פורמט הקלט הן פונקציות שימושיות מאוד, המשמשים באופן נרחב

62
00:03:53,570 --> 00:03:56,160
שלא סופר אינטואיטיבית בהתחלה,

63
00:03:56,160 --> 00:03:58,300
נעבור על כמה sscanf עובד.

64
00:03:58,300 --> 00:04:03,330
>> הטיעון הראשון הוא sscanf * char - מצביע לתו.

65
00:04:03,330 --> 00:04:05,150
לפונקציה כדי לעבוד כמו שצריכה,

66
00:04:05,150 --> 00:04:08,340
דמות שצריכה להיות התו הראשון של מחרוזת C,

67
00:04:08,340 --> 00:04:12,270
הסתיים עם אפס \ 0 אופי.

68
00:04:12,270 --> 00:04:15,120
זה הוא המחרוזת לנתח

69
00:04:15,120 --> 00:04:18,269
הטיעון השני לsscanf הוא מחרוזת תבנית,

70
00:04:18,269 --> 00:04:20,839
מועבר בדרך כלל כבקבוע מחרוזת,

71
00:04:20,839 --> 00:04:24,040
ושאולי ראה מחרוזת כזה בעת שימוש printf.

72
00:04:24,040 --> 00:04:28,650
סימן אחוזים במחרוזת התבנית מציין מציין המרה.

73
00:04:28,650 --> 00:04:30,850
הדמות בעקבות שלט אחוזים באופן מיידי,

74
00:04:30,850 --> 00:04:35,430
מציין את סוג C שאנחנו רוצים sscanf להמיר.

75
00:04:35,430 --> 00:04:40,090
בGetInt, אתה רואה שיש ד% וג%.

76
00:04:40,090 --> 00:04:48,690
משמעות הדבר הוא כי sscanf ינסה int עשרוני -% ד - ו char - ג%.

77
00:04:48,690 --> 00:04:51,510
לכל אחד מציין גיור במחרוזת התבנית,

78
00:04:51,510 --> 00:04:56,620
sscanf מצפה טיעון מקביל מאוחר יותר ברשימת הארגומנטים.

79
00:04:56,620 --> 00:05:00,850
טיעון שחייב להצביע על מיקום הולם מוקלד

80
00:05:00,850 --> 00:05:04,000
שבו לאחסון תוצאה מההמרה.

81
00:05:04,000 --> 00:05:08,910
>> הדרך האופיינית לעשות זאת היא ליצור משתנית במחסנית לפני קריאת sscanf

82
00:05:08,910 --> 00:05:11,440
לכל פריט שברצונך לנתח מהמחרוזת

83
00:05:11,440 --> 00:05:15,520
ולאחר מכן להשתמש באופרטור הכתובת - האמפרסנד - להעביר מצביעים

84
00:05:15,520 --> 00:05:19,100
למשתנים האלה בשיחת sscanf.

85
00:05:19,100 --> 00:05:22,720
ניתן לראות כי בGetInt אנחנו עושים בדיוק את זה.

86
00:05:22,720 --> 00:05:28,240
ממש לפני שיחת sscanf, אנו מצהירים בשם int n וג שיחה char במחסנית,

87
00:05:28,240 --> 00:05:32,340
ואנחנו מעבירים אותם למצביעים לשיחת sscanf.

88
00:05:32,340 --> 00:05:35,800
לשים המשתנים הללו במחסנית עדיפה על שימוש בשטח שהוקצה

89
00:05:35,800 --> 00:05:39,350
בערמה עם malloc, מאחר שאתה למנוע את התקורה של שיחת malloc,

90
00:05:39,350 --> 00:05:43,060
ואתה לא צריך לדאוג לדליפת זיכרון.

91
00:05:43,060 --> 00:05:47,280
דמויות לא התחילית של סימן אחוזים אינן מנחות המרה.

92
00:05:47,280 --> 00:05:50,380
במקום זאת הם רק להוסיף למפרט התבנית.

93
00:05:50,380 --> 00:05:56,500
>> לדוגמה, אם מחרוזת התבנית בGetInt הייתה ד% במקום,

94
00:05:56,500 --> 00:05:59,800
sscanf הייתי לחפש את המכתב ואחריו int,

95
00:05:59,800 --> 00:06:04,360
ובזמן זה ינסה להמיר int, זה לא לעשות שום דבר אחר עם.

96
00:06:04,360 --> 00:06:07,440
החריג היחיד לכלל זה הוא ברווחים.

97
00:06:07,440 --> 00:06:11,030
תווי רווח לבנים במחרוזת התבנית להתאים לכל כמות הרווחים -

98
00:06:11,030 --> 00:06:12,890
אפילו בכלל לא.

99
00:06:12,890 --> 00:06:18,100
לכן, זו הסיבה שהתגובה מזכירה אולי עם מובילים ו / או רווח.

100
00:06:18,100 --> 00:06:22,910
לכן, בשלב זה, זה נראה כמו שיחת sscanf אנסה לנתח מחרוזת הקלט של המשתמש

101
00:06:22,910 --> 00:06:25,380
בבדיקה לרווחים מובילים אפשריים,

102
00:06:25,380 --> 00:06:29,300
אחרי int שיומר ומאוחסן במשתנת n int

103
00:06:29,300 --> 00:06:33,090
אחרי כמות מסוימת של שטח ריק, ואחריו תו

104
00:06:33,090 --> 00:06:35,810
מאוחסן במשתנה char.

105
00:06:35,810 --> 00:06:37,790
>> מה לגבי ערך ההחזרה?

106
00:06:37,790 --> 00:06:41,560
Sscanf יהיה לנתח את שורת הקלט מההתחלה ועד הסוף,

107
00:06:41,560 --> 00:06:44,860
לעצור כשהוא מגיע לסוף או כאשר דמות בקלט

108
00:06:44,860 --> 00:06:49,320
אינו תואם את דמות תבנית, או כשהוא לא יכול לעשות את המרה.

109
00:06:49,320 --> 00:06:52,690
זה ערך ההחזרה משמש לבודד בו היא מפסיקה.

110
00:06:52,690 --> 00:06:55,670
אם זה הפסיק, כי זה הגיע לסוף מחרוזת הקלט

111
00:06:55,670 --> 00:07:00,630
לפני ביצוע המרות ולפני שלא הצליח להתאים חלק מהמחרוזת בתבנית,

112
00:07:00,630 --> 00:07:04,840
אז EOF הקבוע המיוחד הוא חזר.

113
00:07:04,840 --> 00:07:08,200
אחרת, זה מחזיר את מספר ההמרות מוצלחות,

114
00:07:08,200 --> 00:07:14,380
אשר יכול להיות 0, 1 או 2, מאז שבקשנו שתי מרות.

115
00:07:14,380 --> 00:07:19,000
במקרה שלנו, אנו רוצים לוודא שמשתמש הקליד בint ורק int.

116
00:07:19,000 --> 00:07:23,370
>> לכן, אנחנו רוצים לחזור sscanf 1. רואה למה?

117
00:07:23,370 --> 00:07:26,850
אם sscanf חזר 0, לא גיורים שנעשו,

118
00:07:26,850 --> 00:07:31,690
כך שהמשתמש הקליד משהו אחר מאשר int בתחילת הקלט.

119
00:07:31,690 --> 00:07:37,100
אם sscanf מחזיר 2, ואז המשתמש לא מקליד אותו כראוי בתחילת הקלט,

120
00:07:37,100 --> 00:07:41,390
אבל אז הם הקלידו באיזו דמות שאינה רווח לבן אחרי

121
00:07:41,390 --> 00:07:44,940
מאז% ג ההמרה הצליחה.

122
00:07:44,940 --> 00:07:49,570
וואו, זה ממש הסבר ארוך לקריאה לפונקציה אחת.

123
00:07:49,570 --> 00:07:53,460
בכל מקרה, אם אתה רוצה מידע נוסף על sscanf והאחים שלו,

124
00:07:53,460 --> 00:07:57,130
לבדוק את הדפים, גוגל, או שניהם.

125
00:07:57,130 --> 00:07:58,780
יש המון אפשרויות מחרוזת תבנית,

126
00:07:58,780 --> 00:08:03,830
ואלה יכולים לחסוך לך הרבה עבודת כפות כאשר מנסים לנתח מחרוזות ב C.

127
00:08:03,830 --> 00:08:07,180
>> הפונקציה האחרונה בספרייה היא להסתכל GetString.

128
00:08:07,180 --> 00:08:10,310
מתברר כי GetString היא פונקציה מסובכת לכתוב כמו שצריך,

129
00:08:10,310 --> 00:08:14,290
למרות שזה נראה כמו משימה כה פשוטה, משותפת.

130
00:08:14,290 --> 00:08:16,170
מדוע זה כך?

131
00:08:16,170 --> 00:08:21,380
ובכן, בואו נחשוב על איך אנחנו הולכים לאחסן את הקו שהמשתמש מקליד פנימה

132
00:08:21,380 --> 00:08:23,880
מאז מחרוזת היא רצף של תווים,

133
00:08:23,880 --> 00:08:26,430
יתכן שעלינו לאחסן אותו במערך במחסנית,

134
00:08:26,430 --> 00:08:31,250
אבל הייתי צריכים לדעת כמה זמן המערך הולך להיות כאשר אנו מצהירים את זה.

135
00:08:31,250 --> 00:08:34,030
כמו כן, אם אנחנו רוצים לשים אותו על הערמה,

136
00:08:34,030 --> 00:08:38,090
אנחנו צריכים לעבור לmalloc את מספר הבתים שאנחנו רוצים להזמין,

137
00:08:38,090 --> 00:08:39,730
אבל זה בלתי אפשרי.

138
00:08:39,730 --> 00:08:42,760
אין לנו מושג כמה תווי המשתמש להקליד

139
00:08:42,760 --> 00:08:46,590
לפני שהמשתמש למעשה אין להקליד אותם.

140
00:08:46,590 --> 00:08:50,720
>> פתרון נאיבי לבעיה זו הוא פשוט להזמין נתח גדול מחלל, אומר,

141
00:08:50,720 --> 00:08:54,540
בלוק של 1000 תווים לקלט של המשתמש,

142
00:08:54,540 --> 00:08:57,980
בהנחה שהמשתמש לא יקליד במחרוזת כך הרבה זמן.

143
00:08:57,980 --> 00:09:00,810
זה רעיון רע משתי סיבות.

144
00:09:00,810 --> 00:09:05,280
ראשית, בהנחה שמשתמשת באופן טיפוסי לא להקליד בחוטים כל כך הרבה זמן,

145
00:09:05,280 --> 00:09:07,610
אתה יכול לבזבז הרבה זיכרון.

146
00:09:07,610 --> 00:09:10,530
במכונות מודרניות, זה לא יכול להיות בעיה אם אתה עושה את זה

147
00:09:10,530 --> 00:09:13,890
בהזדמנות אחת או שתיים מבודדת,

148
00:09:13,890 --> 00:09:17,630
אבל אם אתה לוקח את הקלט של המשתמש בלולאה ואחסון לשימוש מאוחר יותר,

149
00:09:17,630 --> 00:09:20,870
אתה יכול לשאוב את מהירות טונה של זיכרון.

150
00:09:20,870 --> 00:09:24,450
בנוסף, אם התכנית שאתה כותב היא למחשב קטן יותר -

151
00:09:24,450 --> 00:09:28,100
מכשיר כמו טלפון חכם או משהו אחר עם זיכרון מוגבל -

152
00:09:28,100 --> 00:09:32,060
פתרון זה יגרום לבעיות הרבה יותר מהר.

153
00:09:32,060 --> 00:09:36,450
הסיבה השנייה, רצינית יותר לא לעשות את זה היא שזה משאיר את התכנית שלך לפגיע

154
00:09:36,450 --> 00:09:39,710
עם מה שמכונה התקפת גלישת מאגר.

155
00:09:39,710 --> 00:09:45,840
בתכנות, מאגר נמצא בשימוש באופן זמני זיכרון לאחסון נתוני קלט או פלט

156
00:09:45,840 --> 00:09:48,980
אשר במקרה זה הוא הבלוק שלנו 1000-char.

157
00:09:48,980 --> 00:09:53,370
גלישת חוצץ מתרחשת כאשר נתונים נכתב עבר סוף הבלוק.

158
00:09:53,370 --> 00:09:57,790
>> לדוגמה, אם משתמש עושה בפועל בסוג יותר מ 1000 תווים.

159
00:09:57,790 --> 00:10:01,570
ייתכן חווה את זה בטעות כשתכנות עם מערכים.

160
00:10:01,570 --> 00:10:05,620
אם יש לך מערך של 10 ints, שום דבר לא עוצר אותך מלנסות לקרוא או לכתוב

161
00:10:05,620 --> 00:10:07,810
int 15.

162
00:10:07,810 --> 00:10:10,000
אין אזהרות מהדר או טעויות.

163
00:10:10,000 --> 00:10:13,250
התכנית רק מחדלים ישר קדימה וניגש לזיכרון

164
00:10:13,250 --> 00:10:18,150
שם הוא חושב int 15 יהיה, וזה יכול לדרוס משתנים האחרים שלך.

165
00:10:18,150 --> 00:10:22,040
במקרה הגרוע ביותר, אתה יכול להחליף חלק מהתכנית הפנימית שלך

166
00:10:22,040 --> 00:10:26,820
מנגנוני בקרה, גורם לתכנית שלך בעצם ביצוע הוראות שונות

167
00:10:26,820 --> 00:10:28,340
ממה שהתכוונת.

168
00:10:28,340 --> 00:10:31,360
>> עכשיו, זה לא נפוץ לעשות את זה בטעות,

169
00:10:31,360 --> 00:10:35,150
אבל זו טכניקה נפוצה למדי שרעים להשתמש כדי לשבור תוכניות

170
00:10:35,150 --> 00:10:39,080
ולשים את הקוד זדוני במחשבים של אנשים אחרים.

171
00:10:39,080 --> 00:10:42,910
לכן, אנחנו לא יכולים פשוט להשתמש בפתרון הנאיבי שלנו.

172
00:10:42,910 --> 00:10:45,590
אנחנו זקוקים לדרך כדי למנוע מהתוכניות שלנו מלהיות פגיע

173
00:10:45,590 --> 00:10:47,880
להתקפת גלישת מאגר.

174
00:10:47,880 --> 00:10:51,430
כדי לעשות זאת, אנחנו צריכים לוודא שהמאגר שלנו יכול לגדול ככל שאנו קוראים

175
00:10:51,430 --> 00:10:53,850
יותר קלט מהמשתמש.

176
00:10:53,850 --> 00:10:57,440
הפתרון? אנו משתמשים במאגר שהוקצה ערימה.

177
00:10:57,440 --> 00:10:59,950
מכיוון שאנו יכולים לשנות את גודלו באמצעות שינוי גודל פונקצית realloc,

178
00:10:59,950 --> 00:11:04,580
ואנו עוקבים אחר שני מספרים - מדד למקום הפנוי ליד בחיץ

179
00:11:04,580 --> 00:11:08,390
ואורכו או יכולתו של המאגר.

180
00:11:08,390 --> 00:11:13,210
אנו קוראים בתווים ממשתמש אחד בכל פעם באמצעות פונקצית fgetc.

181
00:11:13,210 --> 00:11:19,360
טיעון פונקצית fgetc לוקחת - stdin - הוא התייחסות למחרוזת הקלט הסטנדרטית,

182
00:11:19,360 --> 00:11:23,810
שערוץ קלט preconnected שמשמש להעברת הקלט של המשתמש

183
00:11:23,810 --> 00:11:26,270
מהמסוף לתכנית.

184
00:11:26,270 --> 00:11:29,890
>> בכל פעם שהמשתמש מקליד בדמות חדשה, שנבדוק אם המדד

185
00:11:29,890 --> 00:11:35,810
לחריץ הפנוי הבא בתוספת 1 הוא גדול מיכולתו של המאגר.

186
00:11:35,810 --> 00:11:39,690
1 מגיע בכי אם מדד התשלום הבא הוא 5,

187
00:11:39,690 --> 00:11:44,150
אז אורכו של המאגר שלנו חייב להיות 6 הודות ל0 אינדוקס.

188
00:11:44,150 --> 00:11:48,350
אם נגמרנו לנו מקום במאגר, ואז אנחנו מנסים לשנות את גודלו,

189
00:11:48,350 --> 00:11:51,690
להכפיל אותו כדי שנצמצם את מספר הפעמים שאנחנו גודל

190
00:11:51,690 --> 00:11:54,760
אם המשתמש מקליד במחרוזת ארוכה באמת.

191
00:11:54,760 --> 00:11:57,950
אם המחרוזת קבלה זמן רבה מדי או אם גמר זכרון ערימה,

192
00:11:57,950 --> 00:12:01,350
אנחנו משחררים את חיצנו ואפס תמורה.

193
00:12:01,350 --> 00:12:04,170
>> לבסוף, אנו לצרף char למאגר.

194
00:12:04,170 --> 00:12:08,200
ברגע שהמשתמש להיכנס או להחזיר, מסמן קו חדש,

195
00:12:08,200 --> 00:12:12,050
או char המיוחד - שליטת ד - מה שמסמן סוף הקלט,

196
00:12:12,050 --> 00:12:16,240
אנחנו עושים בדיקה כדי לראות אם משתמש הקליד בעצם בשום דבר בכלל.

197
00:12:16,240 --> 00:12:18,820
אם לא, תחזירו null.

198
00:12:18,820 --> 00:12:22,280
אחרת, משום שהמאגר שלנו הוא כנראה גדול יותר ממה שאנו צריכים,

199
00:12:22,280 --> 00:12:24,830
במקרה הגרוע ביותר זה כמעט פי שניים גדול כמו שאנחנו צריכים

200
00:12:24,830 --> 00:12:27,830
מאז שנכפיל כל פעם אנחנו גודל,

201
00:12:27,830 --> 00:12:31,840
אנחנו עושים עותק חדש של המחרוזת רק באמצעות כמות השטח שאנחנו צריכים.

202
00:12:31,840 --> 00:12:34,220
אנו מוסיפים תוספת 1 לשיחת malloc,

203
00:12:34,220 --> 00:12:37,810
כך שיש מקום לתו המיוחד null השליחות הקטלנית - \ 0,

204
00:12:37,810 --> 00:12:41,990
בו אנו לצרף למחרוזת ברגע שאנחנו להעתיק בשאר דמויות,

205
00:12:41,990 --> 00:12:45,060
באמצעות strncpy במקום strcpy

206
00:12:45,060 --> 00:12:48,830
כך שאנו יכולים לציין בדיוק כמה תווים שאנו רוצים להעתיק.

207
00:12:48,830 --> 00:12:51,690
Strcpy מעתיק עד שהוא פוגע \ 0.

208
00:12:51,690 --> 00:12:55,740
ואז אנחנו משחררים את החיץ שלנו ולהחזיר את העותק למתקשר.

209
00:12:55,740 --> 00:12:59,840
>> מי ידעה שפונקציה כזו כאילו תמימה יכולה להיות כל כך מסובכת?

210
00:12:59,840 --> 00:13:02,820
עכשיו אתה יודע מה הולך לתוך CS50 הספרייה.

211
00:13:02,820 --> 00:13:06,470
>> השם שלי הוא נייט Hardison, וזה CS50.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]