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

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

3
00:00:04,860 --> 00:00:07,260
[यह CS50 है. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> यह CS50, 5 सप्ताह है.

5
00:00:09,740 --> 00:00:12,900
आज और इस सप्ताह हम फोरेंसिक की दुनिया का एक छोटा सा परिचय

6
00:00:12,900 --> 00:00:14,850
इस समस्या के संदर्भ में 4 सेट.

7
00:00:14,850 --> 00:00:18,480
आज एक संक्षिप्त व्याख्यान हो सकता है क्योंकि वहाँ यहाँ में एक विशेष घटना के बाद होगा.

8
00:00:18,480 --> 00:00:21,940
तो हम एक तिरछी नज़र रखना और दोनों छात्रों और एक जैसे माता पिता को आज तंग

9
00:00:21,940 --> 00:00:24,600
चीजें हैं कि क्षितिज पर हैं में से कुछ के साथ.

10
00:00:24,600 --> 00:00:29,050
>> उनमें से, सोमवार के रूप में, आप कुछ और सहपाठियों होगा.

11
00:00:29,050 --> 00:00:32,980
EDX, हार्वर्ड और एमआईटी OpenCourseWare और अधिक के लिए नए ऑनलाइन पहल,

12
00:00:32,980 --> 00:00:36,730
सोमवार, जो सोमवार आने का मतलब पर हार्वर्ड परिसर पर शुरू

13
00:00:36,730 --> 00:00:40,930
आप, पिछली गणना के रूप में है, 86,000 अतिरिक्त सहपाठियों

14
00:00:40,930 --> 00:00:43,680
जो CS50 व्याख्यान और वर्गों के साथ साथ पालन किया जाएगा

15
00:00:43,680 --> 00:00:45,890
और walkthroughs और समस्या सेट.

16
00:00:45,890 --> 00:00:51,870
और इस के भाग के रूप में, आप CS50 और अब CS50x के उद्घाटन वर्ग का सदस्य बन जाएगा.

17
00:00:51,870 --> 00:00:56,150
इस के हिस्से के रूप में अब एहसास है कि वहाँ कुछ upsides के रूप में अच्छी तरह से हो जाएगा.

18
00:00:56,150 --> 00:01:00,620
छात्रों की भारी संख्या के लिए इस बात के लिए तैयार हो,

19
00:01:00,620 --> 00:01:03,820
इतना ही कहना है कि भले ही हम 108 TFS और सीए,

20
00:01:03,820 --> 00:01:07,560
यह काफी अच्छा छात्र - शिक्षक अनुपात में एक बार हम 80,000 छात्रों के हिट नहीं है.

21
00:01:07,560 --> 00:01:09,830
हम इतने सारे समस्या ग्रेडिंग सेट मैन्युअल रूप से नहीं जा रहे हैं,

22
00:01:09,830 --> 00:01:13,050
तो समस्या सेट में इस सप्ताह शुरू CS50 जांच हो जाएगा,

23
00:01:13,050 --> 00:01:15,410
जो करने के लिए एक कमांड लाइन उपयोगिता उपकरण के भीतर जा रहा है

24
00:01:15,410 --> 00:01:17,880
है कि आप एक बार आप इसे बाद में इस सप्ताह के अंत में अद्यतन करने के लिए मिल जाएगा.

25
00:01:17,880 --> 00:01:21,030
आप के लिए अपने खुद के pset पर एक आदेश, check50, चलाने के लिए सक्षम हो जाएगा,

26
00:01:21,030 --> 00:01:24,770
और आप त्वरित प्रतिक्रिया के रूप में मिलता है कि अपने कार्यक्रम के सही या गलत है

27
00:01:24,770 --> 00:01:27,980
विभिन्न डिजाइन विनिर्देशों के अनुसार कि हम प्रदान की है.

28
00:01:27,980 --> 00:01:30,310
समस्या सेट विनिर्देश में उस पर और अधिक.

29
00:01:30,310 --> 00:01:34,220
CS50x सहपाठियों के रूप में अच्छी तरह से उपयोग किया जाएगा.

30
00:01:34,220 --> 00:01:36,170
>> समस्या 4 सेट फोरेंसिक सब के बारे में है,

31
00:01:36,170 --> 00:01:38,630
और इस pset वास्तव में कुछ सामान वास्तविक जीवन से प्रेरित था

32
00:01:38,630 --> 00:01:41,210
जब मैं स्कूल में था स्नातक मैं जिससे थोड़ी देर के लिए interned

33
00:01:41,210 --> 00:01:45,270
मिडिलसेक्स काउंटी जिला अटार्नी कार्यालय के साथ फोरेंसिक काम कर रही

34
00:01:45,270 --> 00:01:47,660
उनके नेतृत्व फोरेंसिक अन्वेषक के साथ.

35
00:01:47,660 --> 00:01:50,280
क्या होता है इस राशि के रूप में मुझे लगता है कि मैं पिछले कुछ हफ्तों उल्लेख किया है,

36
00:01:50,280 --> 00:01:52,720
मास राज्य पुलिस या दूसरों में आ जाएगा,

37
00:01:52,720 --> 00:01:56,150
वे हार्ड ड्राइव और सीडी और फ्लॉपी डिस्क और इस तरह की तरह बातें छोड़ जाएगा,

38
00:01:56,150 --> 00:01:58,770
और तो फोरेंसिक कार्यालय के लक्ष्य पता लगाने के लिए किया गया था

39
00:01:58,770 --> 00:02:01,470
कि क्या वहाँ था या किसी तरह के सबूत नहीं था.

40
00:02:01,470 --> 00:02:04,730
यह विशेष अन्वेषण यूनिट था, तो यह सफेद कॉलर अपराध था.

41
00:02:04,730 --> 00:02:10,949
यह अपराधों के अधिक परेशान प्रकार, डिजिटल मीडिया के किसी तरह का कुछ भी शामिल था.

42
00:02:10,949 --> 00:02:16,450
यह पता चला है कि, नहीं है कि कई लोगों को एक ईमेल लिखने के लिए कह "मैंने ऐसा किया था."

43
00:02:16,450 --> 00:02:20,490
तो अक्सर, इन फोरेंसिक खोजों कि सभी ज्यादा फल बारी नहीं किया था,

44
00:02:20,490 --> 00:02:22,820
लेकिन कभी कभी लोगों को ऐसी ईमेल लिखना होगा.

45
00:02:22,820 --> 00:02:25,240
तो कभी कभी, के प्रयासों को पुरस्कृत किया गया.

46
00:02:25,240 --> 00:02:31,210
>> लेकिन नेतृत्व करने के लिए इस फोरेंसिक pset, हम pset4 में शुरू हो ग्राफिक्स के एक सा.

47
00:02:31,210 --> 00:02:35,410
आप शायद इन बातों के लिए दी ले - इन दिनों - JPEGs, GIFs, और इस तरह.

48
00:02:35,410 --> 00:02:38,320
लेकिन अगर आप वास्तव में इसके बारे में सोचते हैं, एक छवि, ज्यादा रोब चेहरे की तरह,

49
00:02:38,320 --> 00:02:41,270
डॉट्स या पिक्सल के एक दृश्य के रूप में मॉडलिंग की जा सकता है.

50
00:02:41,270 --> 00:02:43,380
रोब चेहरे के मामले में रंगों के सभी प्रकार है,

51
00:02:43,380 --> 00:02:46,760
और हम व्यक्ति डॉट्स, अन्यथा पिक्सेल के रूप में जाना जाता है देखने के लिए शुरू कर दिया है,

52
00:02:46,760 --> 00:02:48,610
एक बार हम ज़ूम इन करने के लिए शुरू कर दिया

53
00:02:48,610 --> 00:02:54,660
लेकिन अगर हम दुनिया के एक बिट को सरल बनाने और बस का कहना है कि इस काले और सफेद में रोब है,

54
00:02:54,660 --> 00:02:57,490
काले और सफेद का प्रतिनिधित्व करते हैं, हम सिर्फ द्विआधारी का उपयोग कर सकते हैं.

55
00:02:57,490 --> 00:03:01,660
और अगर हम द्विआधारी का उपयोग करने के लिए जा रहे हैं, 1 या 0, हम इस एक ही छवि को व्यक्त कर सकते हैं

56
00:03:01,660 --> 00:03:06,140
रोब बिट्स की इस पद्धति के साथ मुस्कुराते चेहरे के.

57
00:03:06,140 --> 00:03:12,100
11000011 सफेद, सफेद, काले, काले, काले, काले, सफेद, सफेद का प्रतिनिधित्व करता है.

58
00:03:12,100 --> 00:03:16,150
और इसलिए यह एक बड़ी छलांग तो नहीं है रंगीन फोटो के बारे में बात शुरू करने के लिए,

59
00:03:16,150 --> 00:03:18,600
चीज़ें है कि आप फेसबुक पर देख सकते हैं या एक डिजिटल कैमरा के साथ ले लेनी चाहिए.

60
00:03:18,600 --> 00:03:21,410
लेकिन निश्चित रूप से जब यह रंग करने के लिए आता है, तो आप अधिक बिट्स की जरूरत है.

61
00:03:21,410 --> 00:03:25,690
और तस्वीरों की दुनिया में काफी आम 1-बिट रंग का उपयोग नहीं है,

62
00:03:25,690 --> 00:03:29,560
के रूप में यह पता चलता है, लेकिन 24 बिट रंग, जहाँ आप वास्तव में रंगों के लाखों मिलता है.

63
00:03:29,560 --> 00:03:32,250
इसलिए मामले में के रूप में जब हम पर रोब आंख में तेजी से बढ़ी है,

64
00:03:32,250 --> 00:03:36,370
कि अलग रंगीन संभावनाओं के लाखों के किसी भी नंबर था.

65
00:03:36,370 --> 00:03:39,040
तो हम समस्या 4 सेट के रूप में के रूप में अच्छी तरह से walkthrough में इस परिचय देंगे,

66
00:03:39,040 --> 00:03:43,370
जो आज सामान्य 2:30 के बजाय 3:30 पर शुक्रवार को यहाँ व्याख्यान की वजह से होगा.

67
00:03:43,370 --> 00:03:46,620
लेकिन हमेशा की तरह कल के रूप में वीडियो ऑनलाइन हो जाएगा.

68
00:03:46,620 --> 00:03:48,820
>> हम भी आप अन्य फ़ाइल स्वरूप मिलवा देंगे.

69
00:03:48,820 --> 00:03:51,270
यह जानबूझकर पहले डराना देखने का मतलब है,

70
00:03:51,270 --> 00:03:55,670
लेकिन यह सिर्फ एक सी struct के लिए कुछ दस्तावेज है.

71
00:03:55,670 --> 00:03:58,940
यह पता चला है कि माइक्रोसॉफ्ट साल पहले इस प्रारूप को लोकप्रिय बनाने में मदद

72
00:03:58,940 --> 00:04:05,150
बिटमैप फ़ाइल स्वरूप, BMP, और यह एक सुपर सरल, रंगीन आलेखीय फाइल प्रारूप था बुलाया

73
00:04:05,150 --> 00:04:10,150
है कि कुछ समय के लिए इस्तेमाल किया गया था और डेस्कटॉप पर वॉलपेपर के लिए कभी भी.

74
00:04:10,150 --> 00:04:14,760
यदि आप Windows XP और रोलिंग पहाड़ियों और नीले आकाश के लिए वापस लगता है,

75
00:04:14,760 --> 00:04:17,170
कि आम तौर पर एक bmp या बिटमैप छवि था.

76
00:04:17,170 --> 00:04:19,959
बिटमैप्स हमारे लिए मजाक कर रहे हैं क्योंकि वे थोड़ा और अधिक जटिलता है.

77
00:04:19,959 --> 00:04:22,610
यह 0s और 1s के इस ग्रिड के रूप में सरल रूप में काफी नहीं है.

78
00:04:22,610 --> 00:04:27,510
इसके बजाय, आप एक फ़ाइल के शुरू में एक शीर्षक की तरह बातें है.

79
00:04:27,510 --> 00:04:31,990
तो दूसरे शब्दों में, एक bmp फ़ाइल के अंदर में 0s और 1s की एक पूरी गुच्छा है,

80
00:04:31,990 --> 00:04:34,910
लेकिन वहाँ कुछ अतिरिक्त और वहाँ में 0s 1s है.

81
00:04:34,910 --> 00:04:38,220
और यह पता चला है कि हम क्या शायद के लिए साल के लिए दी ले लिया है -

82
00:04:38,220 --> 00:04:45,170
डॉक्टर या. xls या एमपी 3, जैसे फ़ाइल स्वरूपों mp4, जो फ़ाइल स्वरूपों

83
00:04:45,170 --> 00:04:48,480
कि आप से परिचित हैं - यह भी क्या करता है एक फ़ाइल स्वरूप होने का मतलब है,

84
00:04:48,480 --> 00:04:52,480
क्योंकि दिन के अंत में इन फ़ाइलों के सभी हम सिर्फ 0s और 1s है का उपयोग करें.

85
00:04:52,480 --> 00:04:56,810
और शायद उन 0s और 1s ASCII के माध्यम से एबीसी या तरह का प्रतिनिधित्व करते हैं,

86
00:04:56,810 --> 00:04:58,820
लेकिन दिन के अंत में, यह अभी भी सिर्फ 0s और 1s.

87
00:04:58,820 --> 00:05:02,100
तो मनुष्य के बस कभी - कभी एक नया फ़ाइल स्वरूप का आविष्कार करने का फैसला

88
00:05:02,100 --> 00:05:06,420
जहां वे प्रमाण के अनुसार करना बिट्स के पैटर्न वास्तव में क्या मतलब होगा.

89
00:05:06,420 --> 00:05:09,220
और इस मामले में, लोग जो बिटमैप फ़ाइल प्रारूप तैयार

90
00:05:09,220 --> 00:05:15,620
ने कहा कि एक बिटमैप फ़ाइल में बहुत पहली बाइट के रूप में वहाँ ऑफसेट 0 द्वारा चिह्नित,

91
00:05:15,620 --> 00:05:18,940
वहाँ कुछ cryptically नाम चर बुलाया bfType होने जा रहा है,

92
00:05:18,940 --> 00:05:23,080
जो सिर्फ बिटमैप फ़ाइल प्रकार के लिए खड़ा है, बिटमैप फ़ाइल के प्रकार क्या है.

93
00:05:23,080 --> 00:05:27,700
तुम शायद दूसरी पंक्ति है कि 2 ऑफसेट, बाइट संख्या 2 से अनुमान कर सकते हैं,

94
00:05:27,700 --> 00:05:33,740
0s और 1s के एक पैटर्न है कि क्या प्रतिनिधित्व करता है? कुछ का आकार.

95
00:05:33,740 --> 00:05:35,310
और यह वहाँ से चला जाता है.

96
00:05:35,310 --> 00:05:37,410
तो समस्या 4 सेट में, आप इन बातों में से कुछ के माध्यम से चला गया हो जाएगा.

97
00:05:37,410 --> 00:05:39,520
हम अंत नहीं है उन सभी के बारे में देखभाल.

98
00:05:39,520 --> 00:05:47,510
नोटिस लेकिन यह 54 बाइट के आसपास दिलचस्प पाने के लिए शुरू: rgbtBlue, हरे और लाल.

99
00:05:47,510 --> 00:05:52,110
यदि आपने कभी सुना है परिचित करा आरजीबी - लाल, हरे, नीले - यह है कि एक संदर्भ है

100
00:05:52,110 --> 00:05:54,610
क्योंकि यह पता चला है आप इंद्रधनुष के सभी रंगों पेंट कर सकते हैं

101
00:05:54,610 --> 00:05:58,180
लाल और नीले और हरे रंग के कुछ संयोजन के साथ.

102
00:05:58,180 --> 00:06:03,320
और वास्तव में, कमरे में माता - पिता को जल्द से जल्द प्रोजेक्टर के कुछ याद हो सकता है.

103
00:06:03,320 --> 00:06:05,890
इन दिनों, तुम सिर्फ एक उज्ज्वल प्रकाश एक लेंस के बाहर आने को देखने के लिए,

104
00:06:05,890 --> 00:06:09,800
लेकिन दिन में वापस आप लाल लेंस, नीले लेंस, और हरे रंग लेंस था,

105
00:06:09,800 --> 00:06:13,380
और साथ में वे एक स्क्रीन के उद्देश्य से और एक रंगीन चित्र का गठन किया है.

106
00:06:13,380 --> 00:06:16,270
और अक्सर, मध्य विद्यालयों और उच्च विद्यालयों उन लेंस

107
00:06:16,270 --> 00:06:19,720
कभी तो थोड़ा तिरछा है, ताकि आप डबल या ट्रिपल छवियों को देखने की तरह थे.

108
00:06:19,720 --> 00:06:24,100
लेकिन उस विचार था. आप लाल और हरे और नीले प्रकाश एक चित्र चित्र था.

109
00:06:24,100 --> 00:06:26,590
और कि एक ही सिद्धांत कंप्यूटर में प्रयोग किया जाता है.

110
00:06:26,590 --> 00:06:30,230
>> तो आप के लिए तो समस्या में चुनौतियों के बीच 4 सेट करने के लिए कुछ बातें हो जा रहे हैं.

111
00:06:30,230 --> 00:06:34,800
एक करने के लिए वास्तव में एक छवि का आकार है, 0s ​​और 1s के एक पैटर्न में ले,

112
00:06:34,800 --> 00:06:40,200
0s और 1s की हिस्सा इस तरह एक संरचना में क्या प्रतिनिधित्व करते हैं बाहर आंकड़ा,

113
00:06:40,200 --> 00:06:43,630
और फिर बाहर आंकड़ा कैसे पिक्सल को दोहराने के लिए - लाल, नीले, हरे -

114
00:06:43,630 --> 00:06:46,660
अंदर इतना है कि, जब एक तस्वीर इस तरह शुरू में लग रहा है

115
00:06:46,660 --> 00:06:49,210
यह इस तरह है कि बाद के बजाय लग सकता है.

116
00:06:49,210 --> 00:06:53,640
अन्य चुनौतियों के बीच भी हो सकता है कि आप एक फोरेंसिक छवि सौंप दिया जाएगा जा रहा है

117
00:06:53,640 --> 00:06:56,030
एक डिजिटल कैमरे से एक वास्तविक फ़ाइल का.

118
00:06:56,030 --> 00:06:58,960
और कि कैमरे पर, एक बार एक समय पर, तस्वीरों की एक पूरी गुच्छा थे.

119
00:06:58,960 --> 00:07:03,760
समस्या हम गलती से मिट गया है या छवि किसी तरह भ्रष्ट था.

120
00:07:03,760 --> 00:07:05,750
बुरी बातें डिजिटल कैमरों के साथ होता है.

121
00:07:05,750 --> 00:07:09,150
और इसलिए हम जल्दी से आप के लिए है कि कार्ड के 0s और 1s बंद की नकल की है,

122
00:07:09,150 --> 00:07:13,610
एक बड़ी फ़ाइल में उन सभी को बचा लिया, और फिर हम उन्हें समस्या में हाथ होगा 4 सेट

123
00:07:13,610 --> 00:07:19,320
इतनी है कि आप सी में एक कार्यक्रम के साथ जो उन JPEGs के सभी को ठीक करने के लिए लिख सकते हैं, आदर्श.

124
00:07:19,320 --> 00:07:23,330
और यह पता चला कि JPEGs, भले ही वे एक जटिल फ़ाइल स्वरूप के कुछ कर रहे हैं -

125
00:07:23,330 --> 00:07:26,360
वे इस मुस्कुराते हुए चेहरे से बहुत जटिल कर रहे हैं -

126
00:07:26,360 --> 00:07:31,160
यह पता चला है कि हर JPEG 0s और 1s के एक ही पैटर्न के साथ शुरू होता है.

127
00:07:31,160 --> 00:07:35,630
तो का उपयोग करते हुए, अंततः, एक समय या पाश या इसी तरह के लिए एक पाश,

128
00:07:35,630 --> 00:07:38,880
आप सभी 0s और 1s पर इस फोरेंसिक छवि में पुनरावृति कर सकते हैं,

129
00:07:38,880 --> 00:07:43,150
और हर बार जब आप विशेष पैटर्न है कि समस्या सेट विनिर्देश में परिभाषित किया गया है,

130
00:07:43,150 --> 00:07:47,880
आप यहाँ लगता है बहुत अधिक संभावना के साथ है, एक JPEG की शुरुआत कर सकते हैं.

131
00:07:47,880 --> 00:07:51,230
और जैसे ही आप एक ही पैटर्न बाइट्स की कुछ संख्या पाते हैं

132
00:07:51,230 --> 00:07:55,430
या किलोबाइट्स या मेगाबाइट्स बाद, आप यहाँ मान सकते हैं एक दूसरे JPEG है,

133
00:07:55,430 --> 00:07:57,380
तस्वीर मैं पहले एक के बाद लिया.

134
00:07:57,380 --> 00:08:01,370
मुझे कि पहली फ़ाइल पढ़ना बंद करो, इस नए लेखन शुरू,

135
00:08:01,370 --> 00:08:06,310
और pset4 के लिए अपने कार्यक्रम के उत्पादन के रूप में कई के रूप में 50 JPEGs होने जा रहा है.

136
00:08:06,310 --> 00:08:09,270
और अगर यह 50 JPEGs नहीं है, आप एक पाश के एक सा है.

137
00:08:09,270 --> 00:08:12,490
यदि आप JPEGs की एक अनंत संख्या है, तो आप एक अनंत लूप है.

138
00:08:12,490 --> 00:08:14,910
तो वह भी काफी एक आम का मामला हो जाएगा.

139
00:08:14,910 --> 00:08:16,600
तो है कि क्या क्षितिज पर है.

140
00:08:16,600 --> 00:08:21,310
>> हमारे पीछे 0 क्विज, मेरे प्रति ईमेल पता है कि सदा ही लोगों को, जो दोनों खुश हैं,

141
00:08:21,310 --> 00:08:23,640
तटस्थ, और प्रश्नोत्तरी चारों ओर में दुखी 0 समय की तरह.

142
00:08:23,640 --> 00:08:26,800
और कृपया मुझे बाहर तक पहुँचने के लिए, सिर TF Zamyla, अपने खुद के TF करते हैं,

143
00:08:26,800 --> 00:08:31,180
या सीए के एक है कि आप जानते हैं कि अगर आप चर्चा करना चाहते हैं कैसे चीजें गया.

144
00:08:31,180 --> 00:08:35,539
>> ऐसा करने के लिए माता पिता के कमरे में यहाँ प्रभावित, CS50 पुस्तकालय क्या है?

145
00:08:36,429 --> 00:08:40,390
[हँसी] अच्छा काम किया.

146
00:08:40,390 --> 00:08:48,340
CS50 पुस्तकालय क्या है? हाँ. >> [छात्र] यह कोड का एक सेट पूर्व लिखित [अश्राव्य]

147
00:08:48,340 --> 00:08:49,750
ठीक है, अच्छा है.

148
00:08:49,750 --> 00:08:53,240
यह कोड का एक सेट पूर्व लिखित कि हम स्टाफ लिखा है, हम आप के लिए प्रदान करते हैं,

149
00:08:53,240 --> 00:08:55,030
कि कुछ आम कार्यक्षमता प्रदान करता है,

150
00:08:55,030 --> 00:08:59,020
मुझे एक स्ट्रिंग की तरह सामान, मुझे पाने के लिए एक int सभी कार्य करता है कि यहाँ सूचीबद्ध हैं.

151
00:08:59,020 --> 00:09:02,260
>> अब शुरू, हम वास्तव में इन प्रशिक्षण के पहियों से दूर ले शुरू करते हैं.

152
00:09:02,260 --> 00:09:05,050
हम करने के लिए आप से दूर एक स्ट्रिंग लेने के लिए शुरू करने के लिए जा रहे हैं,

153
00:09:05,050 --> 00:09:08,870
जो याद क्या वास्तविक डेटा प्रकार के लिए सिर्फ एक पर्याय था? >> [कई छात्रों] चार *.

154
00:09:08,870 --> 00:09:12,730
चार *. माता पिता के लिए, कि शायद [बनाता whooshing ध्वनि] था. यह अच्छा है.

155
00:09:12,730 --> 00:09:17,550
चार * हम सभी को और अधिक स्क्रीन पर देखने के रूप में हम अपनी शब्दावली से तार हटाने शुरू करेंगे,

156
00:09:17,550 --> 00:09:19,730
कम से कम जब यह वास्तव में कोड लिखने के लिए आता है.

157
00:09:19,730 --> 00:09:22,840
इसी तरह, हम इन कार्यों में से कुछ का उपयोग करने के लिए ज्यादा के रूप में बंद कर देंगे

158
00:09:22,840 --> 00:09:25,280
क्योंकि हमारे कार्यक्रमों को और अधिक परिष्कृत हो जा रहे हैं.

159
00:09:25,280 --> 00:09:28,480
के बजाय सिर्फ प्रोग्राम लिखने कि शीघ्र पलक के साथ वहाँ बैठो,

160
00:09:28,480 --> 00:09:31,870
उपयोगकर्ता के लिए इंतज़ार कर में कुछ लिखें, तो आप कहीं और से अपनी जानकारी मिल जाएगा.

161
00:09:31,870 --> 00:09:35,490
उदाहरण के लिए, आप उन्हें स्थानीय हार्ड ड्राइव पर बिट्स की एक श्रृंखला से मिल जाएगा.

162
00:09:35,490 --> 00:09:38,580
आप के बजाय एक नेटवर्क कनेक्शन से भविष्य में उन्हें मिल जाएगा,

163
00:09:38,580 --> 00:09:40,230
कहीं कुछ वेबसाइट नहीं है.

164
00:09:40,230 --> 00:09:44,110
>> इसलिए पहली बार के लिए वापस इस परत छील और CS50 उपकरण खींच

165
00:09:44,110 --> 00:09:49,010
और इस cs50.h नामक फाइल है, जो # सप्ताह के लिए किया गया है सहित,

166
00:09:49,010 --> 00:09:51,140
लेकिन वास्तव में देखने के लिए क्या इस के अंदर है.

167
00:09:51,140 --> 00:09:54,430
नीले रंग में फ़ाइल के ऊपर टिप्पणी की एक पूरी गुच्छा है:

168
00:09:54,430 --> 00:09:57,050
वारंटी जानकारी और लाइसेंस.

169
00:09:57,050 --> 00:09:59,050
इस सॉफ्टवेयर में एक आम प्रतिमान की तरह है

170
00:09:59,050 --> 00:10:01,580
क्योंकि सॉफ्टवेयर का एक बहुत इन दिनों है क्या खुला स्रोत कहा जाता है,

171
00:10:01,580 --> 00:10:05,220
जिसका मतलब है कि किसी को कोड लिखा है और यह आज़ादी से उपलब्ध कराया

172
00:10:05,220 --> 00:10:10,470
नहीं बस चलाने के लिए उपयोग करने के लिए है, लेकिन वास्तव में पढ़ सकते हैं और बदल और अपने खुद के काम में एकीकृत.

173
00:10:10,470 --> 00:10:14,660
तो यह है कि क्या आप का उपयोग किया गया है, हालांकि एक बहुत छोटे रूप में खुला स्रोत सॉफ्टवेयर,.

174
00:10:14,660 --> 00:10:18,560
अगर मैं टिप्पणी पिछले नीचे स्क्रॉल, हालांकि, हम कुछ अधिक परिचित बातें देखना शुरू करेंगे.

175
00:10:18,560 --> 00:10:25,010
यहाँ शीर्ष कि cs50.h फ़ाइल हेडर फाइल की एक पूरी गुच्छा शामिल सूचना.

176
00:10:25,010 --> 00:10:28,560
इनमें से अधिकांश, हम पहले नहीं देखा है, लेकिन एक परिचित है.

177
00:10:28,560 --> 00:10:32,270
इनमें से कौन, हम संक्षेप में यद्यपि देखा है, इस प्रकार अब तक? >> [छात्र] मानक पुस्तकालय.

178
00:10:32,270 --> 00:10:35,810
हाँ, मानक पुस्तकालय. stdlib.h malloc है.

179
00:10:35,810 --> 00:10:38,320
एक बार जब हम गतिशील स्मृति आवंटन के बारे में बात करना शुरू कर दिया,

180
00:10:38,320 --> 00:10:41,650
जो हम वापस करने के लिए अगले सप्ताह के रूप में अच्छी तरह से आ जाएगा, हम उस फ़ाइल सहित शुरू कर दिया.

181
00:10:41,650 --> 00:10:46,640
यह पता चला है कि वास्तव में bool और सच्चे और झूठे सी दर असल में मौजूद नहीं है

182
00:10:46,640 --> 00:10:49,440
जब तक आप इस फाइल को यहाँ शामिल हैं.

183
00:10:49,440 --> 00:10:52,710
हम सप्ताह के लिए stdbool.h शामिल किया गया है

184
00:10:52,710 --> 00:10:55,620
इतना है कि आप एक bool, सही है या गलत. की धारणा का उपयोग कर सकते हैं

185
00:10:55,620 --> 00:10:58,620
इस के बिना, आप यह नकली की तरह है और एक int का उपयोग करना चाहते हैं

186
00:10:58,620 --> 00:11:02,610
और बस मनमाने ढंग से लगता है कि 0 झूठी है और 1 सच है.

187
00:11:02,610 --> 00:11:07,150
अगर हम आगे नीचे स्क्रॉल, यहाँ एक स्ट्रिंग की हमारी परिभाषा है.

188
00:11:07,150 --> 00:11:11,390
यह पता चला है, जैसा कि हम पहले कहा है, कि जहां इस स्टार है वास्तव में कोई फर्क नहीं पड़ता.

189
00:11:11,390 --> 00:11:13,720
तुम भी अंतरिक्ष के आसपास हो सकता है.

190
00:11:13,720 --> 00:11:16,740
हम इस सेमेस्टर के रूप में किया गया है इसे बढ़ावा देने के लिए स्पष्ट कर दूं

191
00:11:16,740 --> 00:11:18,620
कि सितारा प्रकार के साथ क्या करना है,

192
00:11:18,620 --> 00:11:21,700
लेकिन बस के रूप में आम का एहसास है, अगर छोटे से अधिक एक आम नहीं है,

193
00:11:21,700 --> 00:11:24,430
यह वहाँ रखा है, लेकिन कार्यात्मक यह एक ही बात है.

194
00:11:24,430 --> 00:11:27,720
लेकिन अब अगर हम नीचे आगे पढ़ने के लिए, चलो GetInt पर एक नज़र रखना

195
00:11:27,720 --> 00:11:32,190
क्योंकि हम इस सेमेस्टर से पहले कुछ और है कि शायद पहली बार इस्तेमाल किया.

196
00:11:32,190 --> 00:11:37,440
यहाँ GetInt है. यह क्या है? >> [छात्र] एक प्रोटोटाइप. >> यह सिर्फ एक प्रोटोटाइप है.

197
00:11:37,440 --> 00:11:41,410
अक्सर, हम हमारे में से सबसे ऊपर है पर प्रोटोटाइप डाल दिया है ग फ़ाइलों.

198
00:11:41,410 --> 00:11:46,690
लेकिन आप भी हेडर फाइलें, ज. फ़ाइलों में यह यहाँ एक तरह प्रोटोटाइप डाल सकते हैं

199
00:11:46,690 --> 00:11:50,840
इतना है कि जब आप कुछ कार्यों लिखना है कि आप अन्य लोगों के लिए उपयोग करने में सक्षम होना चाहता हूँ,

200
00:11:50,840 --> 00:11:53,550
जो वास्तव में CS50 पुस्तकालय के साथ मामला है,

201
00:11:53,550 --> 00:11:57,040
तुम नहीं केवल cs50.c की तरह कुछ में अपने कार्यों को लागू करने के लिए,

202
00:11:57,040 --> 00:12:02,790
आप भी उस फ़ाइल के शीर्ष पर नहीं है, लेकिन एक हैडर फ़ाइल के शीर्ष पर प्रोटोटाइप डाल दिया.

203
00:12:02,790 --> 00:12:07,170
तब उस हैडर फ़ाइल मित्रों और सहकर्मियों क्या शामिल

204
00:12:07,170 --> 00:12:09,760
# अपने खुद के कोड में शामिल हैं.

205
00:12:09,760 --> 00:12:12,210
यह सब समय तो, आप इन प्रोटोटाइप के सभी शामिल है,

206
00:12:12,210 --> 00:12:16,580
प्रभावी ढंग से अपनी फ़ाइल के शीर्ष पर है, लेकिन इस तरह के तंत्र शामिल है,

207
00:12:16,580 --> 00:12:20,070
जो अपने आप में अनिवार्य रूप से प्रतियां और चिपकाता इस फ़ाइल.

208
00:12:20,070 --> 00:12:23,070
यहाँ कुछ काफी विस्तृत दस्तावेज है.

209
00:12:23,070 --> 00:12:25,640
हम बहुत ज्यादा के लिए दी गई है कि GetInt एक int हो जाता है ले लिया है,

210
00:12:25,640 --> 00:12:27,640
लेकिन यह निकलता है वहाँ कुछ कोने मामलों.

211
00:12:27,640 --> 00:12:31,810
क्या एक संख्या है कि जिस तरह से बहुत बड़ा है में उपयोगकर्ता प्रकार अगर, एक quintillion,

212
00:12:31,810 --> 00:12:35,490
कि सिर्फ एक int के अंदर फिट नहीं कर सकते? अपेक्षित व्यवहार क्या है?

213
00:12:35,490 --> 00:12:38,020
आदर्श रूप में, यह उम्मीद के मुताबिक है.

214
00:12:38,020 --> 00:12:40,280
तो इस मामले में, यदि आप वास्तव में ठीक प्रिंट पढ़ा,

215
00:12:40,280 --> 00:12:44,500
आप वास्तव में है कि अगर लाइन पढ़ा नहीं जा सकता है, यह रिटर्न INT_MAX देखेंगे.

216
00:12:44,500 --> 00:12:48,320
हम इस बारे में कभी बात नहीं की है, लेकिन अपने पूंजीकरण के आधार पर, यह क्या है शायद?

217
00:12:48,320 --> 00:12:50,640
[छात्र] एक निरंतर. >> यह एक निरंतर है.

218
00:12:50,640 --> 00:12:54,770
यह कुछ विशेष निरंतर है कि शायद एक उन हेडर फाइल के रूप में घोषित है

219
00:12:54,770 --> 00:13:00,090
कि फ़ाइल में उच्च है, और शायद INT_MAX लगभग 2 अरब की तरह कुछ है,

220
00:13:00,090 --> 00:13:04,990
जा रहा है कि क्योंकि हम किसी भी तरह कि कुछ दर्शाता है की जरूरत विचार गलत हो गया था,

221
00:13:04,990 --> 00:13:10,700
हम, हाँ, हमारे निपटान पर चार अरब संख्या: अप करने के लिए 2 अरब अरब -2, दे या ले.

222
00:13:10,700 --> 00:13:14,710
खैर, क्या प्रोग्रामिंग में आम है तुम सिर्फ एक उन लोगों की संख्या की चोरी,

223
00:13:14,710 --> 00:13:18,920
0 हो सकता है, शायद 2 अरब, -2 शायद अरब,

224
00:13:18,920 --> 00:13:23,280
ताकि आप अपने संभावित मूल्यों का खर्च इतना है कि आप दुनिया के लिए प्रतिबद्ध कर सकते हैं

225
00:13:23,280 --> 00:13:26,820
कि अगर कुछ गलत हो जाता है, तो मैं इस सुपर बड़ा मूल्य वापसी करेंगे.

226
00:13:26,820 --> 00:13:31,030
लेकिन आप उपयोगकर्ता 234 की तरह गुप्त कुछ टाइप नहीं करना चाहते ..., एक बहुत बड़ी संख्या है.

227
00:13:31,030 --> 00:13:34,060
बदले में आप इसे सामान्यीकरण के रूप में एक निरंतर.

228
00:13:34,060 --> 00:13:38,060
तो सच में, अगर आप गुदा जा रहे थे कि पिछले कुछ हफ्तों से, किसी भी समय आप GetInt कहा जाता है,

229
00:13:38,060 --> 00:13:42,900
आप एक साथ किया गया है की जाँच करना चाहिए अगर हालत INT_MAX में उपयोगकर्ता प्रकार किया,

230
00:13:42,900 --> 00:13:46,590
या, और अधिक विशेष रूप से, GetInt वापसी INT_MAX किया था, क्योंकि अगर यह किया है,

231
00:13:46,590 --> 00:13:51,830
इसका मतलब है कि वास्तव में वे यह नहीं लिख था. इस मामले में कुछ गलत हो गया था.

232
00:13:51,830 --> 00:13:56,080
तो यह है कि क्या आम तौर पर एक प्रहरी मूल्य है, जो सिर्फ विशेष अर्थ के रूप में जाना जाता है.

233
00:13:56,080 --> 00:13:58,120
>> अब चलो. ग फ़ाइल में बारी.

234
00:13:58,120 --> 00:14:01,340
सी फ़ाइल उपकरण में कुछ समय के लिए ही अस्तित्व में है.

235
00:14:01,340 --> 00:14:06,840
और वास्तव में, यह उपकरण पूर्व संकलित कि बात हम वस्तु कोड कहा जाता है, में आप के लिए है

236
00:14:06,840 --> 00:14:09,540
लेकिन यह सिर्फ आप को कोई फर्क नहीं पड़ता, जहां यह है क्योंकि इस प्रणाली जानता है

237
00:14:09,540 --> 00:14:11,730
उपकरण: इस मामले में वह कहाँ है.

238
00:14:11,730 --> 00:14:17,400
चलो अब नीचे स्क्रॉल करने के लिए GetInt और देखने के लिए कैसे GetInt काम कर रहा है यह सब समय.

239
00:14:17,400 --> 00:14:19,460
यहाँ हम पहले से इसी तरह की टिप्पणी की है.

240
00:14:19,460 --> 00:14:21,660
मुझे सिर्फ कोड हिस्से पर में ज़ूम.

241
00:14:21,660 --> 00:14:23,900
और हम GetInt के लिए है जो निम्नलिखित है.

242
00:14:23,900 --> 00:14:25,700
यह कोई इनपुट लेता है.

243
00:14:25,700 --> 00:14:29,510
यह int देता है, जबकि () सच है, तो हम एक विचार अनंत लूप है,

244
00:14:29,510 --> 00:14:33,180
लेकिन शायद हम इस से बाहर किसी भी तरह तोड़ने या इस के भीतर से लौटने.

245
00:14:33,180 --> 00:14:34,870
>> चलो यह कैसे काम करता है देखना.

246
00:14:34,870 --> 00:14:39,240
हम पाश अंदर इस पहली पंक्ति में GetString का उपयोग किया, 166 लगते हैं.

247
00:14:39,240 --> 00:14:43,780
अब यह अच्छा अभ्यास है है क्योंकि किस परिस्थिति GetString लौट सकता है

248
00:14:43,780 --> 00:14:47,660
विशेष कीवर्ड रिक्त? >> [छात्र] अगर कुछ गलत हो जाता है.

249
00:14:47,660 --> 00:14:51,630
अगर कुछ गलत हो जाता है. और क्या गलत है जब आप GetString की तरह कुछ कह सकते हैं?

250
00:14:54,960 --> 00:14:57,640
हाँ. >> [छात्र] Malloc यह ints देने में विफल रहता है.

251
00:14:57,640 --> 00:14:59,150
हाँ. शायद malloc विफल रहता है.

252
00:14:59,150 --> 00:15:03,190
हुड के नीचे कहीं न कहीं, GetString malloc, जो स्मृति आवंटित बुला रहा है,

253
00:15:03,190 --> 00:15:06,020
जो कंप्यूटर की दुकान की मदद से सभी वर्णों की

254
00:15:06,020 --> 00:15:07,750
कि कुंजीपटल में उपयोगकर्ता प्रकार.

255
00:15:07,750 --> 00:15:11,590
लगता है और उपयोगकर्ता खाली समय का एक पूरी बहुत कुछ था और अधिक उदाहरण के लिए, टाइप,

256
00:15:11,590 --> 00:15:16,160
में, कंप्यूटर से अधिक वर्ण अरब से अधिक 2 वर्ण भी रैम है.

257
00:15:16,160 --> 00:15:19,250
GetString कि आप को दर्शाता करने में सक्षम हो गया है.

258
00:15:19,250 --> 00:15:22,560
यहां तक ​​कि अगर यह एक सुपर, सुपर असामान्य कोने मामला है,

259
00:15:22,560 --> 00:15:24,340
यह किसी भी तरह से इस संभाल करने में सक्षम हो गया है,

260
00:15:24,340 --> 00:15:28,750
और इसलिए GetString, अगर हम वापस चला गया और अपनी दस्तावेज़ीकरण पढ़ें, वास्तव में वापसी की खबरें करता है.

261
00:15:28,750 --> 00:15:34,460
तो अब अगर GetString रिक्त लौटने से विफल रहता है, GetInt को INT_MAX लौटने से असफल हो रहा है

262
00:15:34,460 --> 00:15:37,690
सिर्फ एक प्रहरी के रूप में. ये सिर्फ मानव सम्मेलनों हैं.

263
00:15:37,690 --> 00:15:41,450
केवल तरह आप जानते हैं कि यह मामला है प्रलेखन पढ़ने के द्वारा होता है.

264
00:15:41,450 --> 00:15:45,040
>> चलो जहां int वास्तव में मिल गया है के लिए नीचे स्क्रॉल.

265
00:15:45,040 --> 00:15:51,160
अगर मैं नीचे स्क्रॉल थोड़ा आगे, 170 लाइन में, हम इन लाइनों के ऊपर एक टिप्पणी है.

266
00:15:51,160 --> 00:15:55,100
हम 172 में एक int, पता, और एक चार, ग, और फिर इस नए कार्य की घोषणा,

267
00:15:55,100 --> 00:15:58,930
जो आप में से कुछ पहले sscanf, भर में ठोकर खाई है.

268
00:15:58,930 --> 00:16:00,870
यह स्ट्रिंग scanf के लिए खड़ा है.

269
00:16:00,870 --> 00:16:05,700
दूसरे शब्दों में, मुझे एक स्ट्रिंग दे और मैं यह ब्याज की जानकारी के टुकड़े के लिए स्कैन करेगा.

270
00:16:05,700 --> 00:16:07,360
इसका क्या मतलब है?

271
00:16:07,360 --> 00:16:11,800
मान लीजिए कि मैं कीबोर्ड पर, सचमुच, 123 टाइप करें और फिर हिट दर्ज करें.

272
00:16:11,800 --> 00:16:16,470
123 के डेटा प्रकार जब GetString द्वारा लौटाए गए क्या है? >> [छात्र] स्ट्रिंग.

273
00:16:16,470 --> 00:16:18,380
यह स्पष्ट रूप से एक स्ट्रिंग, है ना? मैं एक स्ट्रिंग है.

274
00:16:18,380 --> 00:16:23,220
तो 123 वास्तव में है, बोली - गंदें शब्द बोलना, 123 के अंत में \ 0 के साथ.

275
00:16:23,220 --> 00:16:27,110
यह एक int नहीं है. यह एक संख्या नहीं है. यह एक नंबर की तरह दिखता है, लेकिन यह वास्तव में नहीं है.

276
00:16:27,110 --> 00:16:29,080
तो क्या GetInt करने के लिए क्या करना है?

277
00:16:29,080 --> 00:16:35,750
123 0 \ - और किसी तरह एक वास्तविक पूर्णांक कनवर्टर के लिए इस्तेमाल किया जा सकता है कि सही करने के लिए छोड़ दिया स्ट्रिंग स्कैन है.

278
00:16:35,750 --> 00:16:37,850
तुम बाहर आंकड़ा कैसे यह करने के लिए कर सकते हैं.

279
00:16:37,850 --> 00:16:41,450
यदि आप pset2 के लिए वापस लगता है, तो आप शायद एक छोटे से सीज़र के साथ सहज हो गया

280
00:16:41,450 --> 00:16:44,820
या Vigenere, ताकि आप एक स्ट्रिंग पर पुनरावृति कर सकते हैं, तो आप घर का काम ints के साथ परिवर्तित कर सकते हैं.

281
00:16:44,820 --> 00:16:46,710
लेकिन बिल्ली, यह काम की एक पूरी बहुत कुछ है.

282
00:16:46,710 --> 00:16:49,860
फोन क्यों नहीं sscanf तरह एक समारोह है कि आप के लिए है कि नहीं करता?

283
00:16:49,860 --> 00:16:54,230
तो sscanf एक तर्क की आशा है - इस मामले में लाइन कहा जाता है, जो एक स्ट्रिंग है.

284
00:16:54,230 --> 00:17:01,840
फिर आप उद्धरण में निर्दिष्ट बहुत ही इसी तरह printf, क्या आप इस स्ट्रिंग में देखने की उम्मीद है.

285
00:17:01,840 --> 00:17:09,000
और मैं यहाँ कह रहा हूँ क्या है मैं एक दशमलव संख्या और शायद एक चरित्र को देखने की उम्मीद है.

286
00:17:09,000 --> 00:17:12,000
और हम क्यों यह बस एक पल में मामले देखेंगे.

287
00:17:12,000 --> 00:17:15,869
और यह पता चला है कि इस अंकन अब सामान की याद ताजा करती है हम के बारे में बात करना शुरू कर दिया

288
00:17:15,869 --> 00:17:17,619
सिर्फ एक हफ्ते पहले से अधिक.

289
00:17:17,619 --> 00:17:21,740
क्या है और n और ग हमारे लिए यहाँ क्या कर रही है? >> [छात्र] n और ग के पते का पता.

290
00:17:21,740 --> 00:17:25,400
हाँ. यह मुझे n और ग के पते का पता दे रही है. कि क्यों महत्वपूर्ण है?

291
00:17:25,400 --> 00:17:30,220
तुम्हें पता है कि सी में कार्यों के साथ, आप हमेशा एक मूल्य या सब पर कोई मूल्य नहीं लौट सकते हैं.

292
00:17:30,220 --> 00:17:34,530
आप एक int एक स्ट्रिंग, एक नाव, एक चार, जो कुछ भी है, या आप शून्य लौट सकते हैं लौट सकते हैं,

293
00:17:34,530 --> 00:17:38,030
लेकिन आप केवल एक बात ज़्यादा से ज़्यादा लौट सकते हैं.

294
00:17:38,030 --> 00:17:42,760
लेकिन यहाँ हम sscanf मुझे वापस जाने के लिए हो सकता है एक int, एक दशमलव संख्या चाहते हैं,

295
00:17:42,760 --> 00:17:46,220
और यह भी एक चार है, और इसलिए मैं एक क्षण में चार समझाता हूँ.

296
00:17:46,220 --> 00:17:51,460
आप को प्रभावी ढंग sscanf दो चीजों को वापस करने के लिए करना चाहते हैं, लेकिन वह सिर्फ सी. में संभव नहीं

297
00:17:51,460 --> 00:17:55,200
आप दो पतों में से गुजर रहा है कि चारों ओर काम कर सकते हैं

298
00:17:55,200 --> 00:17:57,370
क्योंकि जैसे ही आप एक समारोह दो पते हाथ,

299
00:17:57,370 --> 00:18:00,470
कि समारोह उनके साथ क्या कर सकते हैं? >> [छात्र] उन पतों को लिखें.

300
00:18:00,470 --> 00:18:02,010
यह उन पतों के लिए लिख सकते हैं.

301
00:18:02,010 --> 00:18:05,770
आप स्टार कार्रवाई का उपयोग कर सकते हैं और वहाँ उन पतों में से प्रत्येक के लिए जा सकते हैं.

302
00:18:05,770 --> 00:18:11,260
यह चर के मूल्यों को बदलने के लिए पिछले दरवाजे से इस तंत्र की है, लेकिन बहुत आम है

303
00:18:11,260 --> 00:18:14,870
इस मामले में, दो - सिर्फ एक जगह से अधिक है.

304
00:18:14,870 --> 00:18:21,340
अब मैं == 1 के लिए जाँच कर रहा हूँ तो और n लौटने कि अगर वास्तव में करता है, सच करने के लिए मूल्यांकन नोटिस.

305
00:18:21,340 --> 00:18:26,170
तो क्या चल रहा है? तकनीकी तौर पर, हम वास्तव में GetInt में ऐसा करना चाहते है.

306
00:18:26,170 --> 00:18:30,740
123 बोली - गंदें शब्द बोलना - हम पार्स करने के लिए है, तो बात करने के लिए चाहते हैं, हम स्ट्रिंग पढ़ने के लिए चाहते हैं -

307
00:18:30,740 --> 00:18:34,560
और अगर ऐसा लगता है जैसे वहाँ एक संख्या है, हम क्या sscanf के लिए कह रहे हैं

308
00:18:34,560 --> 00:18:38,190
इस चर में मेरे लिए n - 123 - यह है कि संख्या में डाल दिया.

309
00:18:38,190 --> 00:18:42,090
तो फिर क्यों मैं वास्तव में था कि यह के रूप में अच्छी तरह से है?

310
00:18:42,090 --> 00:18:48,220
Sscanf कह रही है आप भी एक चरित्र के यहाँ मिल सकता है की भूमिका क्या है?

311
00:18:48,220 --> 00:18:53,470
[अश्राव्य छात्र प्रतिक्रिया] >> एक दशमलव बिंदु वास्तव में काम कर सकता है.

312
00:18:53,470 --> 00:18:56,330
चलो पकड़ है कि एक पल के लिए सोचा. और क्या?

313
00:18:56,330 --> 00:18:59,270
[छात्र] यह शून्य हो सकता है. >> अच्छा सोचा. यह अशक्त चरित्र हो सकता है.

314
00:18:59,270 --> 00:19:01,660
यह वास्तव में इस मामले में नहीं है. हाँ. >> [छात्र] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. या मुझे भी आगे सामान्यीकरण.

316
00:19:04,340 --> 00:19:06,640
% वहाँ ग त्रुटि जाँच के लिए ही है.

317
00:19:06,640 --> 00:19:09,300
हम वहाँ नहीं चाहते कि संख्या के बाद एक चरित्र हो सकता है,

318
00:19:09,300 --> 00:19:11,870
लेकिन क्या यह मुझे करने के लिए अनुमति देता है इस प्रकार है.

319
00:19:11,870 --> 00:19:18,210
यह पता चला है कि sscanf, इस उदाहरण में n और ग में मूल्यों यहाँ भंडारण के अलावा,

320
00:19:18,210 --> 00:19:24,890
यह भी क्या करता है यह चर की संख्या देता है यह अंदर मूल्यों डाल

321
00:19:24,890 --> 00:19:30,260
तो अगर आप केवल 123 में टाइप, तो केवल% d मैच करने के लिए जा रहा है,

322
00:19:30,260 --> 00:19:33,880
और केवल n 123 की तरह एक मूल्य के साथ जमा हो जाता है,

323
00:19:33,880 --> 00:19:35,640
और कुछ भी नहीं है ग में रखा जाता है.

324
00:19:35,640 --> 00:19:37,620
सी एक कचरा मान रहता है, तो बात करने के लिए -

325
00:19:37,620 --> 00:19:40,730
कचरा क्योंकि यह कुछ मूल्य के लिए कभी नहीं प्रारंभ किया गया है.

326
00:19:40,730 --> 00:19:45,520
तो उस मामले में, sscanf 1 देता है क्योंकि मैं उन संकेत की 1 आबादी,

327
00:19:45,520 --> 00:19:50,190
जो बड़े मामले में, मैं एक int है तो मैं लाइन मुक्त करने के लिए स्मृति मुक्त

328
00:19:50,190 --> 00:19:54,000
कि GetString वास्तव में आवंटित की है, और फिर मैं n लौटने के,

329
00:19:54,000 --> 00:19:58,500
और अगर आपने कभी सोचा है कि जहां पुन: प्रयास करें बयान से आता है, इसे यहीं से आता है.

330
00:19:58,500 --> 00:20:04,390
यदि हां, तो इसके विपरीत, मैं 123foo में लिखें - केवल पाठ के कुछ यादृच्छिक अनुक्रम

331
00:20:04,390 --> 00:20:08,490
sscanf संख्या, संख्या, संख्या, च को देखने के लिए जा रहा है,

332
00:20:08,490 --> 00:20:16,410
और यह 123 n में डाल रहा है, यह ग में च डाल दिया और फिर 2 लौटने के लिए जा रहा है.

333
00:20:16,410 --> 00:20:20,640
तो हम, sscanf व्यवहार, एक बहुत ही सरल तरीके की मूल परिभाषा का उपयोग -

334
00:20:20,640 --> 00:20:23,900
ठीक है, पहली नज़र में जटिल है, लेकिन दिन के अंत में काफी सरल तंत्र

335
00:20:23,900 --> 00:20:28,320
कह के एक int है और अगर ऐसा है, कि केवल एक चीज है कि मैंने पाया है?

336
00:20:28,320 --> 00:20:29,860
और यहाँ रहितसफेद विचार है.

337
00:20:29,860 --> 00:20:34,000
यदि आप sscanf के लिए प्रलेखन पढ़ा है, यह बताता है कि अगर आप खाली स्थान के एक टुकड़ा शामिल

338
00:20:34,000 --> 00:20:38,810
शुरुआत या अंत में, sscanf भी जो भी कारण के लिए उपयोगकर्ता, की अनुमति देगा,

339
00:20:38,810 --> 00:20:41,860
अंतरिक्ष बार 123 मारा और है कि वैध होगा.

340
00:20:41,860 --> 00:20:44,150
आप उपयोगकर्ता पर नहीं चिल्लाना सिर्फ इसलिए कि वे अंतरिक्ष बार मारा जाएगा

341
00:20:44,150 --> 00:20:48,640
शुरुआत या अंत में है, जो सिर्फ एक छोटे से अधिक उपयोगकर्ता के अनुकूल है.

342
00:20:48,640 --> 00:20:52,300
>> कोई तो सवाल GetInt पर? हाँ. >> [छात्र] क्या होगा अगर तुम सिर्फ एक चार में डाल दिया?

343
00:20:52,300 --> 00:20:54,030
अच्छा सवाल है.

344
00:20:54,030 --> 00:20:59,890
क्या होगा अगर तुम सिर्फ च की तरह एक चार में टाइप और कभी 123 टाइपिंग बिना हिट दर्ज?

345
00:20:59,890 --> 00:21:02,420
तुम्हें क्या लगता है कोड की इस पंक्ति का व्यवहार तो होगा?

346
00:21:02,420 --> 00:21:04,730
[अश्राव्य छात्र प्रतिक्रिया]

347
00:21:04,730 --> 00:21:08,790
हाँ, तो sscanf वह भी कवर क्योंकि उस मामले में, यह n या ग को भरने के लिए नहीं जा रहा है.

348
00:21:08,790 --> 00:21:15,310
यह करने के बजाय 0 लौटने के लिए, जो मामले में मैं भी उस परिदृश्य को पकड़ने जा रहा है

349
00:21:15,310 --> 00:21:18,750
क्योंकि मैं चाहता हूँ उम्मीद मूल्य 1 है.

350
00:21:18,750 --> 00:21:22,000
मैं केवल एक चाहते हैं और केवल एक ही बात भरा होना. अच्छा सवाल है.

351
00:21:22,000 --> 00:21:24,290
>> दूसरों? सही सभी.

352
00:21:24,290 --> 00:21:26,250
>> यहाँ के कार्यों के सभी के माध्यम से जाने नहीं,

353
00:21:26,250 --> 00:21:29,500
लेकिन एक है कि शेष ब्याज की शायद लगता GetString है

354
00:21:29,500 --> 00:21:32,790
क्योंकि यह पता चला है कि GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
सभी बाज़ी उनके GetString करने के लिए कार्यक्षमता की एक बहुत कुछ है.

356
00:21:36,260 --> 00:21:39,750
तो चलो वह यहाँ कैसे कार्यान्वित किया जाता है पर एक नज़र रखना.

357
00:21:39,750 --> 00:21:43,630
यह एक थोड़ा जटिल दिखता है, लेकिन यह एक ही बुनियादी बातों का उपयोग करता है

358
00:21:43,630 --> 00:21:45,670
कि हम पिछले हफ्ते के बारे में बात कर शुरू कर दिया.

359
00:21:45,670 --> 00:21:49,490
GetString में, जो शून्य के प्रति कोई तर्क के रूप में लेता है

360
00:21:49,490 --> 00:21:53,730
और यह एक स्ट्रिंग देता है, मैं जाहिरा तौर पर कहा जाता है एक बफर स्ट्रिंग की घोषणा कर रहा हूँ.

361
00:21:53,730 --> 00:21:56,270
मैं वास्तव में नहीं है कि क्या अभी तक के लिए इस्तेमाल किया जा रहा है पता नहीं है, लेकिन हम देखेंगे.

362
00:21:56,270 --> 00:21:58,390
ऐसा लगता है कि क्षमता 0 डिफ़ॉल्ट रूप से है.

363
00:21:58,390 --> 00:22:01,350
नहीं काफी यकीन है कि जहां यह यकीन है कि n क्या करने के लिए अभी तक इस्तेमाल किया जा जा रहा है नहीं जा रहा है,

364
00:22:01,350 --> 00:22:03,590
लेकिन अब यह एक छोटे से अधिक दिलचस्प हो रही है.

365
00:22:03,590 --> 00:22:06,520
243 लाइन में, हम एक int, ग की घोषणा.

366
00:22:06,520 --> 00:22:08,800
यह एक बेवकूफ विस्तार की तरह है.

367
00:22:08,800 --> 00:22:15,820
एक चार 8 बिट है, और 8 बिट कितने विभिन्न मूल्यों स्टोर कर सकते हैं? >> [छात्र] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
समस्या यह है कि अगर आप 256 विभिन्न ASCII वर्ण, जो वहाँ हैं चाहते

369
00:22:20,730 --> 00:22:23,340
अगर तुम वापस लगता है - और यह याद करने के लिए कुछ नहीं है.

370
00:22:23,340 --> 00:22:25,710
लेकिन अगर आप कि बड़ा ASCII चार्ट वापस लगता है कि हम सप्ताह पहले किया था,

371
00:22:25,710 --> 00:22:30,600
उस मामले में 128 या 256 ASCII वर्ण थे.

372
00:22:30,600 --> 00:22:32,940
हम 0s और 1s ऊपर के सभी पैटर्न का इस्तेमाल किया.

373
00:22:32,940 --> 00:22:36,210
यह एक समस्या है अगर आप एक त्रुटि का पता लगाने में सक्षम होना चाहते हैं

374
00:22:36,210 --> 00:22:40,190
क्योंकि अगर आप पहले से ही अपने पात्रों के लिए 256 मूल्यों का उपयोग कर रहे हैं,

375
00:22:40,190 --> 00:22:43,050
आप वास्तव में आगे की योजना नहीं था, क्योंकि अब आप कह रही का कोई रास्ता नहीं है,

376
00:22:43,050 --> 00:22:46,270
यह एक कानूनी चरित्र नहीं है, यह कुछ गलत संदेश है.

377
00:22:46,270 --> 00:22:50,270
तो दुनिया क्या करता है कि वे अगले सबसे बड़ा मूल्य है, एक int की तरह कुछ का उपयोग करने के लिए,

378
00:22:50,270 --> 00:22:54,720
इतनी है कि आप 4 अरब संभव मूल्यों के लिए बिट्स, 32 के एक पागल संख्या है,

379
00:22:54,720 --> 00:22:58,860
इतना है कि आप बस अंत में उनमें से 257 अनिवार्य रूप से उपयोग कर सकते हैं,

380
00:22:58,860 --> 00:23:01,720
1 जिनमें से एक त्रुटि के रूप में कुछ विशेष अर्थ है.

381
00:23:01,720 --> 00:23:03,120
>> तो चलो यह कैसे काम करता है देखने के लिए.

382
00:23:03,120 --> 00:23:07,760
246 लाइन में, मैं इस बड़े जबकि पाश है कि fgetc बुला रहा है,

383
00:23:07,760 --> 00:23:11,090
च अर्थ फ़ाइल, तो जीइ टीसी, और फिर stdin.

384
00:23:11,090 --> 00:23:15,520
यह पता चला है यह सिर्फ कह कुंजीपटल से इनपुट को पढ़ने के और अधिक सटीक तरीका है.

385
00:23:15,520 --> 00:23:19,300
मानक इनपुट का मतलब कुछ कीबोर्ड, मानक आउटपुट स्क्रीन का मतलब है,

386
00:23:19,300 --> 00:23:23,310
और मानक त्रुटि, जो हम pset4 में देखेंगे, स्क्रीन का मतलब

387
00:23:23,310 --> 00:23:27,490
लेकिन स्क्रीन के एक विशेष हिस्सा इतना है कि यह वास्तविक उत्पादन के साथ नहीं conflated है

388
00:23:27,490 --> 00:23:30,750
कि आप मुद्रित करना. लेकिन भविष्य में उस पर और अधिक.

389
00:23:30,750 --> 00:23:34,440
तो fgetc सिर्फ मतलब कीबोर्ड से एक चरित्र को पढ़ने और यह दुकान जहां?

390
00:23:34,440 --> 00:23:37,350
यह ग में स्टोर.

391
00:23:37,350 --> 00:23:41,360
और फिर जांच - तो मैं बस कुछ बूलियन संयोजक यहाँ का उपयोग कर रहा हूँ -

392
00:23:41,360 --> 00:23:46,000
जाँच करें कि यह बराबर नहीं है - \ n, तो उपयोगकर्ता हिट दर्ज किया है, हम उस बिंदु पर रोक चाहते हैं,

393
00:23:46,000 --> 00:23:49,850
लूप के अंत और हम भी विशेष लगातार EOF के लिए जाँच करना चाहते हैं,

394
00:23:49,850 --> 00:23:53,610
जो अगर आप जानते हैं या लगता है, यह क्या के लिए खड़े करता है? >> [छात्र] फ़ाइल का अंत. फ़ाइल के अंतिम >>.

395
00:23:53,610 --> 00:23:56,560
इस तरह के बेतुका है, क्योंकि अगर मैं कीबोर्ड पर टाइप कर रहा हूँ

396
00:23:56,560 --> 00:23:58,870
वहाँ वास्तव में कोई फ़ाइल इस में शामिल है,

397
00:23:58,870 --> 00:24:01,150
लेकिन यह सिर्फ सामान्य मतलब प्रयोग किया जाता शब्द की तरह है

398
00:24:01,150 --> 00:24:04,220
कि और कुछ नहीं मानव उंगलियों से आ रहा है.

399
00:24:04,220 --> 00:24:06,460
EOF - फ़ाइल के अंत.

400
00:24:06,460 --> 00:24:09,920
एक अलग रूप में, अगर तुम कभी अपने कुंजीपटल पर नियंत्रण डी मारा, तो आप कि अभी तक नहीं करना होगा -

401
00:24:09,920 --> 00:24:15,230
आप नियंत्रण सी मारा है - नियंत्रण डी इस विशेष EOF बुलाया लगातार भेजता है.

402
00:24:15,230 --> 00:24:19,850
तो अब हम सिर्फ कुछ गतिशील स्मृति आवंटन है.

403
00:24:19,850 --> 00:24:23,440
>> तो अगर (एन 1 +> क्षमता). अब मैं n समझाता हूँ.

404
00:24:23,440 --> 00:24:26,100
एन कितने बाइट्स बफर में वर्तमान में कर रहे हैं,

405
00:24:26,100 --> 00:24:28,620
स्ट्रिंग है कि आप वर्तमान में उपयोगकर्ता से निर्माण कर रहे हैं.

406
00:24:28,620 --> 00:24:33,450
यदि आप अपने बफर में अधिक वर्ण से आप बफर में क्षमता है,

407
00:24:33,450 --> 00:24:37,410
intuitively हम क्या करते हो तो जरूरत अधिक क्षमता आवंटित है.

408
00:24:37,410 --> 00:24:43,330
तो मैं यहाँ गणित के कुछ हवा में घूमना और यहाँ केवल इस समारोह पर ध्यान केंद्रित करने के लिए जा रहा हूँ.

409
00:24:43,330 --> 00:24:46,070
आप जानते हैं कि malloc क्या है, या कम से कम आम तौर पर परिचित हैं.

410
00:24:46,070 --> 00:24:48,970
एक अनुमान realloc क्या करता है ले लो. >> [छात्र] स्मृति जोड़ता है.

411
00:24:48,970 --> 00:24:52,920
यह काफी स्मृति जोड़कर नहीं है. यह इस प्रकार के रूप में स्मृति reallocates.

412
00:24:52,920 --> 00:24:57,220
अगर वहाँ अभी भी स्ट्रिंग के अंत में कमरे में आप है कि स्मृति की अधिक दे

413
00:24:57,220 --> 00:25:00,000
की तुलना में यह मूल रूप से आप देता है, तो आपको लगता है कि अतिरिक्त स्मृति मिल जाएगा.

414
00:25:00,000 --> 00:25:03,460
तो तुम सिर्फ स्ट्रिंग वर्ण वापस डाल वापस वापस करने के लिए वापस करने के लिए रख सकते हैं.

415
00:25:03,460 --> 00:25:05,830
लेकिन अगर यह मामला नहीं है क्योंकि आप भी लंबे समय से इंतजार कर रहे थे

416
00:25:05,830 --> 00:25:07,940
और बिना सोचे समझे कुछ स्मृति में plopped हो गया

417
00:25:07,940 --> 00:25:10,290
लेकिन यहाँ नीचे अतिरिक्त स्मृति है, वह ठीक है.

418
00:25:10,290 --> 00:25:13,100
Realloc आप सभी के लिए भारी उठाने करने के लिए जा रहा है,

419
00:25:13,100 --> 00:25:16,750
आप स्ट्रिंग में पढ़ा है और इस तरह यहाँ से दूर ले जाने के लिए, यह वहाँ नीचे रखा,

420
00:25:16,750 --> 00:25:19,460
और फिर आप उस बिंदु पर कुछ और रनवे दे.

421
00:25:19,460 --> 00:25:22,550
>> तो हाथ की एक लहर के साथ, मुझे कहना है कि क्या GetString कर रही है

422
00:25:22,550 --> 00:25:26,330
यह एक छोटे से बफर, शायद एक ही चरित्र के साथ शुरू हो रहा है,

423
00:25:26,330 --> 00:25:30,820
और अगर दो अक्षरों में उपयोगकर्ता प्रकार, GetString realloc बुला समाप्त होता है और कहता है

424
00:25:30,820 --> 00:25:33,150
एक चरित्र के लिए पर्याप्त नहीं था, मुझे दो अक्षर दे.

425
00:25:33,150 --> 00:25:35,950
तो अगर आप पाश के तर्क के माध्यम से पढ़ते हैं, यह कहने जा रहा है

426
00:25:35,950 --> 00:25:39,600
उपयोगकर्ता 3 अक्षरों में टाइप, मुझे अब 2 नहीं है, लेकिन 4 अक्षर दे,

427
00:25:39,600 --> 00:25:42,320
तो मुझे 8 दे, तो मुझे 16 और 32 दे.

428
00:25:42,320 --> 00:25:45,000
तथ्य यह है कि मैं क्षमता हर बार दोगुना कर रहा हूँ

429
00:25:45,000 --> 00:25:48,570
मतलब यह है कि बफर करने के लिए धीरे धीरे बढ़ने नहीं जा रहा है, यह सुपर फास्ट बढ़ती जा रही है.

430
00:25:48,570 --> 00:25:51,380
और क्या इस बात का फायदा हो सकता है?

431
00:25:51,380 --> 00:25:54,600
मैं क्यों बफर के आकार के दोहरीकरण हूँ

432
00:25:54,600 --> 00:25:58,020
भले ही उपयोगकर्ता को सिर्फ एक कीबोर्ड से अतिरिक्त चरित्र की जरूरत हो सकती है?

433
00:25:58,020 --> 00:26:01,750
[अश्राव्य छात्र प्रतिक्रिया] >> वह क्या है? >> [छात्र] आप यह अक्सर के रूप में विकसित करने के लिए नहीं है.

434
00:26:01,750 --> 00:26:03,300
बिल्कुल सही. आप इसे अक्सर के रूप में विकसित करने के लिए नहीं है.

435
00:26:03,300 --> 00:26:05,510
और यह सिर्फ आप की तरह है यहाँ अपने दांव हेजिंग कर रहे हैं,

436
00:26:05,510 --> 00:26:10,850
विचार किया जा रहा है कि आप एक बहुत realloc कॉल नहीं करना चाहता क्योंकि यह करने के लिए धीमी गति से हो जाता है.

437
00:26:10,850 --> 00:26:12,910
किसी भी समय आप स्मृति के लिए ऑपरेटिंग सिस्टम से पूछो,

438
00:26:12,910 --> 00:26:16,990
के रूप में आप जल्द ही एक भविष्य समस्या सेट में देखेंगे, यह कुछ समय लेने के लिए जाता है.

439
00:26:16,990 --> 00:26:20,010
तो समय की है कि कम से कम राशि है, भले ही आप कुछ जगह बर्बाद कर रहे हैं,

440
00:26:20,010 --> 00:26:21,900
एक अच्छी बात हो जाता है.

441
00:26:21,900 --> 00:26:24,060
>> लेकिन अगर हम यहाँ GetString के अंतिम भाग के माध्यम से पढ़ा -

442
00:26:24,060 --> 00:26:27,950
और फिर हर एक लाइन यहाँ समझ आज इतना महत्वपूर्ण नहीं है -

443
00:26:27,950 --> 00:26:30,530
सूचना है कि यह अंततः malloc फिर कॉल

444
00:26:30,530 --> 00:26:33,880
और यह कई बाइट के रूप में बिल्कुल का आवंटन के रूप में यह स्ट्रिंग के लिए की जरूरत है

445
00:26:33,880 --> 00:26:38,060
और फिर मुक्त जरूरत से ज्यादा बड़े बफर फोन करके दूर फेंकता

446
00:26:38,060 --> 00:26:40,080
अगर यह वास्तव में भी कई बार दोगुनी हो गया.

447
00:26:40,080 --> 00:26:42,730
तो संक्षेप में, है कि कैसे GetString यह सब समय काम कर रहा है.

448
00:26:42,730 --> 00:26:47,060
यह सब एक समय में एक चरित्र फिर से और फिर से पढ़ा,

449
00:26:47,060 --> 00:26:50,750
और हर बार यह कुछ अतिरिक्त स्मृति की जरूरत है, इसके लिए ऑपरेटिंग सिस्टम पूछता

450
00:26:50,750 --> 00:26:53,670
realloc फोन करके.

451
00:26:53,670 --> 00:26:57,890
>> कोई सवाल? सही सभी.

452
00:26:57,890 --> 00:26:59,270
>> एक हमले.

453
00:26:59,270 --> 00:27:04,060
अब है कि हम संकेत समझते हैं या कम से कम संकेत के साथ तेजी से परिचित हैं,

454
00:27:04,060 --> 00:27:06,700
चलो विचार कैसे पूरी दुनिया के पतन शुरू होता है

455
00:27:06,700 --> 00:27:10,030
अगर आप काफी adversarial उपयोगकर्ताओं के खिलाफ नहीं की रक्षा करते हैं,

456
00:27:10,030 --> 00:27:11,850
लोग हैं, जो आपके सिस्टम में हैक करने की कोशिश कर रहे हैं,

457
00:27:11,850 --> 00:27:16,890
जो लोग कुछ पंजीकरण कोड circumventing द्वारा अपने सॉफ्टवेयर चोरी करने की कोशिश कर रहे हैं

458
00:27:16,890 --> 00:27:19,090
कि वे अन्यथा प्रकार अंदर हो सकता है

459
00:27:19,090 --> 00:27:22,990
>> इस उदाहरण पर एक नज़र यहाँ ले लो, जो सिर्फ सी कोड है कि तल पर एक मुख्य समारोह

460
00:27:22,990 --> 00:27:26,380
कि एक समारोह foo कॉल. और क्या यह foo गुजर रहा है?

461
00:27:26,380 --> 00:27:29,680
एक एकल तर्क [छात्र]. >> [Malan] एक एकल तर्क.

462
00:27:29,680 --> 00:27:33,450
तो argv [1], जो पहला शब्द का अर्थ है कि उपयोगकर्ता कमांड लाइन पर टाइप

463
00:27:33,450 --> 00:27:36,360
a.out या जो भी कार्यक्रम के बाद कहा जाता है.

464
00:27:36,360 --> 00:27:41,680
तो शीर्ष पर foo एक चार * में लेता है. लेकिन चार * क्या बस है? >> [छात्र] एक स्ट्रिंग.

465
00:27:41,680 --> 00:27:43,350
[Malan] एक स्ट्रिंग, तो कोई नई बात नहीं है.

466
00:27:43,350 --> 00:27:45,420
स्ट्रिंग है कि मनमाने ढंग से बार बुलाया जा रहा है.

467
00:27:45,420 --> 00:27:51,430
इस लाइन में, चार ग [12], अर्द्ध तकनीकी अंग्रेजी की तरह, इस लाइन क्या कर रही है?

468
00:27:51,430 --> 00:27:55,220
[छात्र] की एक सरणी - >> सरणी? >> [छात्र] लोगो. >> लोगो.

469
00:27:55,220 --> 00:27:58,870
मुझे 12 वर्णों की एक सरणी दे. तो हम एक बफर कॉल कर सकते हैं.

470
00:27:58,870 --> 00:28:02,920
यह तकनीकी ग कहा जाता है, लेकिन प्रोग्रामिंग में एक बफर सिर्फ अंतरिक्ष का एक गुच्छा का मतलब

471
00:28:02,920 --> 00:28:04,800
है कि आप कुछ सामान अंदर रख सकते हैं

472
00:28:04,800 --> 00:28:07,940
फिर अंत में, memcpy हम पहले नहीं इस्तेमाल किया, है, लेकिन आप शायद लगता है कि यह क्या करता.

473
00:28:07,940 --> 00:28:10,480
यह स्मृति प्रतियां. यह क्या करता है?

474
00:28:10,480 --> 00:28:19,270
जाहिरा तौर पर यह बार प्रतियां, अपने इनपुट, लेकिन ग में केवल पट्टी की लंबाई तक.

475
00:28:19,270 --> 00:28:24,930
लेकिन यहाँ एक बग है. >> [छात्र] आप sizeof चरित्र की जरूरत है. ठीक है. >>

476
00:28:24,930 --> 00:28:30,860
तकनीकी तौर पर, हम वास्तव में strlen (पट्टी) * sizeof (चार)). यह सही है.

477
00:28:30,860 --> 00:28:33,930
लेकिन सबसे खराब मामले में, चलो कि that's मान -

478
00:28:33,930 --> 00:28:35,950
ठीक है. तो फिर वहाँ दो कीड़े है.

479
00:28:35,950 --> 00:28:39,160
(चार) sizeof);

480
00:28:39,160 --> 00:28:41,290
चलो इस एक छोटे से व्यापक बनाने के.

481
00:28:41,290 --> 00:28:44,910
तो अब वहाँ अभी भी एक बग है, जो क्या है? >> [अश्राव्य छात्र प्रतिक्रिया]

482
00:28:44,910 --> 00:28:46,990
क्या के लिए जाँच करें? >> [छात्र] नल के लिए जाँच करें.

483
00:28:46,990 --> 00:28:50,270
हम आम तौर पर नल के लिए जाँच की जानी चाहिए क्योंकि बुरी बातें होती हैं

484
00:28:50,270 --> 00:28:53,200
जब अपने सूचक रिक्त है क्योंकि तुम अंत में वहाँ जा सकता है,

485
00:28:53,200 --> 00:28:57,630
और आप कभी नहीं किया जा सितारा ऑपरेटर के साथ अपसंदर्भन रिक्त चाहिए.

486
00:28:57,630 --> 00:29:01,050
तो यह अच्छी बात है. और हम और क्या कर रहे हैं? तार्किक रूप से, वहाँ एक दोष यहाँ भी है.

487
00:29:01,050 --> 00:29:04,450
[छात्र] की जाँच करें अगर argc> = 2 है.

488
00:29:04,450 --> 00:29:10,550
तो जांच अगर argc> = 2. ठीक है, तो इस कार्यक्रम में तीन कीड़े यहाँ है.

489
00:29:10,550 --> 00:29:16,630
अब हम यदि उपयोगकर्ता वास्तव में argv में किसी भी चीज़ में टाइप की जाँच कर रहे हैं [1]. अच्छा है.

490
00:29:16,630 --> 00:29:20,950
तो 3 बग क्या है? हाँ. >> [छात्र] सी पर्याप्त रूप से बड़ा नहीं हो सकता है.

491
00:29:20,950 --> 00:29:23,320
अच्छा है. हम एक परिदृश्य की जाँच की.

492
00:29:23,320 --> 00:29:29,520
हम उलझाव से जाँच अधिक स्मृति से पट्टी की लंबाई से अधिक की नकल नहीं है.

493
00:29:29,520 --> 00:29:32,510
तो अगर स्ट्रिंग में टाइप उपयोगकर्ता 10 वर्ण लंबा है,

494
00:29:32,510 --> 00:29:36,020
यह कह रही है केवल 10 वर्ण कॉपी. और वह ठीक है.

495
00:29:36,020 --> 00:29:39,940
लेकिन क्या होगा यदि उपयोगकर्ता एक शब्द 20-चरित्र की तरह शीघ्र एक शब्द में टाइप?

496
00:29:39,940 --> 00:29:44,900
इस बार से 20 वर्णों प्रति कह रहा है?

497
00:29:44,900 --> 00:29:49,750
सी, अन्यथा हमारे बफर के रूप में जाना जाता है, जिसका मतलब है कि आप सिर्फ डेटा लिखा

498
00:29:49,750 --> 00:29:52,540
8 बाइट स्थानों है कि आप खुद का नहीं है,

499
00:29:52,540 --> 00:29:54,870
और आप उन्हें भावना है कि आप उन्हें कभी नहीं आवंटित में ही नहीं है.

500
00:29:54,870 --> 00:30:00,370
तो यह है कि क्या आम तौर पर बफर अतिप्रवाह हमले या बफर ओवररन हमले के रूप में जाना जाता है.

501
00:30:00,370 --> 00:30:05,580
और यह भावना में एक हमले की है कि यदि उपयोगकर्ता या प्रोग्राम है कि अपने कार्य बुला रहा है

502
00:30:05,580 --> 00:30:10,490
इस दुर्भावनापूर्ण रूप से कर रही है, क्या वास्तव में आगे क्या होता है वास्तव में काफी खराब हो सकता है.

503
00:30:10,490 --> 00:30:12,450
>> तो चलो इस चित्र पर एक नज़र यहाँ ले.

504
00:30:12,450 --> 00:30:16,060
यह तस्वीर स्मृति के ढेर का प्रतिनिधित्व करता है.

505
00:30:16,060 --> 00:30:19,580
याद है कि हर बार जब आप एक समारोह फोन आप ढेर पर इस छोटे फ्रेम मिल

506
00:30:19,580 --> 00:30:21,520
और फिर दूसरा और फिर दूसरा और दूसरा.

507
00:30:21,520 --> 00:30:24,300
और इस प्रकार अब तक, हम बस की तरह इन आयतों के रूप में abstracted

508
00:30:24,300 --> 00:30:26,290
या तो बोर्ड पर या स्क्रीन पर यहाँ.

509
00:30:26,290 --> 00:30:30,580
लेकिन अगर हम उन आयतों, जब आप एक समारोह foo फोन पर ज़ूम

510
00:30:30,580 --> 00:30:35,880
यह पता चला है कि वहाँ है कि फ्रेम के ढेर के अंदर पर कि आयत में अधिक है

511
00:30:35,880 --> 00:30:40,060
की तुलना में सिर्फ एक्स और y और एक और ख, जैसे हम स्वैप के बारे में बात कर किया.

512
00:30:40,060 --> 00:30:44,410
यह पता चला है कि वहाँ कुछ निचले स्तर के विवरण है, उन के बीच वापसी पता.

513
00:30:44,410 --> 00:30:49,550
तो यह पता चला जब मुख्य foo कॉल, मुख्य foo सूचित

514
00:30:49,550 --> 00:30:53,520
क्या मुख्य पते कंप्यूटर की स्मृति में है

515
00:30:53,520 --> 00:30:57,770
क्योंकि अन्यथा, के रूप में foo के रूप में जल्द ही इस मामले में यहाँ के रूप में क्रियान्वित किया जाता है,

516
00:30:57,770 --> 00:31:00,830
एक बार आप foo के अंत में इस बंद धनु धनुकोष्ठक तक पहुँचने,

517
00:31:00,830 --> 00:31:05,310
कैसे हो foo जहां कार्यक्रम के नियंत्रण के लिए जाना माना जाता है पता नहीं है?

518
00:31:05,310 --> 00:31:08,970
यह पता चला है कि उस सवाल का जवाब इस लाल आयत में है.

519
00:31:08,970 --> 00:31:12,670
यह एक सूचक का प्रतिनिधित्व करता है, और यह कंप्यूटर को अस्थायी रूप से दुकान

520
00:31:12,670 --> 00:31:17,030
ढेर तथाकथित मुख्य ताकि के रूप में foo के रूप में जल्द ही पते क्रियान्वित किया जाता है,

521
00:31:17,030 --> 00:31:21,120
कंप्यूटर जहां मुख्य लाइन और वापस जाने के लिए क्या जानता है.

522
00:31:21,120 --> 00:31:23,940
सहेजे गए फ़्रेम सूचक यह करने के लिए इसी तरह से संबंधित है.

523
00:31:23,940 --> 00:31:26,310
चार * यहाँ बार क्या प्रतिनिधित्व करता है?

524
00:31:26,310 --> 00:31:31,350
अब इस नीले खंड यहाँ foo फ्रेम है. पट्टी क्या है?

525
00:31:31,570 --> 00:31:35,010
बार सिर्फ foo समारोह के लिए तर्क है.

526
00:31:35,010 --> 00:31:37,500
तो अब हम परिचित तस्वीर की तरह पर वापस आ गए हैं.

527
00:31:37,500 --> 00:31:39,850
अधिक और स्क्रीन पर सामान अधिक distractions है,

528
00:31:39,850 --> 00:31:43,380
लेकिन इस हल्के नीले रंग खंड सिर्फ यह है कि हम क्या चॉकबोर्ड पर ड्राइंग किया गया है

529
00:31:43,380 --> 00:31:45,790
स्वैप की तरह कुछ के लिए. कि foo लिए फ्रेम है.

530
00:31:45,790 --> 00:31:51,490
और यह केवल बात सही अब पट्टी है, जो इस पैरामीटर है.

531
00:31:51,490 --> 00:31:55,220
लेकिन और क्या ढेर में यहाँ इस कोड के अनुसार होना चाहिए?

532
00:31:55,220 --> 00:31:57,760
[छात्र] चार ग [12]. >> [Malan] चार ग. [12]

533
00:31:57,760 --> 00:32:02,810
हम भी स्मृति के 12 वर्गों ग चर बुलाया आवंटित देखना चाहिए,

534
00:32:02,810 --> 00:32:04,970
और वास्तव में हम स्क्रीन पर कि है.

535
00:32:04,970 --> 00:32:08,480
बहुत ऊपर है ग [0], और फिर इस चित्र के लेखक

536
00:32:08,480 --> 00:32:11,850
किया परेशान, नहीं सभी वर्गों का ड्राइंग, लेकिन वहाँ वास्तव में कर रहे हैं 12 वहाँ

537
00:32:11,850 --> 00:32:16,590
क्योंकि अगर आप नीचे सही पर देखो, ग [11] यदि आप 0 से गिनती 12 ऐसी बाइट.

538
00:32:16,590 --> 00:32:18,400
लेकिन यहाँ समस्या है.

539
00:32:18,400 --> 00:32:22,390
ग किस दिशा में बढ़ रहा है?

540
00:32:22,390 --> 00:32:27,080
तरह ऊपर नीचे अगर यह शीर्ष पर शुरू होता है और नीचे बढ़ता.

541
00:32:27,080 --> 00:32:30,110
ऐसा लगता है जैसे हम खुद को बहुत रनवे छोड़ दिया सब यहाँ पर नहीं दिखता है.

542
00:32:30,110 --> 00:32:32,090
हम तरह के एक कोने में खुद को चित्रित किया है,

543
00:32:32,090 --> 00:32:36,940
और कि ग [11] बार, जो सहेजे गए फ़्रेम सूचक के खिलाफ सही है के खिलाफ सही है,

544
00:32:36,940 --> 00:32:39,960
जो वापसी पता के खिलाफ अभी भी ऊपर है. वहाँ कोई और अधिक कमरा है.

545
00:32:39,960 --> 00:32:42,810
तो क्या निहितार्थ तो अगर तुम पेंच

546
00:32:42,810 --> 00:32:46,500
और आप एक 12 - बाइट बफर में 20 बाइट्स पढ़ने की कोशिश की?

547
00:32:46,500 --> 00:32:50,060
उन 8 अतिरिक्त बाइट्स कहाँ जा रहे हैं? >> [छात्र] के अंदर -

548
00:32:50,060 --> 00:32:53,200
बाकी सब कुछ अंदर, जिनमें से कुछ महत्वपूर्ण सुपर है.

549
00:32:53,200 --> 00:32:57,260
और सबसे महत्वपूर्ण बात, संभावित, लाल बॉक्स है, वापसी पता,

550
00:32:57,260 --> 00:33:03,560
क्योंकि लगता है कि या तो आप गलती से या adversarially उन 4 बाइट्स अधिलेखित,

551
00:33:03,560 --> 00:33:07,260
न सिर्फ कचरा के साथ, लेकिन एक नंबर के साथ कि सूचक पते,

552
00:33:07,260 --> 00:33:09,810
कि स्मृति में एक वास्तविक पते का प्रतिनिधित्व होता है.

553
00:33:09,810 --> 00:33:13,880
निहितार्थ क्या है तार्किक,? >> [छात्र] समारोह के लिए एक अलग जगह पर लौटने जा रहा है.

554
00:33:13,880 --> 00:33:15,250
बिल्कुल सही.

555
00:33:15,250 --> 00:33:19,170
जब foo रिटर्न और हिट धनु धनुकोष्ठक कि कार्यक्रम के लिए आगे बढ़ने के लिए जा रहा है

556
00:33:19,170 --> 00:33:25,060
मुख्य करने के लिए वापस नहीं है, यह पता कि लाल बॉक्स में जो कुछ भी है लौटने जा रहा है.

557
00:33:25,060 --> 00:33:28,600
>> Circumventing सॉफ्टवेयर पंजीकरण के मामले में,

558
00:33:28,600 --> 00:33:32,260
क्या हुआ अगर पता है कि करने के लिए किया जा रहा वापस आ रहा है समारोह में कहा कि आम तौर पर बुलाया जाता है

559
00:33:32,260 --> 00:33:35,690
के बाद आप सॉफ्टवेयर के लिए भुगतान किया है और अपने पंजीकरण कोड inputted?

560
00:33:35,690 --> 00:33:39,870
आप कंप्यूटर चाल के यहाँ नहीं जा रहा में सॉर्ट लेकिन इसके बजाय यहाँ जा सकते हैं.

561
00:33:39,870 --> 00:33:45,100
या अगर तुम सच में चालाक, एक विरोधी वास्तव में कुंजीपटल में टाइप कर सकते हैं, उदाहरण के लिए,

562
00:33:45,100 --> 00:33:50,690
नहीं एक वास्तविक, शब्द नहीं 20 अक्षर, लेकिन लगता है वह या वह वास्तव में प्रकार

563
00:33:50,690 --> 00:33:52,770
कुछ अक्षर है कि कोड का प्रतिनिधित्व करते हैं.

564
00:33:52,770 --> 00:33:55,320
और यह सी कोड होने नहीं जा रहा है, यह वास्तव में वर्ण होने जा रहा है

565
00:33:55,320 --> 00:33:59,290
कि बाइनरी मशीन कोड, 0s और 1s का प्रतिनिधित्व करते हैं.

566
00:33:59,290 --> 00:34:01,290
लेकिन लगता है कि वे काफी चालाक क्या करना है कि कर रहे हैं,

567
00:34:01,290 --> 00:34:06,500
किसी भी तरह GetString शीघ्र कुछ है कि अनिवार्य रूप से संकलित कोड में पेस्ट,

568
00:34:06,500 --> 00:34:09,980
और पिछले 4 बाइट्स कि वापसी पता अधिलेखित.

569
00:34:09,980 --> 00:34:13,360
और क्या पता है कि इनपुट क्या करता है?

570
00:34:13,360 --> 00:34:18,630
यह वास्तव में इस लाल आयत बफर की पहली बाइट के पते में भंडार है.

571
00:34:18,630 --> 00:34:23,070
तो तुम बहुत चालाक है, और इस बुरे लोगों के लिए परीक्षण और त्रुटि के एक बहुत वहाँ बाहर है,

572
00:34:23,070 --> 00:34:25,639
लेकिन अगर तुम बाहर आंकड़ा कितना बड़ा है यह बफर

573
00:34:25,639 --> 00:34:28,820
कि इस तरह के निवेश में पिछले कुछ बाइट्स आप इस कार्यक्रम को उपलब्ध कराने के

574
00:34:28,820 --> 00:34:33,540
अपने बफर की शुरुआत का पता करने के लिए बराबर होना होगा, आप यह कर सकते हैं.

575
00:34:33,540 --> 00:34:39,320
अगर हम कहते हैं कि सामान्य रूप से नमस्ते और \ 0, कि क्या बफर में समाप्त होता है.

576
00:34:39,320 --> 00:34:44,420
लेकिन अगर हम और अधिक चतुर हो और हम हम क्या generically का दौरा पड़ने कोड के साथ फोन करता हूँ कि बफर भरें -

577
00:34:44,420 --> 00:34:48,860
एएए, हमले, हमले, हमले - जहां यह सिर्फ कुछ है कि कुछ बुरा करता है,

578
00:34:48,860 --> 00:34:51,820
क्या होता है अगर तुम सच में चालाक, आप यह कर सकते हैं.

579
00:34:51,820 --> 00:34:58,610
80, C0, 35, 08 - लाल बॉक्स में संख्या का एक दृश्य है.

580
00:34:58,610 --> 00:35:01,610
सूचना है कि वह संख्या है कि यहाँ है मैच.

581
00:35:01,610 --> 00:35:04,430
यह रिवर्स क्रम में है, लेकिन यह है कि कुछ अन्य समय पर अधिक है.

582
00:35:04,430 --> 00:35:08,140
सूचना है कि इस वापसी पता जानबूझकर बदल दिया गया है

583
00:35:08,140 --> 00:35:12,020
पते बराबर यहाँ, मुख्य पता नहीं.

584
00:35:12,020 --> 00:35:17,500
तो अगर बुरा आदमी सुपर स्मार्ट है, वह या वह है कि हमले के कोड में शामिल करने के लिए जा रहा है

585
00:35:17,500 --> 00:35:20,930
कुछ की तरह उपयोगकर्ता फ़ाइलों के सभी नष्ट या प्रतिलिपि बनाने के पासवर्ड

586
00:35:20,930 --> 00:35:24,680
या एक उपयोगकर्ता खाते बनाने कि मैं तो में लॉग इन कर सकते हैं - सभी में कुछ भी.

587
00:35:24,680 --> 00:35:26,950
>> और यह दोनों खतरे और सी. की शक्ति है

588
00:35:26,950 --> 00:35:29,840
क्योंकि आप संकेत के माध्यम से याद करने के लिए उपयोग किया है

589
00:35:29,840 --> 00:35:32,520
और इसलिए तुम एक कंप्यूटर की स्मृति में आप चाहते हैं कुछ भी लिख सकते हैं,

590
00:35:32,520 --> 00:35:35,080
आप एक कंप्यूटर कुछ भी आप चाहते हैं कर सकते हैं

591
00:35:35,080 --> 00:35:39,550
बस के द्वारा अपने स्वयं के स्मृति अंतरिक्ष के भीतर होने के चारों ओर छलांग.

592
00:35:39,550 --> 00:35:44,650
और इसलिए इस दिन के लिए कई कार्यक्रमों और कई वेबसाइटों है कि समझौता कर रहे हैं

593
00:35:44,650 --> 00:35:46,200
लोगों को इस का लाभ लेने के लिए नीचे फोड़ा.

594
00:35:46,200 --> 00:35:50,760
और इस एक सुपर परिष्कृत हमले की तरह लग रहे हो, लेकिन हो सकता है यह हमेशा कि तरह शुरू नहीं करता है.

595
00:35:50,760 --> 00:35:53,560
वास्तविकता यह है कि बुरे लोगों को आम तौर पर क्या करना होगा है,

596
00:35:53,560 --> 00:35:58,200
क्या यह एक कमांड लाइन पर एक कार्यक्रम या एक GUI प्रोग्राम या एक वेबसाइट है,

597
00:35:58,200 --> 00:35:59,940
तुम सिर्फ बकवास प्रदान करने शुरू.

598
00:35:59,940 --> 00:36:03,980
आप खोज क्षेत्र और हिट दर्ज में एक बहुत बड़ा शब्द में लिखें,

599
00:36:03,980 --> 00:36:05,780
और आप देखने के लिए अगर वेबसाइट दुर्घटनाओं के लिए इंतजार

600
00:36:05,780 --> 00:36:09,990
या आप देखने के लिए अगर कार्यक्रम कुछ त्रुटि संदेश प्रकट होता है के लिए इंतजार

601
00:36:09,990 --> 00:36:14,330
क्योंकि अगर आप बुरा आदमी के रूप में भाग्यशाली हो और तुम कुछ पागल इनपुट प्रदान

602
00:36:14,330 --> 00:36:18,980
कि कार्यक्रम है, इसका मतलब है कि प्रोग्रामर अपने बुरे व्यवहार सोचा भी नहीं था दुर्घटनाओं,

603
00:36:18,980 --> 00:36:23,630
जिसका मतलब है कि आप शायद पर्याप्त प्रयास, पर्याप्त परीक्षण और त्रुटि के साथ कर सकते हैं,

604
00:36:23,630 --> 00:36:26,650
बाहर आंकड़ा कैसे एक और अधिक सटीक हमले मजदूरी.

605
00:36:26,650 --> 00:36:31,410
इतना के रूप में सुरक्षा का एक हिस्सा इन हमलों को पूरी तरह से परहेज नहीं है

606
00:36:31,410 --> 00:36:34,100
लेकिन उन्हें पता लगाने और वास्तव में लॉग तलाश

607
00:36:34,100 --> 00:36:36,780
और देख पागल आदानों क्या लोगों को अपनी वेबसाइट में लिखा गया है,

608
00:36:36,780 --> 00:36:38,960
क्या खोज शब्दों को अपनी वेबसाइट में लोगों को टाइप किया है

609
00:36:38,960 --> 00:36:42,870
कुछ बफर ढेर की उम्मीद में.

610
00:36:42,870 --> 00:36:45,500
और यह क्या की सरल मूल बातें करने के लिए नीचे फोड़े एक सरणी है

611
00:36:45,500 --> 00:36:49,080
और क्या यह आवंटन और स्मृति का उपयोग मतलब नहीं है.

612
00:36:49,080 --> 00:36:51,710
>> फिर भी यह है कि संबंधित.

613
00:36:51,710 --> 00:36:54,280
चलो बस एक हार्ड ड्राइव के अंदर एक बार फिर नज़र.

614
00:36:54,280 --> 00:36:58,440
आप एक या दो सप्ताह पहले से याद करते हैं कि जब आप अपने रीसायकल बिन या कचरा कर सकते हैं फ़ाइलों को खींच,

615
00:36:58,440 --> 00:37:03,710
क्या होता है? >> [छात्र] कुछ भी नहीं है. >> बिल्कुल कुछ भी नहीं है, है ना?

616
00:37:03,710 --> 00:37:05,740
अंत में अगर आप कम डिस्क स्थान पर चलाने के लिए,

617
00:37:05,740 --> 00:37:08,190
विंडोज या मैक ओएस आप के लिए फ़ाइलों को हटाने शुरू कर देंगे.

618
00:37:08,190 --> 00:37:10,390
लेकिन अगर तुम वहाँ में कुछ खींचें, कि सभी सुरक्षित नहीं है.

619
00:37:10,390 --> 00:37:13,800
अपने रूममेट या दोस्त या परिवार के सदस्य के लिए क्या करना है डबल और क्लिक करें, देखा,

620
00:37:13,800 --> 00:37:16,310
वहाँ सभी ढांचे के रूप में फ़ाइलों है कि आप को नष्ट करने की कोशिश की है.

621
00:37:16,310 --> 00:37:19,590
हम में से अधिकांश कम से कम पता है कि तुम ठीक क्लिक करें या बादनियंत्रण

622
00:37:19,590 --> 00:37:22,310
और खाली या उस तरह कुछ कचरा.

623
00:37:22,310 --> 00:37:25,000
लेकिन फिर भी है कि काफी चाल नहीं क्या करता है

624
00:37:25,000 --> 00:37:28,010
क्योंकि क्या होता है जब आप अपनी हार्ड ड्राइव पर एक फ़ाइल है

625
00:37:28,010 --> 00:37:32,770
कि कुछ Word दस्तावेज़ या कुछ JPEG का प्रतिनिधित्व करता है, और यह अपनी हार्ड ड्राइव का प्रतिनिधित्व करता है,

626
00:37:32,770 --> 00:37:35,350
और हम कहते हैं कि यहाँ इस ज़ुल्फ़ कि फ़ाइल का प्रतिनिधित्व करता है,

627
00:37:35,350 --> 00:37:38,390
और यह 0s और 1s की एक पूरी गुच्छा से बना है.

628
00:37:38,390 --> 00:37:42,470
क्या होता है जब आप कचरा कि फ़ाइल केवल खींचें नहीं होता है या बिन पुनरावृत्ति कर सकते हैं

629
00:37:42,470 --> 00:37:48,020
लेकिन यह भी इसे खाली? कुछ भी नहीं की तरह.

630
00:37:48,020 --> 00:37:49,640
अब यह बिल्कुल कुछ भी नहीं है.

631
00:37:49,640 --> 00:37:54,290
अब यह सिर्फ कुछ भी नहीं है क्योंकि एक छोटे से कुछ इस तालिका के रूप में होता है.

632
00:37:54,290 --> 00:37:58,370
तो वहाँ एक कंप्यूटर की स्मृति के अंदर डेटाबेस या तालिका के किसी तरह का है

633
00:37:58,370 --> 00:38:03,850
है कि अनिवार्य रूप से फ़ाइलों के लिए एक कॉलम 'के नाम और फ़ाइलों के लिए एक कॉलम' स्थान है,

634
00:38:03,850 --> 00:38:07,720
इस 123 स्थान है, जहां सिर्फ एक यादृच्छिक संख्या हो सकती है.

635
00:38:07,720 --> 00:38:14,560
तो हम x.jpeg और 123 स्थान की तरह कुछ हो सकता है.

636
00:38:14,560 --> 00:38:18,800
फिर क्या होता है जब आप वास्तव में अपने कचरा खाली?

637
00:38:18,800 --> 00:38:20,330
यह दूर हो जाता है.

638
00:38:20,330 --> 00:38:23,610
लेकिन क्या करता है चले जाओ नहीं 0s और 1s है.

639
00:38:23,610 --> 00:38:26,270
>> तो फिर क्या pset4 के लिए कनेक्शन है?

640
00:38:26,270 --> 00:38:31,240
खैर, pset4 साथ, सिर्फ इसलिए कि हम गलती से कॉम्पैक्ट फ़्लैश कार्ड मिटा दिया है

641
00:38:31,240 --> 00:38:35,750
कि दुर्भाग्य से इन तस्वीरों के सभी था या यह सिर्फ क्योंकि भ्रष्ट बन गया

642
00:38:35,750 --> 00:38:38,000
इसका मतलब यह नहीं है कि 0s और 1s अभी भी वहाँ नहीं कर रहे हैं.

643
00:38:38,000 --> 00:38:40,410
हो सकता है कि उनमें से कुछ खो रहे हैं क्योंकि कुछ भ्रष्ट है

644
00:38:40,410 --> 00:38:43,320
समझ में आता है कि कुछ 0s 1s बन गया है और 1s 0s बन गया.

645
00:38:43,320 --> 00:38:47,240
बुरी बातें छोटी गाड़ी सॉफ्टवेयर या दोषपूर्ण हार्डवेयर की वजह से हो सकता है.

646
00:38:47,240 --> 00:38:50,370
लेकिन उन बिट्स के कई, शायद उनमें से भी 100%, अभी भी वहाँ हैं.

647
00:38:50,370 --> 00:38:55,050
यह सिर्फ है कि कंप्यूटर या कैमरे जहां JPEG1 शुरू नहीं पता नहीं है

648
00:38:55,050 --> 00:38:56,910
और JPEG2 जहां शुरू कर दिया.

649
00:38:56,910 --> 00:39:01,070
लेकिन आप अगर, प्रोग्रामर, प्रेमी की एक सा है, जहां उन JPEGs हैं साथ में पता

650
00:39:01,070 --> 00:39:06,010
या क्या वे जैसे दिखते हैं ताकि आप 0s और 1s और कहते हैं कि JPEG, जेपीईजी का विश्लेषण कर सकते हैं,

651
00:39:06,010 --> 00:39:09,440
आप के लिए अनिवार्य रूप से एक बस के साथ एक कार्यक्रम में लिख सकते हैं या जबकि पाश

652
00:39:09,440 --> 00:39:12,820
कि उन फ़ाइलों में से प्रत्येक एक ठीक हो जाए.

653
00:39:12,820 --> 00:39:16,030
तो सबक तो सुरक्षित रूप से अपने फ़ाइलों को मिटा शुरू

654
00:39:16,030 --> 00:39:18,340
अगर आप इस पूरी तरह से बचने के लिए करना चाहते हैं. हां.

655
00:39:18,340 --> 00:39:21,010
>> [छात्र] कैसे आ यह आपके कंप्यूटर पर कहते हैं

656
00:39:21,010 --> 00:39:23,550
कि आप और अधिक स्मृति की तुलना में आप पहले किया है?

657
00:39:23,550 --> 00:39:27,820
- >> [छात्र] ज्यादा उपलब्ध स्मृति और अधिक स्मृति की तुलना में आप पहले किया है.

658
00:39:27,820 --> 00:39:29,630
ओह. अच्छा सवाल है.

659
00:39:29,630 --> 00:39:32,360
तो फिर क्यों रद्दी खाली करने के बाद अपने कंप्यूटर आपको बता करता है

660
00:39:32,360 --> 00:39:34,910
कि आप और अधिक मुक्त स्थान की तुलना में आप पहले किया है?

661
00:39:34,910 --> 00:39:36,770
संक्षेप में, क्योंकि यह झूठ बोल रहा है.

662
00:39:36,770 --> 00:39:40,740
तकनीकी तौर पर, आप और अधिक स्थान है क्योंकि अब तुम ने कहा है

663
00:39:40,740 --> 00:39:43,680
आप अन्य सामान डाल कर सकते हैं, जहां कि फ़ाइल एक बार गया था.

664
00:39:43,680 --> 00:39:45,450
लेकिन इसका मतलब यह नहीं बिट्स चले जा रहे हैं,

665
00:39:45,450 --> 00:39:48,590
और इसका मतलब यह नहीं बिट सभी 0s को परिवर्तित किया जा रहा है, उदाहरण के लिए,

666
00:39:48,590 --> 00:39:50,150
अपनी सुरक्षा के लिए.

667
00:39:50,150 --> 00:39:54,640
तो इसके विपरीत, यदि आप सुरक्षित फ़ाइलों को मिटा या शारीरिक रूप डिवाइस को नष्ट कर,

668
00:39:54,640 --> 00:39:57,300
कि वास्तव में कभी कभी ही तरीका है कि चारों ओर.

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

670
00:40:02,020 --> 00:40:07,000
[वाहवाही]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]