1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [5 सप्ताह]

2
00:00:02,760 --> 00:00:04,760
[डेविड जे Malan, हार्वर्ड विश्वविद्यालय]

3
00:00:04,760 --> 00:00:11,990
[यह CS50 है.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[महिला] वह झूठ बोल रहा है, के बारे में क्या है, मैं नहीं जानता कि.

5
00:00:17,780 --> 00:00:20,300
[आदमी] तो हम क्या जानते हो?

6
00:00:20,300 --> 00:00:24,120
[महिला] कि 9:15 पर, रे Santoya एटीएम पर था.

7
00:00:24,120 --> 00:00:27,420
[मैन] तो सवाल है, वह क्या था 9:16 पर कर रहे हैं?

8
00:00:27,420 --> 00:00:29,980
[महिला] कुछ में 9 मिमी शूटिंग.

9
00:00:29,980 --> 00:00:31,900
शायद वह निशानची देखा.

10
00:00:31,900 --> 00:00:34,000
[आदमी] या वह उसके साथ काम कर रहा था.

11
00:00:34,000 --> 00:00:36,330
[महिला] रुको. एक वापस जाओ.

12
00:00:36,330 --> 00:00:38,330
[आदमी] आप क्या देखते हैं?

13
00:00:38,330 --> 00:00:44,520
[♫ suspenseful संगीत ♫]

14
00:00:44,520 --> 00:00:48,320
[महिला] उसके चेहरे लाओ. पूर्ण स्क्रीन.

15
00:00:48,320 --> 00:00:51,230
[आदमी] उनकी चश्मा. >> एक प्रतिबिंब है.

16
00:00:51,230 --> 00:01:00,810
[♫ suspenseful संगीत ♫]

17
00:01:00,810 --> 00:01:03,580
मैन] यह है Nuevita बेसबॉल टीम है. वह अपने लोगो है.

18
00:01:03,580 --> 00:01:07,790
[महिला] और वह करने के लिए बात कर रहा है कि जो कोई भी जैकेट पहने हुए है.

19
00:01:07,790 --> 00:01:13,730
>> [दाऊद Malan] तो, इस CS50 5 सप्ताह है, और आज हम आप के लिए टीवी और फिल्म के एक बिट बर्बाद.

20
00:01:13,730 --> 00:01:16,170
तो जब भी आप यह यहाँ एक तरह एक शो देख रहे हैं,

21
00:01:16,170 --> 00:01:19,910
और पुलिस का कहना है कि "आपको लगता है कि साफ कर सकते हैं?" या "को बढ़ावा देने के"

22
00:01:19,910 --> 00:01:21,900
वहाँ कोई वास्तविक दुनिया में वृद्धि है.

23
00:01:21,900 --> 00:01:25,220
वास्तव में, क्या तुम सच में इस तरह एक छोटे से कुछ है.

24
00:01:25,220 --> 00:01:27,570
मैं एक पृष्ठ से कर्मचारियों तस्वीरें खींच लिया है.

25
00:01:27,570 --> 00:01:30,980
यह एक Photoshop नामक कार्यक्रम है. यह 1 2 Bowdens की है,

26
00:01:30,980 --> 00:01:36,300
1 3 वास्तव Bowdens, आज, क्योंकि हम श्रीमती Bowden यहाँ के रूप में अच्छी तरह से रोब और पॉल के साथ है.

27
00:01:36,300 --> 00:01:41,950
लेकिन यहाँ स्क्रीन पर रोब है, और अगर हम उस चमक पर ज़ूम वह हमेशा अपनी आंखों में था,

28
00:01:41,950 --> 00:01:47,600
क्या आप वास्तव में यह है कि क्या तुमने देखा है कि तुम क्या हो.

29
00:01:47,600 --> 00:01:51,690
यह है "बढ़ाया," तो "सीएसआई" यह एक बिट गलत है.

30
00:01:51,690 --> 00:01:55,190
वहाँ एक अन्य क्लिप है, अगर हम अब सिर्फ एक छोटा सा "सीएसआई" पर ले सकते हैं.

31
00:01:55,190 --> 00:01:58,500
आगे से बोलना अगर तुम चाहते हो के लिए यह एक अच्छा मुहावरा है

32
00:01:58,500 --> 00:02:10,280
अपने दोस्तों के साथ तकनीकी ध्वनि जब, वास्तव में, तुम बिल्कुल कुछ भी नहीं कह रहे हैं.

33
00:02:10,280 --> 00:02:12,970
>> [आदमी] सप्ताह के लिए मैं कोचवान खूनी हत्याओं के जांच की गई है

34
00:02:12,970 --> 00:02:15,360
एक निश्चित स्र्ग्ण आकर्षण के साथ.

35
00:02:15,360 --> 00:02:17,160
[महिला # 1] यह वास्तविक समय में है.

36
00:02:17,160 --> 00:02:22,930
[महिला # 2] मैं एक जीयूआई Visual Basic का उपयोग इंटरफ़ेस बनाने के लिए, अगर मैं एक आईपी पते को ट्रैक कर सकते हैं.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] तो अलग सिंक के ऑडियो, एक जीयूआई Visual Basic का उपयोग इंटरफ़ेस बनाने

38
00:02:29,570 --> 00:02:31,820
एक आईपी पते को ट्रैक करने के लिए पूरी तरह बकवास है.

39
00:02:31,820 --> 00:02:33,840
इन दिनों आप Visual Basic का उपयोग नहीं होता,

40
00:02:33,840 --> 00:02:38,920
वहाँ एक जीयूआई के लिए कोई ज़रूरत नहीं है, और आईपी पते में एक तकनीकी तौर पर सही शब्द था.

41
00:02:38,920 --> 00:02:41,730
तो एक नज़र रखना इन के लिए, और एक मेरे पसंदीदा में से एक:

42
00:02:41,730 --> 00:02:45,070
यह एक एक छोटे से अधिक रहस्यमय है, क्योंकि आप एक अलग भाषा जानने की जरूरत है.

43
00:02:45,070 --> 00:02:47,860
एक उद्देश्य सी बुलाया भाषा है, जो सी के एक superset है

44
00:02:47,860 --> 00:02:51,960
जो यह सी प्लस कुछ अतिरिक्त सुविधाओं उन्हें वस्तु उन्मुख प्रोग्रामिंग में, इसका मतलब है.

45
00:02:51,960 --> 00:02:55,070
और इस भाषा है कि एप्पल iOS प्रोग्रामिंग के लिए लोकप्रिय है.

46
00:02:55,070 --> 00:02:58,760
और इसलिए यहाँ एक अलग शो पूरी तरह से एक क्लिप है, से "नंबर"

47
00:02:58,760 --> 00:03:02,450
कि अगर आप वास्तव में सही समय पर अपने TiVo और ठहराव पर बारीकी से देखो,

48
00:03:02,450 --> 00:03:07,700
आप देखेंगे कि वे देख रहे हैं क्या काफी नहीं है क्या वर्णित किया जा रहा है है.

49
00:03:07,700 --> 00:03:11,170
और मुझे एक अलग ऑडियो संबंधक यहाँ कोशिश करो और देखो अगर हम नहीं कर सकते

50
00:03:11,170 --> 00:03:13,780
सिंक में ऑडियो रखने के लिए इस समय.

51
00:03:13,780 --> 00:03:20,530
मैं तुम्हें "नंबर दे."

52
00:03:20,530 --> 00:03:23,240
>> [मैन # 1] यह एक 32-bit IPv4 पता है.

53
00:03:23,240 --> 00:03:38,930
[आदमी 2], आईपी है कि इंटरनेट का है. >> निजी नेटवर्क. यह अनीता निजी नेटवर्क है.

54
00:03:38,930 --> 00:03:43,810
[Malan] ठीक है. यह उद्देश्य सी है, और यह कुछ बच्चे रंग कार्यक्रम के लिए है,

55
00:03:43,810 --> 00:03:51,140
के रूप में आप शायद वहाँ चर के नाम से अनुमान लगा सकते हैं.

56
00:03:51,140 --> 00:03:54,410
ताकि, तो था, "नंबर." और आज तो इस हफ्ते हम परिचय

57
00:03:54,410 --> 00:03:57,740
फोरेंसिक और इसलिए समस्याओं के संदर्भ में की दुनिया का एक छोटा सा.

58
00:03:57,740 --> 00:04:00,590
आज एक संक्षिप्त व्याख्यान हो सकता है क्योंकि यहाँ एक विशेष घटना है

59
00:04:00,590 --> 00:04:05,530
बाद, तो हम एक तिरछी नज़र रखना, करेंगे और दोनों छात्रों और एक जैसे माता पिता आज तंग

60
00:04:05,530 --> 00:04:07,420
चीजें हैं कि क्षितिज पर हैं में से कुछ के साथ.

61
00:04:07,420 --> 00:04:12,240
उनमें से, सोमवार के रूप में, आप कुछ और सहपाठियों होगा.

62
00:04:12,240 --> 00:04:16,050
EDX, हार्वर्ड, और MITS नया ऑनलाइन मुक्त पाठ्य सामग्री के लिए पहल

63
00:04:16,050 --> 00:04:19,120
और अधिक, हार्वर्ड परिसर पर सोमवार को शुरू होता है.

64
00:04:19,120 --> 00:04:21,490
पिछली गणना के रूप में, जो आने सोमवार मतलब है कि आप होगा

65
00:04:21,490 --> 00:04:26,210
86,000 अतिरिक्त सहपाठियों CS50 व्याख्यान के साथ साथ पालन किया जाएगा

66
00:04:26,210 --> 00:04:29,170
और वर्गों और walkthroughs और समस्या सेट.

67
00:04:29,170 --> 00:04:32,350
और इस के भाग के रूप में, आप के उद्घाटन वर्ग के सदस्य बन जाएगा

68
00:04:32,350 --> 00:04:35,090
CS50 और अब CS50x.

69
00:04:35,090 --> 00:04:39,310
>> इस के भाग के रूप में, अब एहसास है कि वहाँ कुछ upsides के रूप में अच्छी तरह से हो जाएगा.

70
00:04:39,310 --> 00:04:43,790
छात्रों की भारी संख्या के लिए इस बात के लिए तैयार हो,

71
00:04:43,790 --> 00:04:47,180
इतना ही कहना है कि भले ही हम 108 TFS और सीए,

72
00:04:47,180 --> 00:04:50,790
नहीं काफी बेहतरीन छात्र / शिक्षक अनुपात एक बार हम 80,000 अन्य छात्रों को मारा.

73
00:04:50,790 --> 00:04:52,850
तो हम इतने सारे समस्या ग्रेडिंग नहीं जा रहे हैं मैन्युअल सेट.

74
00:04:52,850 --> 00:04:55,920
तो समस्या सेट में इस सप्ताह शुरू CS50 जांच हो जाएगा,

75
00:04:55,920 --> 00:04:58,450
जो करने के लिए एक कमांड लाइन उपयोगिता उपकरण के भीतर जा रहा है

76
00:04:58,450 --> 00:05:01,200
है कि आप एक बार आप इसे बाद में इस सप्ताह के अंत में अद्यतन करने के लिए मिल जाएगा,

77
00:05:01,200 --> 00:05:03,200
और आप के लिए एक कमांड को चलाने के लिए सक्षम हो जाएगा, 50 की जांच,

78
00:05:03,200 --> 00:05:06,500
, अपने खुद के pset पर और आप के रूप में है कि क्या अपने कार्यक्रम कुछ प्रतिक्रिया मिल जाएगा

79
00:05:06,500 --> 00:05:11,160
प्रदान की है कि हम विभिन्न डिजाइन विनिर्देशों के अनुसार सही है या गलत.

80
00:05:11,160 --> 00:05:13,580
तो उस पर अधिक से समस्या और सेट विनिर्देश

81
00:05:13,580 --> 00:05:17,240
CS50x सहपाठियों के रूप में अच्छी तरह से उपयोग किया जाएगा.

82
00:05:17,240 --> 00:05:19,230
>> तो समस्या 4 सेट फोरेंसिक सब के बारे में है.

83
00:05:19,230 --> 00:05:21,940
और इस टुकड़े के कुछ सामान वास्तविक जीवन से प्रेरित था,

84
00:05:21,940 --> 00:05:24,620
जिससे जब मैं स्कूल में था स्नातक, मैं के साथ थोड़ी देर के लिए interned

85
00:05:24,620 --> 00:05:28,650
मिडिलसेक्स काउंटी जिला अटार्नी कार्यालय फोरेंसिक काम कर रही

86
00:05:28,650 --> 00:05:31,650
उनके नेतृत्व फोरेंसिक अन्वेषक के साथ, और यह क्या की राशि

87
00:05:31,650 --> 00:05:35,260
है, मुझे लगता है कि मैं कुछ सप्ताह के अतीत का उल्लेख किया, मास राज्य पुलिस या दूसरों

88
00:05:35,260 --> 00:05:39,000
में आ जाएगा, वे बंद हार्ड ड्राइव और सीडी और फ्लॉपी डिस्क की तरह बातें छोड़ जाएगा

89
00:05:39,000 --> 00:05:42,340
और इस तरह, और तो फोरेंसिक कार्यालय के लक्ष्य पता लगाने के लिए किया गया था कि क्या

90
00:05:42,340 --> 00:05:44,600
वहां गया था या किसी तरह के सबूत नहीं था.

91
00:05:44,600 --> 00:05:48,010
यह विशेष अन्वेषण यूनिट था, तो यह सफेद कॉलर अपराध था,

92
00:05:48,010 --> 00:05:52,350
यह अपराधों के अधिक परेशान प्रकार था,

93
00:05:52,350 --> 00:05:55,990
डिजिटल मीडिया के किसी तरह का कुछ भी शामिल है, पता चला है कि नहीं है कि कई लोग

94
00:05:55,990 --> 00:05:59,370
एक कह ईमेल लिखने "मैंने ऐसा किया था."

95
00:05:59,370 --> 00:06:03,290
इसलिए अक्सर इन फोरेंसिक खोजों कि सभी ज्यादा फल बारी नहीं किया था,

96
00:06:03,290 --> 00:06:05,850
लेकिन कभी कभी लोगों को ऐसी ईमेल लिखना होगा.

97
00:06:05,850 --> 00:06:08,490
तो कभी कभी प्रयासों को पुरस्कृत किया गया.

98
00:06:08,490 --> 00:06:14,420
>> लेकिन इस फोरेंसिक pset तक का नेतृत्व करने के लिए, हम 4 ग्राफिक्स के एक बिट pset में शुरू हो जाएगा.

99
00:06:14,420 --> 00:06:18,260
तो आप शायद दी, JPEGs GIFs, और इन दिनों की तरह के लिए इन बातों को ले,

100
00:06:18,260 --> 00:06:21,640
लेकिन अगर तुम सच में लगता है कि इसके बारे में, एक छवि, ज्यादा रोब चेहरे की तरह,

101
00:06:21,640 --> 00:06:24,430
डॉट्स की एक अनुक्रम, या पिक्सल के रूप में modeled किया जा सकता है.

102
00:06:24,430 --> 00:06:26,680
अब, रोब चेहरे के मामले में, वहाँ रंग के सभी प्रकार है,

103
00:06:26,680 --> 00:06:29,940
और हम व्यक्तिगत डॉट्स, otherwide पिक्सेल के रूप में जाना जाता है देखने के लिए शुरू कर दिया है,

104
00:06:29,940 --> 00:06:31,610
एक बार हम ज़ूम इन करने के लिए शुरू कर दिया

105
00:06:31,610 --> 00:06:35,590
लेकिन अगर हम दुनिया के एक बिट सरल, और बस कहना है कि यहाँ इस रोब

106
00:06:35,590 --> 00:06:40,560
काले और सफेद, अच्छी तरह से, का प्रतिनिधित्व करने के काले और सफेद में हम सिर्फ द्विआधारी का उपयोग कर सकते हैं.

107
00:06:40,560 --> 00:06:44,960
और अगर हम द्विआधारी का उपयोग करने के लिए जा रहे हैं, 1 या 0, हम इस एक ही छवि को व्यक्त कर सकते हैं

108
00:06:44,960 --> 00:06:51,970
रोब बिट्स की इस पद्धति के साथ मुस्कुराते चेहरे के: 11000011 का प्रतिनिधित्व करता है

109
00:06:51,970 --> 00:06:55,160
सफेद, सफेद, काले, काले, काले, काले, सफेद सफेद.

110
00:06:55,160 --> 00:06:59,290
और इसलिए यह एक बड़ी छलांग है, तो नहीं है, रंगीन फोटो के बारे में बात शुरू की.

111
00:06:59,290 --> 00:07:01,920
चीज़ें है कि आप फेसबुक पर देख सकते हैं या एक डिजिटल कैमरा के साथ ले जाएगा,

112
00:07:01,920 --> 00:07:04,730
लेकिन, निश्चित रूप से, जब रंगों की बात आती है, तो आप अधिक बिट्स की जरूरत है.

113
00:07:04,730 --> 00:07:08,470
और तस्वीरों की दुनिया में काफी आम 1-बिट रंग का उपयोग नहीं है,

114
00:07:08,470 --> 00:07:12,730
के रूप में यह पता चलता है, लेकिन 24 बिट रंग, जहाँ आप वास्तव में रंगों के लाखों मिलता है.

115
00:07:12,730 --> 00:07:15,430
इसलिए मामले में के रूप में जब हम पर रोब आंख में तेजी से बढ़ी है,

116
00:07:15,430 --> 00:07:19,270
कि अलग रंगीन संभावनाओं के लाखों के किसी भी नंबर था.

117
00:07:19,270 --> 00:07:22,260
>> तो हम समस्या 4 सेट के रूप में के रूप में अच्छी तरह से walkthrough में इस परिचय देंगे,

118
00:07:22,260 --> 00:07:27,050
जो आज सामान्य 2:30 के बजाय 3:30 पर शुक्रवार को यहाँ व्याख्यान की वजह से होगा.

119
00:07:27,050 --> 00:07:29,930
लेकिन वीडियो ऑनलाइन हो हमेशा की तरह, कल.

120
00:07:29,930 --> 00:07:31,880
हम भी आप अन्य फ़ाइल स्वरूप मिलवा देंगे.

121
00:07:31,880 --> 00:07:34,150
तो यह जानबूझकर पहले डराना देखने का मतलब है,

122
00:07:34,150 --> 00:07:38,980
लेकिन यह सिर्फ एक सी struct के लिए कुछ दस्तावेज है.

123
00:07:38,980 --> 00:07:42,280
यह पता चला है कि माइक्रोसॉफ्ट, साल पहले, इस प्रारूप को लोकप्रिय बनाने में मदद की है,

124
00:07:42,280 --> 00:07:46,630
बिटमैप फ़ाइल स्वरूप, बीएमपी, और यह एक सुपर आसान था, कहा जाता है,

125
00:07:46,630 --> 00:07:50,390
रंगीन ग्राफिकल फ़ाइल स्वरूप है कि कुछ समय के लिए इस्तेमाल किया गया था

126
00:07:50,390 --> 00:07:53,640
और कभी कभी भी डेस्कटॉप पर वॉलपेपर के लिए.

127
00:07:53,640 --> 00:07:57,410
यदि आप Windows XP और रोलिंग पहाड़ियों और नीले आकाश के लिए वापस लगता है,

128
00:07:57,410 --> 00:08:00,660
कि आम तौर पर एक बीएमपी, या बिटमैप छवि, और बिटमैप्स

129
00:08:00,660 --> 00:08:03,340
हमारे लिए मजाक कर रहे हैं क्योंकि वे थोड़ा और अधिक जटिलता है.

130
00:08:03,340 --> 00:08:05,640
यह काफी के रूप में 0 और 1 के इस ग्रिड के रूप में सरल नहीं है;

131
00:08:05,640 --> 00:08:10,680
इसके बजाय, आप एक फ़ाइल के शुरू में एक शीर्षक की तरह बातें है.

132
00:08:10,680 --> 00:08:15,520
तो दूसरे शब्दों में, एक bmp फ़ाइल के अंदर 0 और 1 की एक पूरी गुच्छा है,

133
00:08:15,520 --> 00:08:18,070
लेकिन वहाँ कुछ अतिरिक्त 0 और 1 वहाँ में है.

134
00:08:18,070 --> 00:08:21,450
और यह पता चला है कि हम क्या शायद के लिए साल के लिए दी ले लिया है,

135
00:08:21,450 --> 00:08:27,040
डॉक्टर या. xls या एमपी 3 या mp4 तरह फ़ाइल स्वरूपों,

136
00:08:27,040 --> 00:08:29,910
फ़ाइल स्वरूपों जो कुछ भी है कि आप से परिचित हो.

137
00:08:29,910 --> 00:08:31,900
खैर, यह भी एक फ़ाइल स्वरूप क्या मतलब है?

138
00:08:31,900 --> 00:08:35,740
क्योंकि दिन के अंत में, इन फ़ाइलों के सभी का उपयोग हम बस 0 और 1

139
00:08:35,740 --> 00:08:39,950
और शायद उन 0 और 1 क, ख, ग, ASCII या तरह के माध्यम से प्रतिनिधित्व करते हैं,

140
00:08:39,950 --> 00:08:42,030
लेकिन दिन के अंत के माध्यम से, यह सिर्फ 0 और 1.

141
00:08:42,030 --> 00:08:45,300
>> तो मनुष्य के बस कभी - कभी एक नया फ़ाइल स्वरूप का आविष्कार करने का फैसला

142
00:08:45,300 --> 00:08:49,420
जहां वे प्रमाण के अनुसार करना बिट्स के पैटर्न वास्तव में क्या मतलब होगा.

143
00:08:49,420 --> 00:08:52,790
और इस मामले में, लोग जो बिटमैप फ़ाइल प्रारूप तैयार

144
00:08:52,790 --> 00:08:58,260
ने कहा कि एक बिटमैप फ़ाइल में बहुत पहली बाइट के रूप में 0 ऑफसेट द्वारा चिह्नित, वहाँ,

145
00:08:58,260 --> 00:09:02,320
वहाँ कुछ cryptically नाम चर बुलाया bfType होने जा रहा है,

146
00:09:02,320 --> 00:09:06,510
जो सिर्फ बिटमैप फ़ाइल प्रकार के लिए खड़ा है, इस बिटमैप फ़ाइल के प्रकार क्या है.

147
00:09:06,510 --> 00:09:10,780
आप अनुमान शायद दूसरी पंक्ति है कि 2 ऑफसेट, बाइट संख्या 2 से कर सकते हैं,

148
00:09:10,780 --> 00:09:15,980
0 और 1 है कि क्या प्रतिनिधित्व करता है की एक पैटर्न है?

149
00:09:15,980 --> 00:09:18,320
कुछ के आकार, और यह वहाँ से चला जाता है.

150
00:09:18,320 --> 00:09:20,660
तो समस्या 4 सेट में, आप इन बातों में से कुछ के माध्यम से चला गया हो जाएगा.

151
00:09:20,660 --> 00:09:24,480
>> हम उन सभी के बारे में देखभाल, लेकिन नोटिस जाएगा यह दिलचस्प प्राप्त करने के लिए शुरू होता है

152
00:09:24,480 --> 00:09:30,780
लाइन या 54 बाइट, rgbtBlue, हरे और लाल के आसपास.

153
00:09:30,780 --> 00:09:35,280
यदि आप कभी भी परिचित करा आरजीबी, लाल, हरे नीले सुना है, यह है कि करने के लिए एक संदर्भ है.

154
00:09:35,280 --> 00:09:37,840
क्योंकि यह पता चला है आप इंद्रधनुष के सभी रंगों पेंट कर सकते हैं

155
00:09:37,840 --> 00:09:41,580
लाल और नीले और हरे रंग के कुछ संयोजन के साथ.

156
00:09:41,580 --> 00:09:46,560
और, वास्तव में, कमरे में माता - पिता जल्द से जल्द प्रोजेक्टर के कुछ याद हो सकता है.

157
00:09:46,560 --> 00:09:49,360
इन दिनों, तुम सिर्फ 1 उज्ज्वल प्रकाश एक लेंस के बाहर आने को देखने.

158
00:09:49,360 --> 00:09:52,870
लेकिन वापस दिन में, आप लाल लेंस, नीले लेंस, और हरे रंग लेंस था

159
00:09:52,870 --> 00:09:56,620
और साथ में वे स्क्रीन के उद्देश्य से और एक रंगीन चित्र का गठन किया है.

160
00:09:56,620 --> 00:09:59,590
और अक्सर मध्य विद्यालयों और उच्च विद्यालयों के उन लेंस

161
00:09:59,590 --> 00:10:02,680
तिरछेपन से कभी तो थोड़ा, तो आप डबल या ट्रिपल छवियों को देखने की तरह थे,

162
00:10:02,680 --> 00:10:07,500
लेकिन यह है कि विचार था. आप लाल और हरे और नीले प्रकाश एक चित्र चित्र था.

163
00:10:07,500 --> 00:10:09,570
और कि एक ही सिद्धांत कंप्यूटर में प्रयोग किया जाता है.

164
00:10:09,570 --> 00:10:12,000
>> चुनौतियों के बीच है, तो, आप के लिए तो समस्या में 4 सेट

165
00:10:12,000 --> 00:10:16,080
कुछ चीजें होने जा रहा है, एक के लिए वास्तव में एक छवि का आकार बदलने के लिए है.

166
00:10:16,080 --> 00:10:18,050
0 और 1 के एक पैटर्न में ले,

167
00:10:18,050 --> 00:10:22,840
पता लगाने की जो 0 और 1 हिस्सा इस तरह एक संरचना में क्या प्रतिनिधित्व करते हैं,

168
00:10:22,840 --> 00:10:26,800
और फिर बाहर आंकड़ा कैसे पिक्सल को दोहराने के लिए: लाल, नीले, हरे

169
00:10:26,800 --> 00:10:32,460
इतना है कि अंदर जब एक तस्वीर इस तरह शुरू में लग रहा है, कि इस तरह के बाद बजाय लग सकता है.

170
00:10:32,460 --> 00:10:35,590
अन्य चुनौतियों के बीच भी है, हो सकता है कि आप हाथ हो जाएगा जा रहा है

171
00:10:35,590 --> 00:10:38,900
एक डिजिटल कैमरे से एक वास्तविक फ़ाइल की फोरेंसिक छवि

172
00:10:38,900 --> 00:10:42,410
और उस कैमरे पर, एक बार एक समय पर, तस्वीरों की एक पूरी गुच्छा थे.

173
00:10:42,410 --> 00:10:47,030
समस्या है, हम गलती से मिट गया था या छवि किसी तरह भ्रष्ट.

174
00:10:47,030 --> 00:10:51,040
बुरी बातें डिजिटल कैमरों के साथ होता है, और इसलिए हम जल्दी से 0 और 1 के सभी नकल

175
00:10:51,040 --> 00:10:55,410
आप के लिए है कि कार्ड के, 1 बड़ा फ़ाइल में उन सब को बचाया, और फिर हम उन्हें आप के लिए हाथ होगा

176
00:10:55,410 --> 00:11:00,000
समस्या में 4 इतना तय है कि तुम सी में एक कार्यक्रम के साथ ठीक करने के लिए लिख सकते हैं

177
00:11:00,000 --> 00:11:02,660
उन JPEGs, आदर्श.

178
00:11:02,660 --> 00:11:06,280
और यह पता चला कि JPEGs, भले ही वे एक जटिल फ़ाइल स्वरूप के कुछ कर रहे हैं,

179
00:11:06,280 --> 00:11:09,580
वे इस मुस्कुरा यहाँ चेहरे से कहीं अधिक जटिल हो.

180
00:11:09,580 --> 00:11:14,320
यह पता चला है कि हर JPEG 0 और 1 के एक ही पैटर्न के साथ शुरू होता है.

181
00:11:14,320 --> 00:11:18,820
तो एक समय या पाश या इसी तरह के लिए एक पाश का उपयोग करते हुए,

182
00:11:18,820 --> 00:11:22,350
आप सभी 0 और इस फोरेंसिक छवि में 1 से अधिक पुनरावृति कर सकते हैं

183
00:11:22,350 --> 00:11:26,670
और हर बार जब आप विशेष पैटर्न है कि समस्या सेट विनिर्देश में परिभाषित है,

184
00:11:26,670 --> 00:11:29,770
तुम्हें पता है, 'ओह, यहाँ है, बहुत अधिक संभावना के साथ मान सकते हैं,

185
00:11:29,770 --> 00:11:33,520
एक JPEG की शुरुआत, 'जैसे ही आप पाते हैं एक ही पैटर्न

186
00:11:33,520 --> 00:11:36,050
बाइट्स या किलोबाइट्स या मेगाबाइट्स की कुछ बाद में यह संख्या,

187
00:11:36,050 --> 00:11:40,550
आप मान ऊह, 'कर सकते हैं! यहाँ एक दूसरे JPEG, फोटो मैं पहले एक के बाद लिया है.

188
00:11:40,550 --> 00:11:44,720
मुझे कि पहली फ़ाइल पढ़ना बंद करो, यह एक नया लेखन शुरू करते हैं. '

189
00:11:44,720 --> 00:11:49,980
और pset 4 के लिए अपने कार्यक्रम के उत्पादन के रूप में कई के रूप में 50 JPEGs होने जा रहा है.

190
00:11:49,980 --> 00:11:52,400
और अगर यह 50 JPEGs नहीं है, आप एक पाश के एक सा है.

191
00:11:52,400 --> 00:11:55,580
यदि आप JPEGs की एक अनंत संख्या है, तो आप एक अनंत लूप है.

192
00:11:55,580 --> 00:11:58,280
तो वह भी एक बहुत आम मामला होगा.

193
00:11:58,280 --> 00:12:00,280
यही कारण है कि क्या क्षितिज पर है.

194
00:12:00,280 --> 00:12:03,740
>> 0 हमारे पीछे कीजिए. अपने ईमेल के अनुसार, एहसास, कि सदा ही वहाँ लोगों की

195
00:12:03,740 --> 00:12:06,820
दोनों तटस्थ के खुश तरह है,, और 0 समय प्रश्नोत्तरी चारों ओर दुख की बात है, जो कर रहे हैं.

196
00:12:06,820 --> 00:12:10,160
और कृपया मुझे बाहर तक पहुँचने के लिए, सिर TFS, Zamyla, अपने खुद के TF

197
00:12:10,160 --> 00:12:14,120
या सीए के एक है कि आप जानते हैं कि अगर आप चर्चा करना चाहते हैं कैसे चीजें गया.

198
00:12:14,120 --> 00:12:16,460
>> तो माता पिता को प्रभावित करने के लिए कमरे में

199
00:12:16,460 --> 00:12:23,990
CS50 पुस्तकालय क्या है? अच्छा काम किया.

200
00:12:23,990 --> 00:12:32,280
CS50 पुस्तकालय क्या है? हाँ? [छात्र जवाब, unintelligible]

201
00:12:32,280 --> 00:12:35,730
>> ठीक है, अच्छा है. तो यह कोड का एक prewritten सेट है कि हम, स्टाफ, लिखा है,

202
00:12:35,730 --> 00:12:38,460
हम आप के लिए प्रदान करने के लिए कुछ सामान्य functionalities प्रदान.

203
00:12:38,460 --> 00:12:42,290
सामग्री मुझे एक स्ट्रिंग प्राप्त करना, मुझे एक int, सभी कार्य करता है कि यहाँ सूचीबद्ध हैं.

204
00:12:42,290 --> 00:12:45,260
अब शुरू, हम वास्तव में इन प्रशिक्षण के पहियों से दूर ले शुरू करते हैं.

205
00:12:45,260 --> 00:12:48,230
तो हम करने के लिए आप से दूर एक "स्ट्रिंग" लेने के लिए शुरू करने के लिए जा रहे हैं,

206
00:12:48,230 --> 00:12:52,790
जो, याद है, क्या वास्तविक डेटा प्रकार के लिए सिर्फ एक पर्याय था? चार *.

207
00:12:52,790 --> 00:12:57,020
तो माता पिता के लिए, कि शायद था - यह अच्छी बात है, तो चार * हम देखना शुरू करेंगे

208
00:12:57,020 --> 00:13:00,810
स्क्रीन पर सभी अधिक के रूप में हम हमारे शब्दावली से "स्ट्रिंग" को हटाने,

209
00:13:00,810 --> 00:13:02,760
कम से कम जब यह वास्तव में कोड लिखने के लिए आता है.

210
00:13:02,760 --> 00:13:06,240
इसी तरह, हम जितना इन कार्यों में से कुछ का उपयोग बंद कर देंगे,

211
00:13:06,240 --> 00:13:08,390
क्योंकि हमारे कार्यक्रमों को और अधिक परिष्कृत पाने के लिए जा रहे हैं

212
00:13:08,390 --> 00:13:11,370
के बजाय सिर्फ प्रोग्राम लिखने कि शीघ्र पलक के साथ वहाँ बैठो,

213
00:13:11,370 --> 00:13:13,580
उपयोगकर्ता के लिए प्रतीक्षा करने के लिए अंदर कुछ लिखें

214
00:13:13,580 --> 00:13:15,220
आप कहीं और से अपनी जानकारी मिल जाएगा.

215
00:13:15,220 --> 00:13:18,720
उदाहरण के लिए, आप उन्हें स्थानीय हार्ड ड्राइव पर बिट्स की एक श्रृंखला से मिल जाएगा.

216
00:13:18,720 --> 00:13:23,340
आप के बजाय उन्हें भविष्य में मिलेगा एक नेटवर्क कनेक्शन से, कुछ वेबसाइट कहीं.

217
00:13:23,340 --> 00:13:27,460
तो वापस पहली बार के लिए इस परत छील चलो, और CS50 उपकरण खींच

218
00:13:27,460 --> 00:13:32,300
और इस CS50.h नामक फाइल है, जो तुम हफ्तों के लिए सहित तेज किया गया है.

219
00:13:32,300 --> 00:13:34,380
>> लेकिन वास्तव में देखने के लिए क्या इस के अंदर है.

220
00:13:34,380 --> 00:13:38,250
तो नीले रंग में फाइल के ऊपर टिप्पणी की एक पूरी गुच्छा है,

221
00:13:38,250 --> 00:13:41,340
वारंटी जानकारी और लाइसेंस. यह एक आम प्रतिमान की तरह है

222
00:13:41,340 --> 00:13:44,600
सॉफ्टवेयर में है, क्योंकि सॉफ्टवेयर का एक बहुत इन दिनों है, "क्या कहा जाता है" खुला स्रोत

223
00:13:44,600 --> 00:13:46,940
जिसका अर्थ है कि कोई कोड लिखा है

224
00:13:46,940 --> 00:13:50,060
और यह आज़ादी से उपलब्ध कराया, नहीं बस चलाने के लिए उपयोग करने के लिए,

225
00:13:50,060 --> 00:13:53,660
लेकिन वास्तव में पढ़ सकते हैं और बदल और अपने खुद के काम में एकीकृत.

226
00:13:53,660 --> 00:13:55,790
तो है कि क्या आप का उपयोग किया गया है, ओपन सोर्स सॉफ्टवेयर,

227
00:13:55,790 --> 00:13:58,030
यद्यपि एक बहुत छोटे रूप में.

228
00:13:58,030 --> 00:14:01,860
अगर मैं टिप्पणी पिछले नीचे स्क्रॉल, हालांकि, हम कुछ अधिक परिचित बातें देखना शुरू करेंगे.

229
00:14:01,860 --> 00:14:08,090
तो यहाँ शीर्ष पर नोटिस, कि CS50.h फ़ाइल हेडर फाइल की एक पूरी गुच्छा भी शामिल है.

230
00:14:08,090 --> 00:14:11,160
अब, इनमें से अधिकांश हम पहले नहीं देखा है, लेकिन एक है

231
00:14:11,160 --> 00:14:15,640
परिचित, इनमें से जो हम संक्षेप में यद्यपि देखा है, इस प्रकार अब तक?

232
00:14:15,640 --> 00:14:18,720
हाँ, मानक पुस्तकालयों. Stdlib.h malloc है,

233
00:14:18,720 --> 00:14:21,590
तो एक बार हम गतिशील स्मृति आवंटन के बारे में बात करना शुरू कर दिया,

234
00:14:21,590 --> 00:14:24,960
जो हम वापस करने के लिए अगले सप्ताह के रूप में अच्छी तरह से आ जाएगा, हम उस फ़ाइल सहित शुरू कर दिया.

235
00:14:24,960 --> 00:14:29,660
यह पता चला है कि bool और सच्चे और झूठे सी में वास्तव में नहीं मौजूद नहीं है, से प्रति,

236
00:14:29,660 --> 00:14:32,460
जब तक आप इस फाइल को यहाँ शामिल हैं.

237
00:14:32,460 --> 00:14:35,770
तो हम सप्ताह के लिए किया है, मानक bool.h सहित

238
00:14:35,770 --> 00:14:39,020
इतना है कि आप एक bool, सही है या गलत. की धारणा का उपयोग कर सकते हैं

239
00:14:39,020 --> 00:14:41,830
इस के बिना, आप यह नकली की तरह है और एक int का उपयोग करना चाहते हैं

240
00:14:41,830 --> 00:14:45,920
और बस मनमाने ढंग से लगता है कि 0 झूठी है और 1 सच है.

241
00:14:45,920 --> 00:14:49,980
>> अब, अगर हम आगे नीचे स्क्रॉल, यहाँ एक स्ट्रिंग की हमारी परिभाषा है.

242
00:14:49,980 --> 00:14:54,820
यह पता चला है, जैसा कि हम पहले कहा है, कि जहां यह * वास्तव में कोई फर्क नहीं पड़ता.

243
00:14:54,820 --> 00:14:56,750
तुम भी अंतरिक्ष के आसपास हो सकता है.

244
00:14:56,750 --> 00:15:01,550
हम, इस सेमेस्टर, इस के रूप में किया गया है इसे बढ़ावा देने के लिए स्पष्ट कर दूं कि * प्रकार के साथ क्या करना है.

245
00:15:01,550 --> 00:15:05,370
लेकिन एहसास है, बस के रूप में आम है, अगर छोटे से अधिक एक आम नहीं है, यह वहाँ रखा है

246
00:15:05,370 --> 00:15:07,480
लेकिन कार्यात्मक यह एक ही बात है.

247
00:15:07,480 --> 00:15:11,070
लेकिन अब, अगर हम नीचे आगे पढ़ने के लिए, चलो कहते हैं, पर एक नज़र GetInt ले,

248
00:15:11,070 --> 00:15:15,350
क्योंकि हम उस का उपयोग किया है, शायद कुछ और इस सेमेस्टर से पहले.

249
00:15:15,350 --> 00:15:19,620
और यहाँ GetInt है. यह क्या है?

250
00:15:19,620 --> 00:15:24,650
इस प्रोटोटाइप है. तो अक्सर, हम हमारे में से सबसे ऊपर है पर प्रोटोटाइप डाल दिया है ग फ़ाइलों.

251
00:15:24,650 --> 00:15:28,190
लेकिन आप भी हेडर फाइलें, ज. फ़ाइलों में प्रोटोटाइप डाल सकते हैं,

252
00:15:28,190 --> 00:15:32,110
यह यहाँ एक तरह, ताकि जब आप कुछ कार्यों को लिखने

253
00:15:32,110 --> 00:15:36,790
कि आप अन्य लोगों के लिए उपयोग करने में सक्षम होने के लिए करना चाहते हैं, जो वास्तव में CS50 पुस्तकालय के साथ मामला है,

254
00:15:36,790 --> 00:15:40,900
तुम नहीं केवल CS50.c की तरह कुछ में अपने कार्यों को लागू करने के लिए,

255
00:15:40,900 --> 00:15:46,720
आप भी उस फ़ाइल के शीर्ष पर नहीं प्रोटोटाइप डाल दिया, लेकिन एक हैडर फ़ाइल के शीर्ष पर,

256
00:15:46,720 --> 00:15:50,810
तो उस हैडर फ़ाइल मित्रों और सहकर्मियों क्या शामिल है,

257
00:15:50,810 --> 00:15:52,800
तेज के साथ अपने खुद के कोड में शामिल हैं.

258
00:15:52,800 --> 00:15:55,440
यह सब समय तो आप इन प्रोटोटाइप के सभी सहित किया गया है

259
00:15:55,440 --> 00:15:59,870
प्रभावी ढंग से अपनी फ़ाइल के शीर्ष पर है, लेकिन इस तेज के रास्ते से तंत्र में शामिल हैं

260
00:15:59,870 --> 00:16:03,320
कि अनिवार्य रूप से प्रतियां और चिपकाता अपने ही में इस फ़ाइल.

261
00:16:03,320 --> 00:16:06,400
अब, यहाँ कुछ काफी विस्तृत दस्तावेज है.

262
00:16:06,400 --> 00:16:08,880
>> हम बहुत ज्यादा के लिए दी गई है कि GetInt एक int हो जाता है ले लिया है,

263
00:16:08,880 --> 00:16:10,740
लेकिन यह वहाँ बाहर कुछ कोने मामलों बदल जाता है, है ना?

264
00:16:10,740 --> 00:16:14,320
क्या एक संख्या है कि जिस तरह से बहुत बड़ा है में उपयोगकर्ता प्रकार अगर?

265
00:16:14,320 --> 00:16:17,350
Quintillion एक, कि सिर्फ एक int के अंदर फिट नहीं कर सकते?

266
00:16:17,350 --> 00:16:21,180
अपेक्षित व्यवहार क्या है? खैर, आदर्श, यह उम्मीद के मुताबिक है.

267
00:16:21,180 --> 00:16:23,460
तो इस मामले में, यदि आप वास्तव में ठीक प्रिंट पढ़ा,

268
00:16:23,460 --> 00:16:27,850
आपको लगता है कि अगर लाइन को पढ़ा नहीं जा सकता है, यह रिटर्न INT_MAX देखेंगे.

269
00:16:27,850 --> 00:16:30,800
हम इस बारे में कभी बात नहीं की है, लेकिन अपने पूंजीकरण के आधार पर,

270
00:16:30,800 --> 00:16:33,030
यह क्या है, शायद?

271
00:16:33,030 --> 00:16:36,610
यह एक निरंतर है, तो यह कुछ विशेष निरंतर है कि शायद घोषित

272
00:16:36,610 --> 00:16:39,460
उन हेडर फाइल है कि फ़ाइल में उच्च ऊपर में,

273
00:16:39,460 --> 00:16:43,400
और INT_MAX शायद मोटे तौर पर, 2 अरब की तरह कुछ है.

274
00:16:43,400 --> 00:16:48,160
जा रहा है कि क्योंकि हम किसी भी तरह कि कुछ दर्शाता है की जरूरत विचार गलत हो गया था,

275
00:16:48,160 --> 00:16:51,090
हम, हाँ, हमारे निपटान पर चार अरब संख्या है,

276
00:16:51,090 --> 00:16:53,980
अप करने के लिए 2 अरब पर नकारात्मक 2 अरब, दे या ले.

277
00:16:53,980 --> 00:16:58,030
खैर, क्या प्रोग्रामिंग में आम है तुम सिर्फ एक उन लोगों की संख्या की चोरी.

278
00:16:58,030 --> 00:17:02,250
0 हो सकता है, शायद 2 अरब, शायद नकारात्मक दो अरब.

279
00:17:02,250 --> 00:17:06,720
तो तुम एक अपने संभव मूल्यों के खर्च इतनी है कि आप दुनिया के लिए प्रतिबद्ध कर सकते हैं

280
00:17:06,720 --> 00:17:10,089
कि अगर कुछ गलत हो जाता है, तो मैं इस सुपर बड़ा मूल्य वापस आ जाएगी.

281
00:17:10,089 --> 00:17:13,329
लेकिन आप की तरह गुप्त उपयोगकर्ता कुछ टाइप नहीं करना चाहता "2, 3, 4 ... है"

282
00:17:13,329 --> 00:17:17,079
वास्तव में बड़ी संख्या है, जहां आप एक निरंतर बजाय सामान्य.

283
00:17:17,079 --> 00:17:19,380
तो सच में, अगर आप गुदा जा रहे थे पिछले कुछ हफ्तों,

284
00:17:19,380 --> 00:17:23,800
कभी भी आप GetInt फोन है, तो आप एक हालत अगर के साथ किया गया है की जाँच करना चाहिए.

285
00:17:23,800 --> 00:17:27,109
INT_MAX में उपयोगकर्ता प्रकार किया था, या अधिक विशेष,

286
00:17:27,109 --> 00:17:29,900
GetInt वापसी INT_MAX किया? क्योंकि अगर ऐसा किया था,

287
00:17:29,900 --> 00:17:35,140
इसका मतलब है कि वास्तव में वे यह नहीं लिख था, इस मामले में कुछ गलत हो गया था.

288
00:17:35,140 --> 00:17:38,970
तो यह है कि क्या आम तौर पर एक "प्रहरी" मूल्य है, जो सिर्फ विशेष मतलब के रूप में जाना जाता है.

289
00:17:38,970 --> 00:17:41,020
>> ठीक है, चलो अब ग फ़ाइलों में बारी.

290
00:17:41,020 --> 00:17:44,500
सी फ़ाइल उपकरण में कुछ समय के लिए ही अस्तित्व में है,

291
00:17:44,500 --> 00:17:47,540
और, वास्तव में, यह उपकरण आप के लिए precompiled

292
00:17:47,540 --> 00:17:49,720
उस बात में हम "ऑब्जेक्ट कोड," कहा जाता है

293
00:17:49,720 --> 00:17:52,940
लेकिन यह सिर्फ आप को कोई फर्क नहीं पड़ता, जहां यह है क्योंकि इस प्रणाली जानता है,

294
00:17:52,940 --> 00:17:54,780
इस मामले में, जहां यह है, उपकरण.

295
00:17:54,780 --> 00:18:00,620
लेकिन अब नीचे स्क्रॉल लिए GetInt, और देखने के लिए कैसे GetInt यह सब समय काम कर रहा है.

296
00:18:00,620 --> 00:18:02,380
यहाँ तो हम पहले से इसी तरह की टिप्पणी है.

297
00:18:02,380 --> 00:18:04,930
मुझे सिर्फ कोड हिस्से पर में ज़ूम,

298
00:18:04,930 --> 00:18:07,410
और हम GetInt के लिए है जो निम्नलिखित है.

299
00:18:07,410 --> 00:18:12,770
यह कोई इनपुट लेता है और यह एक int देता है, जबकि () सच है, तो हम एक जानबूझकर अनंत लूप

300
00:18:12,770 --> 00:18:16,560
लेकिन, शायद, हम इस से बाहर किसी भी तरह तोड़ने, या इस के भीतर से लौटने.

301
00:18:16,560 --> 00:18:19,890
तो चलो यह कैसे काम करता है देखने के लिए. खैर, हम GetString उपयोग लग रहे हो

302
00:18:19,890 --> 00:18:22,550
पाश, 166 के अंदर इस पहली पंक्ति में.

303
00:18:22,550 --> 00:18:25,320
यह अब अच्छा अभ्यास है क्योंकि किस परिस्थिति में

304
00:18:25,320 --> 00:18:30,820
GetString इस विशेष कीवर्ड रिक्त, वापस आ सकता है?

305
00:18:30,820 --> 00:18:38,460
अगर कुछ गलत हो जाता है. क्या गलत जब आप GetString की तरह कुछ कह सकते हैं?

306
00:18:38,460 --> 00:18:42,550
हाँ? [छात्र जवाब, unintelligible] >> हाँ. तो शायद malloc विफल रहता है.

307
00:18:42,550 --> 00:18:45,310
हुड GetString नीचे कहीं malloc बुला रहा है,

308
00:18:45,310 --> 00:18:48,210
जो स्मृति आबंटित करता है, जो कंप्यूटर की दुकान की मदद से

309
00:18:48,210 --> 00:18:50,950
अक्षरों के सभी कि कुंजीपटल में उपयोगकर्ता प्रकार.

310
00:18:50,950 --> 00:18:53,270
लगता है और उपयोगकर्ता खाली समय का एक पूरी बहुत कुछ था

311
00:18:53,270 --> 00:18:56,470
और अधिक दो अरब वर्ण से, उदाहरण के लिए, टाइप.

312
00:18:56,470 --> 00:18:59,600
कंप्यूटर से अधिक वर्ण भी रैम है.

313
00:18:59,600 --> 00:19:02,350
खैर, GetString कि आप को दर्शाता करने में सक्षम हो गया है,

314
00:19:02,350 --> 00:19:05,650
यहां तक ​​कि अगर यह एक सुपर, सुपर असामान्य कोने मामले है.

315
00:19:05,650 --> 00:19:08,490
यह किसी भी तरह से इस संभाल करने में सक्षम हो गया है, और इतना GetString

316
00:19:08,490 --> 00:19:11,850
अगर हम वापस जाओ और अपनी दस्तावेज़ीकरण पढ़ें, वास्तव में करता है, नल लौटने के लिए.

317
00:19:11,850 --> 00:19:16,150
अब अगर GetString रिक्त लौटने से विफल रहता है, GetInt असफल हो रहा है

318
00:19:16,150 --> 00:19:19,370
INT_MAX एक प्रहरी के रूप में लौटने से.

319
00:19:19,370 --> 00:19:22,650
ये सिर्फ मानव सम्मेलनों हैं. केवल जिस तरह से आप यह पता होगा मामला है

320
00:19:22,650 --> 00:19:24,840
प्रलेखन पढ़ने के द्वारा होता है.

321
00:19:24,840 --> 00:19:28,200
तो चलो जहां int वास्तव में है GotInt के लिए नीचे स्क्रॉल.

322
00:19:28,200 --> 00:19:34,220
>> तो अगर मैं नीचे स्क्रॉल थोड़ा आगे, 170 लाइन में हम इन लाइनों के ऊपर एक टिप्पणी है.

323
00:19:34,220 --> 00:19:38,470
तो हम 172 में घोषणा, एक int n और एक चार ग, और फिर इस नए समारोह

324
00:19:38,470 --> 00:19:41,870
जो आप में से कुछ पहले भर में ठोकर खाई है, लेकिन sscanf.

325
00:19:41,870 --> 00:19:44,190
यह स्ट्रिंग स्कैन च के लिए खड़ा है.

326
00:19:44,190 --> 00:19:48,580
दूसरे शब्दों में, मुझे एक स्ट्रिंग दे और मैं यह ब्याज की जानकारी के टुकड़े के लिए स्कैन करेगा.

327
00:19:48,580 --> 00:19:53,820
तो इसका क्या मतलब है? खैर, मान लीजिए कि मैं कीबोर्ड पर में, सचमुच, 1 2 3 टाइप,

328
00:19:53,820 --> 00:19:59,730
और तब दर्ज करें मारा. 2 1 3 के डेटा प्रकार जब GetString द्वारा लौटाए गए क्या है?

329
00:19:59,730 --> 00:20:05,010
यह स्पष्ट रूप से एक स्ट्रिंग, है ना? मैं एक स्ट्रिंग है, तो 2 1 3 सच है "1 2 3"

330
00:20:05,010 --> 00:20:07,260
यह अंत में \ 0 के साथ. यह एक int नहीं है.

331
00:20:07,260 --> 00:20:10,420
यह एक संख्या नहीं है. यह एक नंबर की तरह दिखता है, लेकिन यह वास्तव में नहीं है.

332
00:20:10,420 --> 00:20:14,680
तो क्या GetInt करने के लिए क्या करना है? यह है कि सही करने के लिए छोड़ दिया स्ट्रिंग स्कैन है,

333
00:20:14,680 --> 00:20:19,010
1 2 3 0 \, और किसी तरह यह एक वास्तविक पूर्णांक कनवर्टर के लिए इस्तेमाल किया जा सकता है.

334
00:20:19,010 --> 00:20:21,010
अब, आप बाहर आंकड़ा कैसे यह करने के लिए कर सकते हैं.

335
00:20:21,010 --> 00:20:24,240
यदि तुम pset 2 वापस लगता है, तो आप शायद एक छोटे से आराम से मिला

336
00:20:24,240 --> 00:20:26,810
ताकि आप सीज़र या vigenere के साथ एक स्ट्रिंग पुनरावृति कर सकते हैं,

337
00:20:26,810 --> 00:20:29,800
आप घर का काम लेने के साथ ints को बदल सकते हैं. यह काम की एक पूरी बहुत कुछ है.

338
00:20:29,800 --> 00:20:32,800
फोन क्यों नहीं sscanf तरह एक समारोह है कि आप के लिए है कि नहीं करता?

339
00:20:32,800 --> 00:20:37,520
तो sscanf इस लाइन कहा जाता है के मामले में, जो एक स्ट्रिंग में एक तर्क है, उम्मीद है.

340
00:20:37,520 --> 00:20:41,310
फिर आप उद्धरण में निर्दिष्ट, बहुत printf के लिए इसी तरह की है,

341
00:20:41,310 --> 00:20:44,960
क्या आप इस स्ट्रिंग में देखने की उम्मीद करते हैं?

342
00:20:44,960 --> 00:20:52,980
मैं यहाँ क्या कह रहा है, मैं एक दशमलव संख्या और शायद एक चरित्र को देखने की उम्मीद है.

343
00:20:52,980 --> 00:20:54,990
और हम क्यों यह बस एक पल में मामले देखेंगे.

344
00:20:54,990 --> 00:20:58,440
यह पता चला है कि इस अंकन अब सामान की याद ताजा करती है

345
00:20:58,440 --> 00:21:00,840
हम सिर्फ एक हफ्ते पहले से अधिक के बारे में बात कर शुरू कर दिया.

346
00:21:00,840 --> 00:21:05,430
>> क्या है और n और ग हमारे लिए यहाँ क्या कर रही है? [छात्र जवाब, unintelligible]

347
00:21:05,430 --> 00:21:07,610
>> हाँ. यह मुझे n और ग के पते का पता दे रही है.

348
00:21:07,610 --> 00:21:10,440
अब, कि क्यों महत्वपूर्ण है? खैर, तुम्हें पता है कि सी में कार्यों के साथ

349
00:21:10,440 --> 00:21:13,440
तुम हमेशा एक या सभी में कोई मूल्य नहीं मान सकते हैं.

350
00:21:13,440 --> 00:21:16,630
आप एक int एक स्ट्रिंग, एक नाव, एक चार, जो कुछ भी लौट सकते हैं.

351
00:21:16,630 --> 00:21:21,150
या आप शून्य लौटने के लिए, कर सकते हैं, लेकिन आप केवल 1 बात ज़्यादा से ज़्यादा लौट सकते हैं.

352
00:21:21,150 --> 00:21:26,100
लेकिन यहाँ हम sscanf मुझे वापस जाने के लिए हो सकता है एक int, एक दशमलव संख्या चाहते हैं,

353
00:21:26,100 --> 00:21:29,240
और यह भी एक चार है, और इसलिए मैं एक क्षण में चार समझाता हूँ.

354
00:21:29,240 --> 00:21:34,250
तो आप को प्रभावी ढंग से च 2 बातें वापस करने के लिए करना चाहते हैं, कि बस सी. में संभव नहीं

355
00:21:34,250 --> 00:21:38,460
तो आप 2 पतों में से गुजर रहा है कि चारों ओर काम कर सकते हैं,

356
00:21:38,460 --> 00:21:43,710
क्योंकि जैसे ही आप एक समारोह 2 पते हाथ, उस समारोह उनके साथ क्या कर सकते हैं?

357
00:21:43,710 --> 00:21:49,880
यह उन पतों के लिए लिख सकते हैं. * आप कार्रवाई का उपयोग कर सकते हैं और उन पतों में से प्रत्येक के लिए "वहाँ जाओ" कर सकते हैं.

358
00:21:49,880 --> 00:21:54,320
यह यह पिछले दरवाजे तंत्र की तरह है, लेकिन चर के मूल्यों को बदलने के लिए बहुत आम है

359
00:21:54,320 --> 00:21:58,020
इस मामले में 2 1 जगह है, अधिक से अधिक समय में.

360
00:21:58,020 --> 00:22:04,590
अब, मैं to1 == के लिए जाँच कर रहा हूँ, तो और n लौटने कि अगर वास्तव में करता है, सच करने के लिए मूल्यांकन नोटिस.

361
00:22:04,590 --> 00:22:09,340
तो क्या चल रहा है? वैसे, तकनीकी, हम वास्तव में GetInt में ऐसा करना चाहते है.

362
00:22:09,340 --> 00:22:12,340
हम पार्स करने के लिए है, तो बात करने के लिए करना चाहते हैं, हम स्ट्रिंग पढ़ने के लिए चाहते हैं

363
00:22:12,340 --> 00:22:16,210
"1 2 3" और अगर ऐसा लगता है जैसे वहाँ एक संख्या है,

364
00:22:16,210 --> 00:22:21,360
क्या हम sscanf के लिए कह रहे हैं कि मेरे लिए इस चर n में संख्या 2, 3, 1, डाल दिया है.

365
00:22:21,360 --> 00:22:26,060
क्यों, तो, मैं इस के रूप में अच्छी तरह से किया है?

366
00:22:26,060 --> 00:22:33,750
भी कह रही है, sscanf, आप भी एक चरित्र यहाँ मिल सकता है की भूमिका क्या है.

367
00:22:33,750 --> 00:22:36,890
[छात्र बोल, unintelligible] >> नहीं - एक दशमलव बिंदु काम कर सकता है.

368
00:22:36,890 --> 00:22:40,650
चलो पकड़ है कि एक पल के लिए सोचा. और क्या?

369
00:22:40,650 --> 00:22:42,570
[छात्र, unintelligible] तो >>, अच्छा लगा, यह नल चरित्र हो सकता है.

370
00:22:42,570 --> 00:22:44,970
यह वास्तव में इस मामले में नहीं है. हाँ? [छात्र, unintelligible]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. या चलो, मुझे भी आगे सामान्यीकरण.

372
00:22:47,100 --> 00:22:49,670
% वहाँ ग त्रुटि जाँच के लिए ही है.

373
00:22:49,670 --> 00:22:52,510
हम वहाँ नहीं चाहते कि संख्या के बाद चरित्र हो सकता है,

374
00:22:52,510 --> 00:22:54,980
लेकिन क्या यह मुझे करने के लिए अनुमति देता है निम्नलिखित है:

375
00:22:54,980 --> 00:23:01,270
यह पता चला है कि sscanf, n और ग में मूल्यों को यहाँ इस उदाहरण में, भंडारण के अलावा,

376
00:23:01,270 --> 00:23:08,170
यह भी क्या करता है यह चर की संख्या देता है यह अंदर मूल्यों डाल

377
00:23:08,170 --> 00:23:13,330
तो अगर आप केवल 2 1 3 में लिखते हैं, तो केवल% d मैच करने के लिए जा रहा है

378
00:23:13,330 --> 00:23:18,830
और केवल n 2 1 3 की तरह एक मूल्य के साथ जमा हो जाता है और कुछ भी नहीं ग में डाल दिया जाता है;

379
00:23:18,830 --> 00:23:20,870
ग एक कचरा मान रहता है, तो बात करने के लिए.

380
00:23:20,870 --> 00:23:23,550
कचरा क्योंकि यह कुछ मूल्य के रूप में कभी नहीं प्रारंभ किया गया है.

381
00:23:23,550 --> 00:23:29,390
तो उस मामले में, sscanf 1 देता है, क्योंकि मैं उन संकेत की एक आबादी,

382
00:23:29,390 --> 00:23:33,650
जो मामले में, महान. मैं एक int है, तो मैं लाइन मुक्त करने के लिए स्मृति मुक्त

383
00:23:33,650 --> 00:23:37,150
GetString है कि वास्तव में आवंटित की है, और तो मैं n लौटने के.

384
00:23:37,150 --> 00:23:42,210
वरना, अगर आपने कभी सोचा है जहाँ कि लिए पुनःप्रयास करें बयान से आता है, यहीं से आता है.

385
00:23:42,210 --> 00:23:45,770
अगर, इसके विपरीत, मैं 1 2 3 foo में लिखते हैं,

386
00:23:45,770 --> 00:23:48,640
सिर्फ पाठ के कुछ यादृच्छिक अनुक्रम, sscanf को देखने के लिए जा रहा है,

387
00:23:48,640 --> 00:23:51,500
उह, संख्या, उह, संख्या, उह, संख्या, उह - च.

388
00:23:51,500 --> 00:23:54,190
और यह 1 2 3 n में डाल दिया जा रहा है.

389
00:23:54,190 --> 00:23:59,970
यह ग में च डाल दिया, और फिर 2 लौटने के लिए जा रहा है.

390
00:23:59,970 --> 00:24:02,980
तो हम है, बस scanf व्यवहार के मूल परिभाषा का उपयोग कर,

391
00:24:02,980 --> 00:24:06,170
एक बहुत ही सरल तरीके - ठीक है, पहली नज़र में जटिल है, लेकिन दिन के अंत में,

392
00:24:06,170 --> 00:24:11,460
कह के काफी सरल तंत्र, एक int है, और यदि ऐसा है, कि केवल एक चीज है कि मैंने पाया है?

393
00:24:11,460 --> 00:24:14,950
और सफेद अंतरिक्ष यहाँ विचार है. यदि आप sscanf के लिए प्रलेखन पढ़ा,

394
00:24:14,950 --> 00:24:18,690
यह आपको बताता है कि अगर आप शुरुआत या अंत में सफेद स्थान का एक टुकड़ा शामिल है,

395
00:24:18,690 --> 00:24:24,990
sscanf भी उपयोगकर्ता की अनुमति है, जो भी कारण के लिए, 1 2 3 spacebar मारा, और है कि वैध होगा.

396
00:24:24,990 --> 00:24:28,310
यह उपयोगकर्ता पर चिल्लाना नहीं सिर्फ इसलिए कि वे शुरुआत या अंत में spacebar मारा जाएगा,

397
00:24:28,310 --> 00:24:32,160
जो सिर्फ एक छोटे से अधिक उपयोगकर्ता के अनुकूल है.

398
00:24:32,160 --> 00:24:34,160
>> किसी भी सवाल है, तो, GetInts पर? हाँ?

399
00:24:34,160 --> 00:24:36,820
[छात्र सवाल है, unintelligible]

400
00:24:36,820 --> 00:24:40,740
>> अच्छा सवाल है. क्या होगा अगर तुम सिर्फ एक चार में टाइप, च, और हिट की तरह प्रवेश

401
00:24:40,740 --> 00:24:47,830
कभी 2 1 3 टाइपिंग के बिना, आप क्या सोचते हैं कोड की इस पंक्ति का व्यवहार तो होगा?

402
00:24:47,830 --> 00:24:50,500
तो sscanf कि भी कवर कर सकते हैं, क्योंकि उस मामले में,

403
00:24:50,500 --> 00:24:56,280
यह n या ग को भरने के लिए नहीं जा रहा है, यह करने के बजाय 0 वापसी करने के लिए जा रहा है.

404
00:24:56,280 --> 00:25:01,540
जो मामले में, मैं यह भी है कि परिदृश्य पकड़ रहा हूँ, क्योंकि मैं चाहता हूँ उम्मीद मूल्य 1 है.

405
00:25:01,540 --> 00:25:07,310
मैं केवल 1 चाहते हैं, और केवल 1 बात भरा होना. अच्छा सवाल है. दूसरों?

406
00:25:07,310 --> 00:25:09,610
>> ठीक है, तो यहाँ के कार्यों के सभी के माध्यम से जाना नहीं है,

407
00:25:09,610 --> 00:25:11,820
लेकिन एक है कि हो सकता है, शायद शेष ब्याज की, लगता है

408
00:25:11,820 --> 00:25:14,530
है GetString क्योंकि यह पता चला है कि GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
, सब बाज़ी GetDouble उनके GetString करने के लिए कार्यक्षमता की एक बहुत GetLongLong.

410
00:25:19,490 --> 00:25:22,860
तो चलो वह यहाँ कैसे कार्यान्वित किया जाता है पर एक नज़र रखना.

411
00:25:22,860 --> 00:25:27,040
यह एक थोड़ा जटिल दिखता है, लेकिन यह एक ही बुनियादी बातों का उपयोग करता है

412
00:25:27,040 --> 00:25:29,680
कि हम पिछले हफ्ते के बारे में बात कर शुरू कर दिया. तो GetString में,

413
00:25:29,680 --> 00:25:32,670
जो शून्य प्रति कोई तर्क के रूप में लेता है,

414
00:25:32,670 --> 00:25:37,110
और यह एक स्ट्रिंग देता है, तो मैं एक स्ट्रिंग बफर बुलाया की घोषणा कर रहा हूँ.

415
00:25:37,110 --> 00:25:39,670
मैं वास्तव में नहीं है कि क्या अभी तक के लिए इस्तेमाल किया जा रहा है पता नहीं है, लेकिन हम देखेंगे.

416
00:25:39,670 --> 00:25:42,950
क्षमता की तरह दिखता है डिफ़ॉल्ट, 0 से है, काफी यकीन है कि जहां यह जा रहा है नहीं.

417
00:25:42,950 --> 00:25:44,920
यकीन है कि क्या पता करने के लिए अभी तक के लिए इस्तेमाल किया जा रहा है.

418
00:25:44,920 --> 00:25:47,860
लेकिन अब यह एक छोटे से अधिक दिलचस्प हो रही है तो 243 लाइन में,

419
00:25:47,860 --> 00:25:51,760
हम एक int ग, इस एक बेवकूफ विस्तार की तरह है की घोषणा.

420
00:25:51,760 --> 00:25:58,080
एक चार 8 बिट है, और 8 बिट कितने विभिन्न मूल्यों स्टोर कर सकते हैं?

421
00:25:58,080 --> 00:26:03,310
256. समस्या है, अगर आप 256 अलग ASCII वर्ण चाहते हैं,

422
00:26:03,310 --> 00:26:06,210
जो वहाँ हैं, अगर तुम वापस लगता है, और यह याद करने के लिए कुछ नहीं है.

423
00:26:06,210 --> 00:26:09,100
लेकिन अगर आप कि बड़ा ASCII चार्ट वापस लगता है कि हम सप्ताह पहले किया था,

424
00:26:09,100 --> 00:26:13,780
उस मामले में, 128 या 256 ASCII वर्ण में थे.

425
00:26:13,780 --> 00:26:16,220
हम 0 के पैटर्न और 1 निर्भर है.

426
00:26:16,220 --> 00:26:19,410
यह एक समस्या है अगर आप एक त्रुटि का पता लगाने में सक्षम होना चाहता हूँ.

427
00:26:19,410 --> 00:26:23,290
क्योंकि अगर आप पहले से ही अपने पात्रों के लिए 256 मूल्यों का उपयोग कर रहे हैं,

428
00:26:23,290 --> 00:26:26,390
आप वास्तव में आगे नहीं की योजना थी, क्योंकि अब आप कह रही का कोई रास्ता नहीं है,

429
00:26:26,390 --> 00:26:29,750
"यह एक कानूनी चरित्र नहीं है, यह कुछ गलत संदेश है."

430
00:26:29,750 --> 00:26:32,430
तो दुनिया क्या करता है, वे अगले सबसे बड़ा मूल्य का उपयोग करें,

431
00:26:32,430 --> 00:26:35,790
एक int की तरह कुछ इतनी है कि आप बिट्स के एक पागल संख्या है,

432
00:26:35,790 --> 00:26:39,610
4 अरब संभव मूल्यों के लिए 32, इतना है कि आप बस ऊपर अंत का उपयोग कर सकते हैं,

433
00:26:39,610 --> 00:26:44,800
मूलतः, उनमें से 257, जिनमें से 1 एक त्रुटि के रूप में कुछ विशेष अर्थ नहीं है.

434
00:26:44,800 --> 00:26:49,190
>> तो चलो यह कैसे काम करता है देखने के लिए. 246 लाइन में, मैं इस बड़े जबकि पाश

435
00:26:49,190 --> 00:26:54,530
कि fgetc बुला रहा है, च अर्थ फ़ाइल, जीइ टीसी, और फिर stdin.

436
00:26:54,530 --> 00:26:59,030
पता चला है यह सिर्फ कह के और अधिक सटीक तरीका है "कीबोर्ड से इनपुट पढ़ें."

437
00:26:59,030 --> 00:27:02,730
मानक इनपुट का मतलब कुछ कीबोर्ड, मानक आउटपुट स्क्रीन का मतलब है,

438
00:27:02,730 --> 00:27:06,920
और मानक त्रुटि, जो हम 4 pset में देखेंगे, स्क्रीन का मतलब है,

439
00:27:06,920 --> 00:27:09,670
लेकिन स्क्रीन के एक विशेष भाग इतना है कि यह नहीं conflated

440
00:27:09,670 --> 00:27:13,760
वास्तविक उत्पादन के साथ कि आप मुद्रित करना है, लेकिन भविष्य में उस पर और अधिक.

441
00:27:13,760 --> 00:27:19,430
तो fgetc सिर्फ कुंजीपटल से एक चरित्र का मतलब पढ़ा है, और यह जहा?

442
00:27:19,430 --> 00:27:24,000
यह ग में स्टोर, और फिर जांच, तो मैं बस कुछ बूलियन संयोजक यहाँ का उपयोग कर रहा हूँ,

443
00:27:24,000 --> 00:27:28,430
जाँच करें कि यह \ n बराबर, तो उपयोगकर्ता में प्रवेश करने के लिए मारा गया है नहीं है.

444
00:27:28,430 --> 00:27:31,510
हम उस बिंदु, लूप के अंत में बंद करना चाहते हैं, और हम भी जाँच करना चाहते हैं

445
00:27:31,510 --> 00:27:36,170
के लिए विशेष निरंतर, EOF, जो अगर आप जानते हैं या लगता है कि यह क्या के लिए खड़े करता है?

446
00:27:36,170 --> 00:27:39,860
फ़ाइल का अंत. तो यह बेतुका की तरह है, क्योंकि अगर मैं कीबोर्ड पर टाइप कर रहा हूँ,

447
00:27:39,860 --> 00:27:41,900
वहाँ वास्तव में कोई फ़ाइल इस में शामिल है,

448
00:27:41,900 --> 00:27:44,330
लेकिन यह सिर्फ सामान्य मतलब प्रयोग किया जाता शब्द की तरह है

449
00:27:44,330 --> 00:27:50,320
कि और कुछ नहीं मानव उंगलियों से आ रहा है. EOF. फ़ाइल का अंत.

450
00:27:50,320 --> 00:27:52,600
एक अलग रूप में, अगर तुम कभी अपने कुंजीपटल पर नियंत्रण घ मारा,

451
00:27:52,600 --> 00:27:54,680
कि तुम अभी तक नहीं करना होगा, आप नियंत्रण ग मारा है.

452
00:27:54,680 --> 00:27:57,920
लेकिन नियंत्रण घ इस विशेष लगातार बुलाया EOF भेजता है.

453
00:27:57,920 --> 00:28:03,100
>> तो अब हम सिर्फ कुछ गतिशील स्मृति आवंटन है.

454
00:28:03,100 --> 00:28:06,460
तो अगर n + 1> क्षमता, अब मैं n समझाता हूँ.

455
00:28:06,460 --> 00:28:09,380
n कितने बाइट्स बफर में वर्तमान में कर रहे हैं,

456
00:28:09,380 --> 00:28:11,970
स्ट्रिंग है कि आप वर्तमान में उपयोगकर्ता से निर्माण कर रहे हैं.

457
00:28:11,970 --> 00:28:16,240
यदि आप अपने बफर में अधिक वर्ण से आप बफर में क्षमता है,

458
00:28:16,240 --> 00:28:20,760
intuitively, हम क्या करने की जरूरत है तो अधिक क्षमता आवंटित है.

459
00:28:20,760 --> 00:28:24,490
मैं गणित के कुछ यहाँ किसी पदार्थ का उत्तम तत्त्व ले लेना करने के लिए जा रहा हूँ

460
00:28:24,490 --> 00:28:26,900
और इस समारोह पर ही ध्यान केंद्रित.

461
00:28:26,900 --> 00:28:29,170
तुम्हें पता है क्या malloc है, या कम से कम आम तौर पर परिचित.

462
00:28:29,170 --> 00:28:32,380
एक अनुमान realloc क्या करता है ले लो. [छात्र जवाब, unintelligible]

463
00:28:32,380 --> 00:28:35,690
>> हाँ. और यह काफी स्मृति नहीं जोड़ने से है, यह इस प्रकार के रूप में स्मृति reallocates:

464
00:28:35,690 --> 00:28:40,530
अगर वहाँ अभी भी स्ट्रिंग के अंत में कमरे में आप है कि स्मृति की अधिक दे

465
00:28:40,530 --> 00:28:43,370
की तुलना में यह मूल रूप से आप देता है, तो आपको लगता है कि अतिरिक्त स्मृति मिल जाएगा.

466
00:28:43,370 --> 00:28:46,640
तो तुम सिर्फ तार वर्ण वापस डाल से वापस वापस करने के लिए वापस करने के लिए कर सकते हैं.

467
00:28:46,640 --> 00:28:49,290
लेकिन अगर यह मामला नहीं है, क्योंकि आप भी लंबे समय से इंतजार कर रहे थे

468
00:28:49,290 --> 00:28:51,700
और बिना सोचे समझे कुछ स्मृति में वहाँ plopped, लेकिन वहाँ अतिरिक्त है

469
00:28:51,700 --> 00:28:56,480
यहाँ नीचे स्मृति, वह ठीक है. Realloc आप सभी के लिए भारी उठाने करने के लिए जा रहा है,

470
00:28:56,480 --> 00:28:58,810
आप स्ट्रिंग में पढ़ा है और इस तरह यहाँ से दूर ले जाने के लिए,

471
00:28:58,810 --> 00:29:02,550
इसे नीचे रख, और फिर आप उस बिंदु पर कुछ और रनवे दे.

472
00:29:02,550 --> 00:29:05,610
तो हाथ की एक लहर के साथ, मुझे कहना है कि क्या GetString कर रही है

473
00:29:05,610 --> 00:29:09,540
यह एक छोटे से बफर, शायद 1 एकल चरित्र के साथ शुरू हो रहा है,

474
00:29:09,540 --> 00:29:12,300
और 2 अक्षरों में उपयोगकर्ता प्रकार अगर, GetString समाप्त होता है

475
00:29:12,300 --> 00:29:15,210
realloc बुला रही है और कहता है, 'ओह, 1 चरित्र के लिए पर्याप्त नहीं था.

476
00:29:15,210 --> 00:29:18,480
मुझे 2 अक्षर दे. ' तो अगर आप पाश के तर्क के माध्यम से पढ़ा,

477
00:29:18,480 --> 00:29:21,070
यह कहना है, 'ओह, 3 अक्षरों में टाइप उपयोगकर्ता जा रहा है.

478
00:29:21,070 --> 00:29:25,690
मुझे दो. अब नहीं 2, लेकिन 4 वर्ण, तो मुझे 8 देते हैं, तो मुझे 16 और 32 दे. '

479
00:29:25,690 --> 00:29:28,180
तथ्य यह है कि मैं क्षमता हर बार दोगुना कर रहा हूँ

480
00:29:28,180 --> 00:29:30,320
मतलब यह है कि बफर करने के लिए धीरे धीरे बढ़ने नहीं जा रहा है.

481
00:29:30,320 --> 00:29:35,870
यह सुपर फास्ट बढ़ती जा रही है, और क्या उस का लाभ हो सकता है?

482
00:29:35,870 --> 00:29:38,540
मैं क्यों बफर के आकार के दोहरीकरण रहा हूँ, भले ही उपयोगकर्ता

483
00:29:38,540 --> 00:29:41,450
सिर्फ 1 कीबोर्ड से अतिरिक्त चरित्र की आवश्यकता हो सकती है?

484
00:29:41,450 --> 00:29:44,830
[छात्र जवाब, unintelligible]. >> क्या है?

485
00:29:44,830 --> 00:29:46,750
बिल्कुल सही. आप इसे अक्सर के रूप में विकसित करने के लिए नहीं है.

486
00:29:46,750 --> 00:29:48,870
और यह एक बस की तरह है - तुम यहाँ अपने दांव हेजिंग.

487
00:29:48,870 --> 00:29:54,150
विचार किया जा रहा है कि आप एक बहुत realloc कॉल नहीं चाहते हैं, क्योंकि यह धीमी गति से हो जाता है.

488
00:29:54,150 --> 00:29:56,840
किसी भी समय आप पूछना स्मृति के लिए ऑपरेटिंग सिस्टम के रूप में आप जल्द ही देखेंगे

489
00:29:56,840 --> 00:30:00,620
एक भविष्य समस्या सेट में, यह कुछ समय लेने के लिए जाता है.

490
00:30:00,620 --> 00:30:04,980
समय की है कि कम से कम राशि है, भले ही आप कुछ अंतरिक्ष बर्बाद कर रहे हैं तो एक अच्छी बात हो जाता है.

491
00:30:04,980 --> 00:30:07,250
>> लेकिन अगर हम यहाँ GetString के अंतिम भाग के माध्यम से पढ़ा,

492
00:30:07,250 --> 00:30:10,880
और फिर, हर एक लाइन यहाँ समझ आज इतनी महत्वपूर्ण नहीं है.

493
00:30:10,880 --> 00:30:14,830
नोटिस लेकिन है कि यह अंततः malloc फिर से कहता है, और यह का आवंटन

494
00:30:14,830 --> 00:30:16,980
बिल्कुल के रूप में कई बाइट्स के रूप में यह स्ट्रिंग के लिए की जरूरत है

495
00:30:16,980 --> 00:30:21,620
और फिर फ्री फोन करके दूर फेंकता है, जरूरत से ज्यादा बड़े बफर,

496
00:30:21,620 --> 00:30:23,510
अगर यह वास्तव में भी कई बार दोगुनी हो गया.

497
00:30:23,510 --> 00:30:25,970
संक्षेप में, है कि कैसे GetString यह सब समय काम कर रहा है.

498
00:30:25,970 --> 00:30:30,100
यह सब होता है एक समय में एक चरित्र फिर से पढ़ा जाता है और फिर

499
00:30:30,100 --> 00:30:37,930
और हर बार यह कुछ अतिरिक्त स्मृति की आवश्यकता है, यह realloc फोन करके इसके लिए ऑपरेटिंग सिस्टम पूछता है.

500
00:30:37,930 --> 00:30:41,660
कोई सवाल? सही सभी.

501
00:30:41,660 --> 00:30:45,220
>> एक हमले. अब है कि हम संकेत को समझते हैं, या कम से कम

502
00:30:45,220 --> 00:30:47,560
संकेत के साथ तेजी से परिचित हैं,

503
00:30:47,560 --> 00:30:50,020
चलो विचार कैसे पूरी दुनिया के पतन शुरू होता है

504
00:30:50,020 --> 00:30:53,160
अगर आप काफी adversarial उपयोगकर्ताओं के खिलाफ नहीं की रक्षा करते हैं,

505
00:30:53,160 --> 00:30:55,180
लोग हैं, जो आपके सिस्टम में हैक करने की कोशिश कर रहे हैं.

506
00:30:55,180 --> 00:31:00,260
जो लोग कुछ पंजीकरण कोड circumventing द्वारा अपने सॉफ्टवेयर चोरी करने की कोशिश कर रहे हैं

507
00:31:00,260 --> 00:31:02,150
कि वे अन्यथा प्रकार अंदर हो सकता है

508
00:31:02,150 --> 00:31:04,860
इस उदाहरण पर एक नज़र यहाँ ले लो, जो सिर्फ सी कोड है

509
00:31:04,860 --> 00:31:07,920
कि नीचे एक मुख्य कार्य है, कि एक समारोह foo कहता है,

510
00:31:07,920 --> 00:31:12,100
और क्या यह foo गुजर रहा है? एक एकल तर्क [छात्र].

511
00:31:12,100 --> 00:31:15,660
>> एकल तर्क. तो argv [1], जो पहला शब्द उपयोगकर्ता टाइप का मतलब

512
00:31:15,660 --> 00:31:19,150
a.out या जो भी बाद कमांड लाइन कार्यक्रम कहा जाता है.

513
00:31:19,150 --> 00:31:24,920
Foo तो, शीर्ष पर, एक चार * में लेता है, लेकिन चार * बस क्या है?

514
00:31:24,920 --> 00:31:28,860
स्ट्रिंग. कोई नई बात नहीं है, और है कि मनमाने ढंग से स्ट्रिंग बार बुलाया जा रहा है.

515
00:31:28,860 --> 00:31:36,090
यहाँ इस लाइन में, चार ग [12], अर्द्ध तकनीकी अंग्रेजी की तरह, इस लाइन क्या कर रही है?

516
00:31:36,090 --> 00:31:40,640
सरणी? वर्ण. मुझे 12 वर्णों की एक सरणी दे.

517
00:31:40,640 --> 00:31:44,970
तो हम एक बफर कॉल कर सकते हैं. यह तकनीकी ग कहा जाता है, लेकिन प्रोग्रामिंग में एक बफर

518
00:31:44,970 --> 00:31:47,890
सिर्फ अंतरिक्ष की एक गुच्छा का मतलब है कि आप कुछ सामान अंदर रख सकते हैं

519
00:31:47,890 --> 00:31:49,940
>> फिर अंत में, memcpy, हम पहले नहीं का उपयोग किया है.

520
00:31:49,940 --> 00:31:52,380
लेकिन आप शायद लगता है कि यह क्या करता है सकते हैं. यह स्मृति प्रतियां.

521
00:31:52,380 --> 00:31:58,790
यह क्या करता है? खैर, यह स्पष्ट तौर पर बार प्रतियां, अपने इनपुट ग में,

522
00:31:58,790 --> 00:32:03,420
लेकिन केवल पट्टी की लंबाई.

523
00:32:03,420 --> 00:32:07,440
लेकिन यहाँ एक बग है.

524
00:32:07,440 --> 00:32:14,500
ठीक है, तो तकनीकी रूप से हम वास्तव में strlen (पट्टी) x sizeof (चार), यह सही है.

525
00:32:14,500 --> 00:32:17,920
लेकिन सबसे खराब मामले में, कि that's मान - हां, तो ठीक है.

526
00:32:17,920 --> 00:32:23,760
तो वहाँ 2 कीड़े है. Sizeof (चार), सब ठीक है, तो यह एक छोटे से व्यापक बनाने.

527
00:32:23,760 --> 00:32:28,860
तो अब वहाँ अभी भी एक बग है, जो क्या है?

528
00:32:28,860 --> 00:32:31,630
[छात्र जवाब, unintelligible] के लिए क्या >> जांच? ठीक है, तो हम जाँच की जानी चाहिए

529
00:32:31,630 --> 00:32:35,010
नल के लिए, क्योंकि बुरी बातें होती हैं जब अपने सूचक रिक्त है,

530
00:32:35,010 --> 00:32:38,490
क्योंकि तुम वहाँ जा रहा है, हो सकता है और आप कभी नहीं होने के लिए जा रहा नल चाहिए

531
00:32:38,490 --> 00:32:40,890
* ऑपरेटर के साथ अपसंदर्भन द्वारा.

532
00:32:40,890 --> 00:32:45,250
तो यह है कि अच्छा है, और हम और क्या कर रहे हैं? तार्किक रूप से वहाँ एक दोष यहाँ भी है.

533
00:32:45,250 --> 00:32:47,650
[छात्र जवाब, unintelligible]

534
00:32:47,650 --> 00:32:51,340
>> तो अगर argc ≥ 2 की जांच?

535
00:32:51,340 --> 00:32:54,130
ठीक है, तो इस कार्यक्रम में 3 कीड़े यहाँ है.

536
00:32:54,130 --> 00:33:00,080
हम अगर उपयोगकर्ता वास्तव में टाइप [1] argv में अच्छा है, कुछ भी नहीं की जाँच कर रहे हैं.

537
00:33:00,080 --> 00:33:02,240
तो 3 बग क्या है? हाँ?

538
00:33:02,240 --> 00:33:04,420
[छात्र जवाब, unintelligible] अच्छा. >>

539
00:33:04,420 --> 00:33:09,590
तो हम एक परिदृश्य की जाँच की. हम उलझाव से जाँच के और अधिक स्मृति की नकल नहीं है

540
00:33:09,590 --> 00:33:12,800
पट्टी की लंबाई से अधिक हो जाती है.

541
00:33:12,800 --> 00:33:15,720
तो अगर स्ट्रिंग में टाइप उपयोगकर्ता 10 वर्ण लंबा है,

542
00:33:15,720 --> 00:33:18,260
यह कह रही है, केवल 10 अक्षर की प्रतिलिपि बनाते हैं. '

543
00:33:18,260 --> 00:33:21,140
और कहा कि ठीक है, लेकिन क्या अगर शीघ्र एक शब्द में टाइप उपयोगकर्ता

544
00:33:21,140 --> 00:33:29,360
एक 20 चरित्र शब्द की तरह है, यह है, क्या में पट्टी से प्रतिलिपि 20 अक्षर कह?

545
00:33:29,360 --> 00:33:32,840
ग, अन्यथा हमारे बफर के रूप में जाना जाता है, जिसका मतलब है कि आप सिर्फ डेटा लिखा

546
00:33:32,840 --> 00:33:35,950
8 बाइट स्थानों है कि आप खुद का नहीं है,

547
00:33:35,950 --> 00:33:38,320
और आप उन्हें भावना है कि आप उन्हें कभी नहीं आवंटित में ही नहीं है.

548
00:33:38,320 --> 00:33:41,190
तो यह है कि क्या आम तौर पर बफर अतिप्रवाह हमले के रूप में जाना जाता है,

549
00:33:41,190 --> 00:33:46,650
या बफर सीमा से अधिक का दौरा, और इस अर्थ में यह हमले की है कि यदि उपयोगकर्ता

550
00:33:46,650 --> 00:33:50,650
या प्रोग्राम है कि अपने कार्य बुला रहा है इस दुर्भावनापूर्ण रूप से कर रही है,

551
00:33:50,650 --> 00:33:53,780
क्या वास्तव में अगले काफी बुरा हो सकता है होता है.

552
00:33:53,780 --> 00:33:55,690
>> इस चित्र पर एक नज़र यहाँ ले.

553
00:33:55,690 --> 00:33:59,070
यह तस्वीर स्मृति के ढेर का प्रतिनिधित्व करता है.

554
00:33:59,070 --> 00:34:01,050
याद करते हैं और है कि हर बार जब आप एक समारोह फोन,

555
00:34:01,050 --> 00:34:04,520
आप ढेर पर इस छोटे फ्रेम पाने के लिए और फिर एक और फिर एक और और फिर एक और.

556
00:34:04,520 --> 00:34:07,250
और इस प्रकार अब तक हम बस की तरह है इन आयतों के रूप में दूर abstracted

557
00:34:07,250 --> 00:34:09,380
या तो बोर्ड पर या स्क्रीन पर यहाँ.

558
00:34:09,380 --> 00:34:12,219
लेकिन अगर हम उन आयतों पर ज़ूम

559
00:34:12,219 --> 00:34:16,460
जब आप एक समारोह foo कहते हैं, यह पता चला है कि वहाँ ढेर पर अधिक है

560
00:34:16,460 --> 00:34:18,739
कि फ्रेम और है कि आयत के अंदर

561
00:34:18,739 --> 00:34:23,370
की तुलना में सिर्फ एक्स और y और एक और ख, जैसे हम स्वैप के बारे में बात कर किया.

562
00:34:23,370 --> 00:34:25,949
यह पता चला है कि वहाँ कुछ निचले स्तर के विवरण हैं,

563
00:34:25,949 --> 00:34:27,780
उन के बीच में पता वापस.

564
00:34:27,780 --> 00:34:33,020
तो यह पता चला जब मुख्य foo कॉल, मुख्य foo सूचित

565
00:34:33,020 --> 00:34:36,760
मुख्य पते क्या कंप्यूटर की स्मृति में है.

566
00:34:36,760 --> 00:34:40,659
क्योंकि अन्यथा, के रूप में foo के रूप में जल्द ही इस मामले में यहाँ के रूप में क्रियान्वित किया जाता है,

567
00:34:40,659 --> 00:34:43,790
एक बार आप foo के अंत में यह करीब घुंघराले ब्रेस तक पहुँचने के लिए,

568
00:34:43,790 --> 00:34:48,860
कैसे बिल्ली foo जहां कार्यक्रम के नियंत्रण के लिए जाना माना जाता है पता नहीं है?

569
00:34:48,860 --> 00:34:52,460
यह पता चला है कि उस सवाल का जवाब है कि लाल आयत में है.

570
00:34:52,460 --> 00:34:56,130
यह एक सूचक का प्रतिनिधित्व करता है, और यह कंप्यूटर को स्टोर करने के लिए अस्थायी रूप से,

571
00:34:56,130 --> 00:35:00,250
ढेर तथाकथित मुख्य ताकि के रूप में foo के रूप में जल्द ही पते क्रियान्वित किया जाता है,

572
00:35:00,250 --> 00:35:04,110
कंप्यूटर जहां मुख्य लाइन और वापस जाने के लिए क्या जानता है.

573
00:35:04,110 --> 00:35:06,900
सहेजे गए फ्रेम सूचक यह करने के लिए इसी तरह से संबंधित है.

574
00:35:06,900 --> 00:35:09,620
चार * यहाँ बार क्या प्रतिनिधित्व करता है?

575
00:35:09,620 --> 00:35:14,740
खैर, अब इस नीले खंड यहाँ foo फ्रेम है, बार क्या है?

576
00:35:14,740 --> 00:35:18,300
ठीक है, तो बार बस foo समारोह के लिए तर्क है.

577
00:35:18,300 --> 00:35:20,720
>> तो अब हम परिचित तस्वीर को वापस कर रहे हैं.

578
00:35:20,720 --> 00:35:22,960
अधिक और स्क्रीन पर सामान अधिक distractions

579
00:35:22,960 --> 00:35:27,490
लेकिन इस हल्के नीले रंग खंड है कि हम क्या स्वैप की तरह कुछ के लिए किया गया है चॉकबोर्ड पर ड्राइंग.

580
00:35:27,490 --> 00:35:31,890
Foo के लिए और फ्रेम में ही बात यह अब ठीक है बार है,

581
00:35:31,890 --> 00:35:34,630
जो इस पैरामीटर है.

582
00:35:34,630 --> 00:35:39,840
लेकिन और क्या ढेर में यहाँ इस कोड के अनुसार होना चाहिए?

583
00:35:39,840 --> 00:35:44,280
चार ग. [12] इसलिए हम भी स्मृति के 12 वर्ग देखना चाहिए,

584
00:35:44,280 --> 00:35:46,260
ग चर बुलाया आवंटित.

585
00:35:46,260 --> 00:35:48,340
और वास्तव में हम स्क्रीन पर कि है.

586
00:35:48,340 --> 00:35:51,650
बहुत ऊपर है ग [0], और फिर इस चित्र के लेखक

587
00:35:51,650 --> 00:35:55,130
परेशान किया था लेकिन नहीं सभी वर्गों के ड्राइंग वहाँ वास्तव में कर रहे हैं 12 वहाँ

588
00:35:55,130 --> 00:36:00,120
क्योंकि अगर आप नीचे सही पर देखो, ग [11], यदि आप 0 से गिनती, 12 बाइट्स है.

589
00:36:00,120 --> 00:36:06,190
लेकिन यहाँ समस्या है: ग किस दिशा में बढ़ रहा है?

590
00:36:06,190 --> 00:36:10,390
नीचे ऊपर की तरह है, है ना? यदि यह शीर्ष पर शुरू होता है और नीचे करने के लिए बढ़ता है,

591
00:36:10,390 --> 00:36:13,480
देखने के लिए नहीं करता है जैसे हम खुद को बहुत रनवे छोड़ दिया सब यहाँ पर.

592
00:36:13,480 --> 00:36:15,320
हम तरह के एक कोने में खुद को चित्रित किया है,

593
00:36:15,320 --> 00:36:20,210
और कि ग [11] बार, जो स्टैक फ्रेम सूचक के खिलाफ सही है के खिलाफ सही है,

594
00:36:20,210 --> 00:36:23,800
जो वापसी पते के खिलाफ सही है, वहाँ कोई और अधिक कमरा है.

595
00:36:23,800 --> 00:36:26,100
तो क्या निहितार्थ है, तो, अगर तुम पेंच,

596
00:36:26,100 --> 00:36:30,460
और आप एक 12 - बाइट बफर में 20 बाइट्स पढ़ने की कोशिश की?

597
00:36:30,460 --> 00:36:33,460
उन 8 अतिरिक्त बाइट्स कहाँ जा रहे हैं?

598
00:36:33,460 --> 00:36:36,370
बाकी सब कुछ अंदर, जिनमें से कुछ महत्वपूर्ण सुपर है.

599
00:36:36,370 --> 00:36:40,480
और सबसे महत्वपूर्ण बात, संभावित, लाल बॉक्स है, वापसी पते.

600
00:36:40,480 --> 00:36:44,720
क्योंकि लगता है कि आप या तो गलती से या adversarially

601
00:36:44,720 --> 00:36:48,040
उन 4 बाइट्स, कि सूचक पते लिखना चाहते हैं,

602
00:36:48,040 --> 00:36:53,190
कचरे के साथ, लेकिन एक नंबर है कि स्मृति में एक वास्तविक पते का प्रतिनिधित्व होता है के साथ नहीं है?

603
00:36:53,190 --> 00:36:55,930
Implicaiton क्या है तार्किक,?

604
00:36:55,930 --> 00:36:59,080
[छात्र जवाब, unintelligible] वास्तव में. >> जब foo रिटर्न

605
00:36:59,080 --> 00:37:03,560
हिट और धनु धनुकोष्ठक कि कार्यक्रम के मुख्य करने के लिए वापस नहीं करने के लिए आगे बढ़ना जा रहा है,

606
00:37:03,560 --> 00:37:08,320
यह पता कि लाल बॉक्स में जो कुछ भी है लौटने जा रहा है.

607
00:37:08,320 --> 00:37:11,560
>> अब, circumventing सॉफ्टवेयर पंजीकरण के मामले में,

608
00:37:11,560 --> 00:37:14,400
क्या पता है कि करने के लिए किया जा रहा वापस आ रहा है एक समारोह है

609
00:37:14,400 --> 00:37:18,820
है कि आम तौर पर बुलाया जाता है के बाद आप सॉफ्टवेयर के लिए भुगतान किया है और अपने पंजीकरण कोड inputted?

610
00:37:18,820 --> 00:37:23,160
आप कंप्यूटर चाल के यहाँ नहीं जा रहा में छांटने सकता है, लेकिन इसके बजाय, यहाँ पर जा रहा है.

611
00:37:23,160 --> 00:37:27,950
या, यदि आप वास्तव में कर रहे हैं चालाक, एक विरोधी वास्तव में कुंजीपटल में टाइप कर सकते हैं,

612
00:37:27,950 --> 00:37:32,500
उदाहरण के लिए, नहीं एक वास्तविक, शब्द नहीं 20 अक्षर है, लेकिन लगता है वह या वह

613
00:37:32,500 --> 00:37:36,200
कुछ वर्ण है कि कोड का प्रतिनिधित्व में प्रकार?

614
00:37:36,200 --> 00:37:38,860
और यह सी कोड होने नहीं जा रहा है, यह करने के लिए वर्ण होने जा रहा है

615
00:37:38,860 --> 00:37:42,920
कि बाइनरी मशीन कोड, 0 और 1 का प्रतिनिधित्व करते हैं.

616
00:37:42,920 --> 00:37:46,740
लेकिन लगता है कि वे काफी चालाक है कि, किसी भी तरह GetString शीघ्र में चस्पा करने के लिए कर रहे हैं

617
00:37:46,740 --> 00:37:49,460
कुछ है कि अनिवार्य रूप से कोड को संकलित किया गया है,

618
00:37:49,460 --> 00:37:56,900
और पिछले 4 बाइट्स कि वापसी पता लिखना चाहते हैं, और क्या पता है कि इनपुट क्या करता है?

619
00:37:56,900 --> 00:38:01,860
यह इस लाल आयत बफर की पहली बाइट के पते में भंडार है.

620
00:38:01,860 --> 00:38:04,270
तो तुम बहुत चालाक है, और यह परीक्षण और त्रुटि के एक बहुत कुछ है

621
00:38:04,270 --> 00:38:08,500
बुरे लोग वहाँ से बाहर है, लेकिन, अगर आप समझ कितना बड़ा इस बफर के लिए

622
00:38:08,500 --> 00:38:12,170
कि इस तरह के निवेश में पिछले कुछ बाइट्स है कि आप इस कार्यक्रम को उपलब्ध कराने के

623
00:38:12,170 --> 00:38:15,970
अपने बफर की शुरुआत का पता करने के लिए बराबर होना होगा,

624
00:38:15,970 --> 00:38:22,270
आप यह कर सकते हैं. यदि हम कहते हैं, आम तौर पर, हैलो, और \ 0, कि क्या बफर में समाप्त होता है.

625
00:38:22,270 --> 00:38:27,860
लेकिन अगर हम और अधिक चतुर हो, और हम हम क्या generically का दौरा पड़ने कोड के साथ फोन करता हूँ कि बफर को भरने,

626
00:38:27,860 --> 00:38:31,920
ए, ए, ए, एक: हमला, हमले, हमले, हमले, जहां यह सिर्फ कुछ है कि कुछ बुरा करता है.

627
00:38:31,920 --> 00:38:35,190
ठीक है, क्या होता है अगर तुम सच में चालाक, आप यह कर सकते हैं:

628
00:38:35,190 --> 00:38:41,740
80, सीओ, 35, 08: लाल बॉक्स में संख्या का एक दृश्य है.

629
00:38:41,740 --> 00:38:44,890
सूचना है कि वह संख्या है कि यहाँ है मैच.

630
00:38:44,890 --> 00:38:47,280
यह रिवर्स क्रम में है, लेकिन यह है कि कुछ अन्य समय पर अधिक है.

631
00:38:47,280 --> 00:38:51,430
सूचना है कि इस वापसी पता जानबूझकर बदल दिया गया है

632
00:38:51,430 --> 00:38:54,970
पते बराबर यहाँ, मुख्य पता नहीं.

633
00:38:54,970 --> 00:39:00,170
तो अगर बुरा आदमी सुपर स्मार्ट है, वह या वह है कि हमले के कोड में शामिल करने के लिए जा रहा है

634
00:39:00,170 --> 00:39:02,890
कुछ पसंद है, 'उपयोगकर्ता फ़ाइलों के सभी हटाएँ.'

635
00:39:02,890 --> 00:39:06,320
या 'पासवर्ड की प्रतिलिपि बनाएँ,' या 'एक उपयोगकर्ता खाते है कि मैं में लॉग इन कर सकते हैं बनाएँ.'

636
00:39:06,320 --> 00:39:10,130
सभी में कुछ भी, और यह दोनों खतरे और सी. शक्ति है

637
00:39:10,130 --> 00:39:12,900
क्योंकि आप संकेत के माध्यम से याद करने के लिए उपयोग किया है

638
00:39:12,900 --> 00:39:15,950
और इसलिए तुम कुछ भी आप एक कंप्यूटर की स्मृति में चाहते लिख सकते हैं.

639
00:39:15,950 --> 00:39:19,290
आप कर सकते हैं एक कंप्यूटर कुछ भी आप बस चाहते

640
00:39:19,290 --> 00:39:22,780
यह अपने स्वयं के स्मृति अंतरिक्ष के भीतर चारों ओर छलांग.

641
00:39:22,780 --> 00:39:27,230
और हां, तो ऐसा है, तो इस दिन के लिए कई कार्यक्रमों और इतने सारे वेबसाइटों है कि समझौता कर रहे हैं

642
00:39:27,230 --> 00:39:29,730
लोगों को इस का लाभ लेने के लिए नीचे फोड़ा.

643
00:39:29,730 --> 00:39:32,510
और यह एक सुपर परिष्कृत हमले की तरह लग सकता है,

644
00:39:32,510 --> 00:39:34,220
लेकिन यह हमेशा कि तरह शुरू नहीं करता है.

645
00:39:34,220 --> 00:39:36,770
>> वास्तविकता यह है कि बुरे लोगों को आम तौर पर क्या करना होगा है,

646
00:39:36,770 --> 00:39:41,470
क्या यह एक कमांड लाइन पर एक कार्यक्रम या एक GUI प्रोग्राम या एक वेबसाइट है,

647
00:39:41,470 --> 00:39:43,290
तुम सिर्फ बकवास प्रदान करने शुरू.

648
00:39:43,290 --> 00:39:46,940
आप खोज क्षेत्र और हिट दर्ज करें में एक बहुत बड़ा शब्द में टाइप करें,

649
00:39:46,940 --> 00:39:49,030
और आप को देखने अगर वेबसाइट क्रैश इंतजार.

650
00:39:49,030 --> 00:39:53,270
या फिर आप को देखने के लिए अगर कार्यक्रम कुछ त्रुटि संदेश प्रकट होता है रुको.

651
00:39:53,270 --> 00:39:55,480
अगर तुम भाग्यशाली हो, क्योंकि बुरा आदमी,

652
00:39:55,480 --> 00:39:59,610
और आप कुछ पागल इनपुट है कि कार्यक्रम दुर्घटनाओं प्रदान करते हैं,

653
00:39:59,610 --> 00:40:02,280
इसका मतलब है कि प्रोग्रामर अपने बुरे व्यवहार सोचा भी नहीं था

654
00:40:02,280 --> 00:40:05,420
जो आप शायद पर्याप्त प्रयास के साथ कर सकते हैं, इसका मतलब है,

655
00:40:05,420 --> 00:40:09,870
पर्याप्त परीक्षण और त्रुटि, बाहर आंकड़ा कैसे एक और अधिक सटीक हमले मजदूरी.

656
00:40:09,870 --> 00:40:15,900
इतना के रूप में सुरक्षा का एक हिस्सा इन हमलों से परहेज नहीं है कुल मिलाकर, लेकिन उन्हें पता लगाने

657
00:40:15,900 --> 00:40:20,250
और वास्तव में लॉग देख और देख पागल आदानों क्या लोगों को अपनी वेबसाइट में लिखा गया है.

658
00:40:20,250 --> 00:40:26,040
क्या खोज शब्दों कुछ बफर बह निकला की उम्मीद में लोगों को अपनी वेबसाइट में लिखा है?

659
00:40:26,040 --> 00:40:28,900
और यह क्या एक सरणी के सरल मूल बातें करने के लिए सभी नीचे फोड़े,

660
00:40:28,900 --> 00:40:32,510
और क्या यह आवंटन और स्मृति का उपयोग करने के लिए क्या मतलब है?

661
00:40:32,510 --> 00:40:34,920
और उस से संबंधित है, भी, यह है.

662
00:40:34,920 --> 00:40:37,520
>> तो चलो सिर्फ एक हार्ड ड्राइव के अंदर एक बार फिर नज़र.

663
00:40:37,520 --> 00:40:40,190
तो आपको याद है कि एक या दो सप्ताह पहले से जब आप फ़ाइलों को खींच

664
00:40:40,190 --> 00:40:45,470
अपने रीसायकल बिन या कचरा कर सकते हैं, क्या होता है?

665
00:40:45,470 --> 00:40:47,850
[छात्र] कुछ भी नहीं है. >> हाँ, बिल्कुल कुछ भी नहीं. अंत में अगर आप दौड़ते

666
00:40:47,850 --> 00:40:51,370
डिस्क स्थान पर, विंडोज या मैक ओएस आप के लिए फ़ाइलों को हटाने शुरू कर देंगे.

667
00:40:51,370 --> 00:40:53,670
लेकिन अगर तुम वहाँ में कुछ खींचें, तो यह सभी सुरक्षित नहीं है.

668
00:40:53,670 --> 00:40:56,550
अपने रूममेट दोस्त या परिवार के सदस्य के लिए क्या करना है सभी डबल क्लिक करें और voila.

669
00:40:56,550 --> 00:40:59,720
सभी ढांचे के रूप में फ़ाइलों है कि आप को नष्ट करने की कोशिश की है.

670
00:40:59,720 --> 00:41:02,840
हम में से ज्यादातर के तो कम से कम पता है कि आप सही क्लिक करें या क्लिक करें नियंत्रण

671
00:41:02,840 --> 00:41:05,320
और खाली कचरा, या ऐसा कुछ.

672
00:41:05,320 --> 00:41:07,900
लेकिन फिर भी, कि काफी चाल नहीं क्या करता है.

673
00:41:07,900 --> 00:41:11,340
क्योंकि क्या होता है जब आप अपनी हार्ड ड्राइव पर एक फ़ाइल है

674
00:41:11,340 --> 00:41:14,590
कि कुछ शब्द दस्तावेज़ या कुछ JPEG का प्रतिनिधित्व करता है?

675
00:41:14,590 --> 00:41:18,820
और यह अपनी हार्ड ड्राइव का प्रतिनिधित्व करता है, और हम कहते हैं कि यहाँ इस ज़ुल्फ़ कि फ़ाइल का प्रतिनिधित्व करता है,

676
00:41:18,820 --> 00:41:21,640
और यह 0 और 1 की एक पूरी गुच्छा से बना है.

677
00:41:21,640 --> 00:41:25,470
क्या होता है जब आप trashcan या रीसायकल बिन कि फ़ाइल ही नहीं खींचें,

678
00:41:25,470 --> 00:41:30,390
लेकिन यह भी इसे खाली?

679
00:41:30,390 --> 00:41:32,820
कुछ भी नहीं की तरह. अब यह बिल्कुल कुछ भी नहीं है.

680
00:41:32,820 --> 00:41:37,630
अब यह सिर्फ कुछ भी नहीं है, क्योंकि एक छोटे से कुछ इस तालिका के रूप में होता है.

681
00:41:37,630 --> 00:41:41,170
तो वहाँ एक कंप्यूटर की स्मृति के अंदर डेटाबेस या तालिका के किसी तरह का है

682
00:41:41,170 --> 00:41:44,470
है कि अनिवार्य रूप से फ़ाइलों के नामों के लिए एक स्तंभ है,

683
00:41:44,470 --> 00:41:50,550
और फ़ाइल का स्थान है, जहां इस स्थान 123, सिर्फ एक यादृच्छिक संख्या हो सकता है के लिए 1 स्तंभ.

684
00:41:50,550 --> 00:41:58,270
तो हम x.jpg की तरह कुछ है, और 123 स्थान हो सकता है.

685
00:41:58,270 --> 00:42:02,870
और फिर क्या होता है, जब आप अपने कचरा खाली?

686
00:42:02,870 --> 00:42:06,720
यह दूर हो जाता है. लेकिन क्या दूर जाना नहीं है 0 और 1.

687
00:42:06,720 --> 00:42:09,690
>> तो क्या हुआ, है तो, कनेक्शन के लिए 4 pset?

688
00:42:09,690 --> 00:42:13,460
ठीक है,, 4 pset के साथ, सिर्फ इसलिए कि हम गलती से मिट गया है

689
00:42:13,460 --> 00:42:15,890
कॉम्पैक्ट फ़्लैश कार्ड है कि इन तस्वीरों के सभी था,

690
00:42:15,890 --> 00:42:18,710
या सिर्फ इसलिए कि यह बुरी किस्मत से भ्रष्ट बन गया है,

691
00:42:18,710 --> 00:42:21,170
इसका मतलब यह नहीं है कि 0 और 1 अभी भी वहाँ नहीं कर रहे हैं.

692
00:42:21,170 --> 00:42:23,920
हो सकता है कि उनमें से कुछ खो रहे हैं क्योंकि कुछ भ्रष्ट है

693
00:42:23,920 --> 00:42:26,530
समझ में आता है कि कुछ 0 1 और 1 बन गया में 0 बन गया.

694
00:42:26,530 --> 00:42:30,460
बुरी बातें छोटी गाड़ी सॉफ्टवेयर या दोषपूर्ण हार्डवेयर की वजह से हो सकता है.

695
00:42:30,460 --> 00:42:33,510
लेकिन उन बिट्स के कई, शायद उनमें से भी 100% अभी भी वहाँ हैं,

696
00:42:33,510 --> 00:42:38,330
यह सिर्फ है कि कंप्यूटर या कैमरे जहां JPEG 1 शुरू नहीं करता है

697
00:42:38,330 --> 00:42:41,660
और जहां JPEG 2 शुरू कर दिया है, लेकिन अगर तुम, प्रोग्रामर,

698
00:42:41,660 --> 00:42:45,800
प्रेमी की एक सा है, जहां उन JPEGs कर रहे हैं या वे कैसा दिखेगा के साथ पता है,

699
00:42:45,800 --> 00:42:49,570
आप 0 और 1 का विश्लेषण कर सकते हैं और कहते हैं, 'ओह. जेपीईजी. ओह, जेपीईजी.

700
00:42:49,570 --> 00:42:52,830
आप के लिए अनिवार्य रूप से एक बस के साथ एक कार्यक्रम में लिख सकते हैं या जबकि पाश

701
00:42:52,830 --> 00:42:56,100
कि उन फ़ाइलों में से हर एक के ठीक.

702
00:42:56,100 --> 00:42:59,360
तो सबक तो, शुरू करने के लिए "सुरक्षित" आपकी फ़ाइलों को मिटा

703
00:42:59,360 --> 00:43:01,720
अगर आप इस पूरी तरह से बचने के लिए करना चाहते हैं. हाँ?

704
00:43:01,720 --> 00:43:06,940
[छात्र सवाल है, unintelligible]

705
00:43:06,940 --> 00:43:11,150
>> और अधिक स्मृति की तुलना में आप पहले किया है -

706
00:43:11,150 --> 00:43:14,790
ओह! अच्छा सवाल है. क्यों तो, फिर, रद्दी खाली करने के बाद,

707
00:43:14,790 --> 00:43:18,300
आपके कंप्यूटर तुम बताओ कि तुम और अधिक मुक्त स्थान की तुलना में आप पहले किया था?

708
00:43:18,300 --> 00:43:22,450
संक्षेप में, क्योंकि यह झूठ बोल रहा है. तकनीकी तौर पर, आप और अधिक स्थान है.

709
00:43:22,450 --> 00:43:26,720
क्योंकि अब आप ने कहा है, तो आप अन्य सामान डाल कर सकते हैं, जहां कि फ़ाइल एक बार गया था,

710
00:43:26,720 --> 00:43:28,930
लेकिन इसका मतलब यह नहीं बिट्स चले जा रहे हैं,

711
00:43:28,930 --> 00:43:33,070
और इसका मतलब यह नहीं बिट सभी 0 जा रहा बदल रहे हैं, उदाहरण के लिए अपनी सुरक्षा के लिए,.

712
00:43:33,070 --> 00:43:37,520
इसके विपरीत, यदि आप "सुरक्षित" मिटा फाइलें, या शारीरिक रूप डिवाइस को नष्ट करने के लिए,

713
00:43:37,520 --> 00:43:40,810
कि वास्तव में एक ही रास्ता है, कभी कभी कि चारों ओर.

714
00:43:40,810 --> 00:43:45,300
तो हम क्यों कि अर्द्ध डरावना नोट पर नहीं छोड़ करते हैं, और हम आप सोमवार को देखेंगे.

715
00:43:45,300 --> 00:43:52,810
CS50.TV