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
>> सी पुस्तकालयों पर वीडियो में, हम कैसे आप # हेडर फ़ाइलों में शामिल के बारे में बात करते हैं

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
नाव, सीमा, मानक, bool, और मानक उदारीकरण.

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
इस लाइन वास्तव में सिर्फ चार * प्रकार के लिए एक उर्फ ​​बनाता है,

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
हम बदले में घोषित, उपयोगकर्ता और वापसी chars, डबल्स, मंगाई, 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
इसे से सीखते हैं, और यदि आप चाहें तो इसे विभिन्न मशीनों पर recompile,

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
वे एक समय पाश का उपयोग करने के लिए निवेश की एक लाइन के लिए उपयोगकर्ता prompt.

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
यह एक चार, एक डबल, एक नाव, आदि

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 कॉल कि उपयोगकर्ता इनपुट parses है.

57
00:03:34,720 --> 00:03:38,160
Sscanf इनपुट प्रारूप रूपांतरण परिवार का हिस्सा है.

58
00:03:38,160 --> 00:03:42,300
यह मानक io.h में रहता है, और अपने काम करने के लिए एक सी स्ट्रिंग को पार्स है,

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 पहला तर्क एक चार * एक चरित्र के लिए एक सूचक है.

65
00:04:03,330 --> 00:04:05,150
समारोह में ठीक से काम करने के लिए,

66
00:04:05,150 --> 00:04:08,340
कि चरित्र एक सी स्ट्रिंग का पहला वर्ण होना चाहिए,

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
सी प्रकार है कि हम चाहते हैं कि करने के लिए बदलने की sscanf इंगित करता है.

75
00:04:35,430 --> 00:04:40,090
GetInt में, आप देख सकते हैं कि वहाँ एक% d और% ग है.

76
00:04:40,090 --> 00:04:48,690
इसका मतलब यह है sscanf एक दशमलव int कि कोशिश करेंगे -% d और एक चार -% ग.

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 फोन से पहले ठीक है, हम एक n नामक int और ढेर पर एक चार कॉल ग की घोषणा

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
एक प्रतिशत हस्ताक्षर नहीं prefixed वर्ण रूपांतरण प्रांप्ट नहीं.

92
00:05:47,280 --> 00:05:50,380
बल्कि वे सिर्फ प्रारूप विनिर्देशन के लिए जोड़.

93
00:05:50,380 --> 00:05:56,500
>> उदाहरण के लिए, अगर GetInt में प्रारूप स्ट्रिंग एक% d बजाय थे

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 है कि परिवर्तित हो जाएगा और int चर n में संग्रहीत द्वारा पीछा

103
00:06:29,300 --> 00:06:33,090
खाली स्थान के कुछ राशि के द्वारा पीछा किया, और एक चरित्र के बाद

104
00:06:33,090 --> 00:06:35,810
चार चर ग में संग्रहीत.

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
और ये आप शारीरिक श्रम का एक बहुत बचाने के लिए जब सी. में तार व्याकरण के नियमों के अनुसार या व्याकरण सम्मत (शब्द की) व्याख्या करना करने की कोशिश कर रहा है कर सकते हैं

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
चूंकि एक स्ट्रिंग chars के एक दृश्य है,

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
हमें पता नहीं कितने chars उपयोगकर्ता में टाइप करेंगे

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
एक smartphone या सीमित स्मृति के साथ कुछ और तरह से एक डिवाइस -

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-चार ब्लॉक है.

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
आप इस अनुभव हो सकता है गलती से जब arrays के साथ प्रोग्रामिंग.

160
00:10:01,570 --> 00:10:05,620
यदि आप 10 ints की एक सरणी है, तुम्हें कुछ पढ़ने या लिखने की कोशिश कर रहा से रोकता है

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

162
00:10:07,810 --> 00:10:10,000
वहाँ कोई संकलक चेतावनियाँ या त्रुटियाँ हैं.

163
00:10:10,000 --> 00:10:13,250
कार्यक्रम बस सीधे आगे भूलों और स्मृति accesses

164
00:10:13,250 --> 00:10:18,150
जहां यह सोचता है कि 15 int हो सकता है, और यह अपने अन्य चर अधिलेखित कर सकते हैं.

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
एक है क्योंकि अगर अगले मुक्त सूचकांक 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
>> अंत में, हम बफर करने के लिए चार संलग्न.

194
00:12:04,170 --> 00:12:08,200
एक बार जब उपयोगकर्ता हिट दर्ज करें या लौटने के लिए, एक नई लाइन संकेत

195
00:12:08,200 --> 00:12:12,050
या विशेष चार - नियंत्रण घ - जो इनपुट के अंत का संकेत है,

196
00:12:12,050 --> 00:12:16,240
हम देखने के लिए अगर उपयोगकर्ता वास्तव में सब पर कुछ भी टाइप करने के लिए जांच करते हैं.

197
00:12:16,240 --> 00:12:18,820
यदि नहीं, तो हम अशक्त लौट आते हैं.

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
हम malloc कॉल करने के लिए एक अतिरिक्त 1 जोड़ने के लिए,

203
00:12:34,220 --> 00:12:37,810
\ 0, इतना है कि वहाँ विशेष अशक्त टर्मिनेटर चरित्र के लिए जगह है

204
00:12:37,810 --> 00:12:41,990
जो हम स्ट्रिंग संलग्न करने के लिए एक बार हम पात्रों के बाकी हिस्सों में कॉपी,

205
00:12:41,990 --> 00:12:45,060
strcpy के बजाय strncpy का उपयोग

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]