1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> डेविड मालन: सब ठीक है, वापस स्वागत है.

3
00:00:12,580 --> 00:00:13,290
इस CS50 है.

4
00:00:13,290 --> 00:00:15,130
इस सप्ताह सात की शुरुआत है.

5
00:00:15,130 --> 00:00:18,890
तो यह एक समय हो गया है, इसलिए मुझे लगता है हमें लगा है
जहां हम का एक बवंडर दौरे ले

6
00:00:18,890 --> 00:00:20,760
दूर छोड़ दिया है और अब हम कहाँ जा रहे हैं.

7
00:00:20,760 --> 00:00:23,310
>> तो यहाँ इस बात के लिए हो सकता
पहली बार में कुछ गुस्से का कारण बना.

8
00:00:23,310 --> 00:00:27,680
लेकिन उम्मीद है, आप शुरुआत कर रहे हैं
यहाँ यह अर्थ क्या करने के लिए acclimate -

9
00:00:27,680 --> 00:00:32,670
है जो एक सूचक का प्रतिनिधित्व सितारा
अधिक आम आदमी की दृष्टि में, बस क्या?

10
00:00:32,670 --> 00:00:33,400
तो यह एक पता है.

11
00:00:33,400 --> 00:00:35,490
>> इसलिए इसके बारे में पता है
स्मृति में कुछ.

12
00:00:35,490 --> 00:00:38,260
और हम परतों वापस छील करने के लिए शुरू कर दिया
कुछ हफ़्ते पहले, की तरह बातें

13
00:00:38,260 --> 00:00:41,800
GetString और अन्य तरह के कार्यों
यह सब समय लौट कर दिया गया है

14
00:00:41,800 --> 00:00:46,010
जैसे स्मृति में चीजों के पते,
में प्रथम चरित्र का पता

15
00:00:46,010 --> 00:00:46,990
कुछ अनुक्रम.

16
00:00:46,990 --> 00:00:50,360
>> इसलिए हम भी, वेलग्रिंड शुरू की जो
आप इस समस्या के लिए उपयोग करने के लिए शुरू करेंगे

17
00:00:50,360 --> 00:00:53,380
विशेष रूप से अगले के लिए, सेट
समस्या के रूप में अच्छी तरह से सेट.

18
00:00:53,380 --> 00:00:54,980
और वेलग्रिंड हमारे लिए क्या करता है?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
यह स्मृति लीक के लिए जाँच करता है, और यह
यह भी स्मृति के दुरुपयोग की जांच करता है.

21
00:01:01,020 --> 00:01:05,890
>> यह कुछ संभावना के साथ, पता लगा सकता है अगर
अपने कोड स्मृति को छूने जा रहा है

22
00:01:05,890 --> 00:01:07,100
यह बस नहीं होना चाहिए.

23
00:01:07,100 --> 00:01:10,410
इसलिए जरूरी नहीं कि एक दरार है, लेकिन आप अगर
कुछ की सीमाओं से परे जाना

24
00:01:10,410 --> 00:01:14,730
सरणी, और आप वास्तव में वेलग्रिंड चलाने
और उस व्यवहार के लिए प्रेरित करते हुए

25
00:01:14,730 --> 00:01:17,870
Valgrind है अपने प्रोग्राम में चल रहा है
इसके अंदर चल रहा है, आप मिल जाएगा

26
00:01:17,870 --> 00:01:21,460
इस तरह के संदेश - "अवैध लिखने की
आकार 4, "जो, एक जोड़ी की याद

27
00:01:21,460 --> 00:01:25,880
हफ्ते पहले मैं गलती से मतलब था कि
जैसे एक int पर बहुत दूर

28
00:01:25,880 --> 00:01:27,250
एक सरणी की सीमाओं से परे.

29
00:01:27,250 --> 00:01:30,790
और इसलिए आकार 4 यहाँ आकार का मतलब
उस विशेष int की.

30
00:01:30,790 --> 00:01:35,260
>> तो वास्तव में आश्वासन ले कि
Valgrind के उत्पादन, यह का प्रारूप,

31
00:01:35,260 --> 00:01:36,170
बस नृशंस है.

32
00:01:36,170 --> 00:01:40,180
यह गंदगी के माध्यम से देखने के लिए वास्तव में मुश्किल है
रोचक जानकारी के लिए.

33
00:01:40,180 --> 00:01:42,910
तो क्या हम यहाँ किया है सिर्फ अंश है
अधिक की जोड़ी के कुछ

34
00:01:42,910 --> 00:01:43,850
दिलचस्प लाइनों.

35
00:01:43,850 --> 00:01:46,760
लेकिन एहसास है कि Valgrind के 80%
उत्पादन एक का एक सा होने जा रहा है

36
00:01:46,760 --> 00:01:47,650
व्याकुलता.

37
00:01:47,650 --> 00:01:52,820
>> सिर्फ इस तरह के पैटर्न के लिए देखो -
अवैध सही, अवैध पढ़ें, 40 बाइट्स

38
00:01:52,820 --> 00:01:56,690
और ब्लॉकों में से कुछ संख्या निश्चित रूप से कर रहे हैं
उस तरह खो दिया है, कीवर्ड्स.

39
00:01:56,690 --> 00:02:01,920
और क्या आप उम्मीद देखेंगे कुछ है
समारोह का पता लगाने की तरह

40
00:02:01,920 --> 00:02:03,340
गलती अंदर वास्तव में है

41
00:02:03,340 --> 00:02:07,195
यहां इस मामले में, किस लाइन में
मेरे कोड जाहिरा तौर पर त्रुटि थी?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> था जो memory.c नामक एक फाइल में 26
हम साथ खेल रहे थे उदाहरण

44
00:02:14,130 --> 00:02:14,890
समय पर.

45
00:02:14,890 --> 00:02:16,460
तो यह malloc में शायद नहीं है.

46
00:02:16,460 --> 00:02:18,630
यह बजाय अपने कोड में शायद था.

47
00:02:18,630 --> 00:02:20,910
तो हम फिर से इस देखेंगे
और फिर लंबे समय से पहले.

48
00:02:20,910 --> 00:02:24,080
>> तो scanf, यह एक में आया
रूपों की जोड़ी इस प्रकार अब तक.

49
00:02:24,080 --> 00:02:26,410
हम sscanf संक्षेप में देखा था.

50
00:02:26,410 --> 00:02:28,330
यह की एक संख्या में कुछ था
आप में में डुबकी लगाई अपनी

51
00:02:28,330 --> 00:02:29,535
प्रश्नोत्तरी के लिए तैयारी.

52
00:02:29,535 --> 00:02:33,130
और scanf वास्तव में क्या CS50 है
पुस्तकालय के नीचे का उपयोग किया गया है

53
00:02:33,130 --> 00:02:36,560
आदेश में कुछ समय के लिए हुड
उपयोगकर्ता से इनपुट मिल.

54
00:02:36,560 --> 00:02:40,420
>> उदाहरण के लिए, मैं CS50 खत्म करने के लिए कदम अगर
यहां के उपकरण, मुझे खोल देना एक

55
00:02:40,420 --> 00:02:45,315
उदाहरण आज scanf-0.c कहा जाता है कि
और यह सुपर आसान है.

56
00:02:45,315 --> 00:02:46,590
यह कोड की कुछ लाइनें है.

57
00:02:46,590 --> 00:02:50,880
लेकिन यह कैसे getInt वास्तव दर्शाता
इस समय के सभी काम कर रहा है.

58
00:02:50,880 --> 00:02:54,710
>> यहां इस कार्यक्रम में रेखा 16 में
, मैं एक पूर्णांक घोषित नोटिस.

59
00:02:54,710 --> 00:02:57,270
तो कोई संकेत, कुछ भी नहीं जादुई
वहाँ, बस एक पूर्णांक.

60
00:02:57,270 --> 00:03:00,330
फिर 17 लाइन में, मैं का संकेत
एक नंबर के लिए उपयोगकर्ता, कृपया.

61
00:03:00,330 --> 00:03:02,930
तो फिर देर से 18 में, मैं यहाँ scanf का उपयोग करें.

62
00:03:02,930 --> 00:03:06,910
और मुझे लगता है, की तरह printf की तरह, निर्दिष्ट
मैं बोली की उम्मीद कर रहा हूँ कि

63
00:03:06,910 --> 00:03:08,110
गंदें शब्द बोलना प्रतिशत मैं.

64
00:03:08,110 --> 00:03:10,920
>> तो जाहिर प्रतिशत मैं,,
एक पूर्णांक अर्थ.

65
00:03:10,920 --> 00:03:14,580
लेकिन क्या दूसरा नोटिस
scanf के लिए तर्क है.

66
00:03:14,580 --> 00:03:17,350
कैसे आप दूसरे का वर्णन होगा
अल्पविराम के बाद तर्क?

67
00:03:17,350 --> 00:03:19,450
वह क्या है?

68
00:03:19,450 --> 00:03:20,670
>> यह एक्स का पता है.

69
00:03:20,670 --> 00:03:25,490
तो इस वजह से प्रदान करके उपयोगी है
क्या करता है, एक्स के पते के साथ scanf

70
00:03:25,490 --> 00:03:29,560
ऐसा करने के लिए समारोह में कहा कि है कि सशक्त?

71
00:03:29,560 --> 00:03:33,010
बस वहाँ जाना है, लेकिन यह भी क्या नहीं?

72
00:03:33,010 --> 00:03:34,060
>> यह करने के लिए एक बदलाव करें.

73
00:03:34,060 --> 00:03:38,080
आप वहां जा सकते हैं, क्योंकि यह की तरह है
स्मृति में एक स्थान के लिए एक मानचित्र की तरह.

74
00:03:38,080 --> 00:03:41,900
और इतने लंबे समय आपको उपलब्ध कराने के रूप में scanf, या
इस तरह के एक नक्शे, उस के साथ किसी भी समारोह

75
00:03:41,900 --> 00:03:45,840
समारोह न केवल वहाँ जाना है, और कर सकते हैं
मूल्य पर देखने के लिए, लेकिन यह भी कर सकते हैं

76
00:03:45,840 --> 00:03:49,670
अगर उपयोगी है जो कि मूल्य, बदल
scanf के जीवन में उद्देश्य के लिए है

77
00:03:49,670 --> 00:03:53,060
विशेष रूप से, उपयोगकर्ता से इनपुट स्कैन
कीबोर्ड से.

78
00:03:53,060 --> 00:03:57,830
और एफ, जैसे स्वरूपित अर्थ
printf, च एक स्वरूपित अर्थ

79
00:03:57,830 --> 00:03:58,930
आप मुद्रित करना चाहते हैं कि स्ट्रिंग.

80
00:03:58,930 --> 00:04:04,430
>> तो संक्षेप में, इस लाइन में 18 बस, कहते हैं
उपयोगकर्ता से एक पूर्णांक को पढ़ने की कोशिश

81
00:04:04,430 --> 00:04:10,420
कीबोर्ड और पर, एक्स के अंदर यह स्टोर
जो कुछ भी पता एक्स में रहने के लिए होता है.

82
00:04:10,420 --> 00:04:14,860
और फिर अंत में, 19 लाइन बस का कहना है,
इस मामले में int के लिए धन्यवाद,.

83
00:04:14,860 --> 00:04:15,940
>> तो मुझे आगे जाना है और इस बनाते हैं.

84
00:04:15,940 --> 00:04:18,570
तो scanf 0 बनाते हैं.

85
00:04:18,570 --> 00:04:20,130
मुझे आगे जाना है और जूम इन करते हैं

86
00:04:20,130 --> 00:04:22,960
मैं जाने के लिए और के साथ इस भाग लेंगे
डॉट्स scanf 0 स्लेश.

87
00:04:22,960 --> 00:04:24,020
संख्या, कृपया?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
50 के लिए धन्यवाद.

90
00:04:25,730 --> 00:04:27,270
तो यह काफी आसान है.

91
00:04:27,270 --> 00:04:28,160
>> अब यह क्या कर रहा है?

92
00:04:28,160 --> 00:04:29,940
यह एक पूरी गुच्छा नहीं कर रही है
त्रुटि की जाँच.

93
00:04:29,940 --> 00:04:33,000
उदाहरण के लिए, मैं सहयोग नहीं करते हैं,
और मैं एक संख्या में टाइप करें, लेकिन नहीं है

94
00:04:33,000 --> 00:04:37,860
बजाय मैं "हैलो" की तरह कुछ लिखने
कि सिर्फ अजीब तरह का है.

95
00:04:37,860 --> 00:04:41,130
चीजों की है और एक बहुत CS50
पुस्तकालय कुछ के लिए हमारे लिए कर दिया गया है

96
00:04:41,130 --> 00:04:43,440
समय है कि reprompting है
और reprompting.

97
00:04:43,440 --> 00:04:49,320
>> फिर से प्रयास करें मुहावरा याद, cs50.c में था
और उस में getInt कि कारण है

98
00:04:49,320 --> 00:04:51,670
CS50 पुस्तकालय वास्तव में एक पूरी है
लंबी लाइनों का गुच्छा, हम कर रहे हैं, क्योंकि

99
00:04:51,670 --> 00:04:53,190
इस तरह बेवकूफ सामान के लिए जाँच.

100
00:04:53,190 --> 00:04:55,730
उपयोगकर्ता नहीं दिया
वास्तव में हमें, एक int?

101
00:04:55,730 --> 00:04:57,910
वह या वह हमें कुछ दे दिया
एक वर्णमाला पत्र की तरह?

102
00:04:57,910 --> 00:05:01,410
यदि हां, हम पता लगाने के लिए चाहते हैं
कि और उन पर चिल्लाना.

103
00:05:01,410 --> 00:05:03,915
>> लेकिन चीजों को और अधिक दिलचस्प हो
यह अगले उदाहरण में.

104
00:05:03,915 --> 00:05:09,840
मैं scanf-1.c के लिए जाना है, एक क्या है
मूलरूप में बदल गया है कि बात

105
00:05:09,840 --> 00:05:11,135
यह अगले उदाहरण?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
मैं, ज़ाहिर है, चार * उपयोग कर रहा हूँ
बजाय int की.

108
00:05:16,010 --> 00:05:19,210
>> तो यह दिलचस्प है, क्योंकि चार *,
याद है, वास्तव में सिर्फ है

109
00:05:19,210 --> 00:05:20,190
स्ट्रिंग के रूप में एक ही बात.

110
00:05:20,190 --> 00:05:23,840
शायद यह एक सुपर है तो ऐसा लगता है
GetString की सरल कार्यान्वयन.

111
00:05:23,840 --> 00:05:26,010
लेकिन मैं परत वापस खुली दिया है
CS50 पुस्तकालय की, तो मैं कर रहा हूँ

112
00:05:26,010 --> 00:05:27,550
अब यह चार * बुला.

113
00:05:27,550 --> 00:05:30,070
तो चलो जहां, अगर कहीं भी देखते हैं,
हम गलत जाना.

114
00:05:30,070 --> 00:05:30,840
>> 17 लाइन -

115
00:05:30,840 --> 00:05:33,950
मैं फिर कहता हूँ, मुझे कुछ दे,
इस मामले में, एक स्ट्रिंग.

116
00:05:33,950 --> 00:05:37,940
और फिर अगली पंक्ति में, मैं scanf कॉल,
फिर, यह एक स्वरूप कोड दे रही है,

117
00:05:37,940 --> 00:05:39,310
लेकिन इस बार प्रतिशत है.

118
00:05:39,310 --> 00:05:41,900
और फिर इस बार, मैं हूँ
यह बफर दे रही है.

119
00:05:41,900 --> 00:05:43,550
>> अब मैं का उपयोग नहीं कर रहा हूँ, नोटिस
एम्परसेंड.

120
00:05:43,550 --> 00:05:47,120
लेकिन यही कारण है कि यहां शायद ठीक है?

121
00:05:47,120 --> 00:05:49,760
बफर पहले से ही क्या है वजह?

122
00:05:49,760 --> 00:05:50,770
यह पहले से ही एक सूचक है.

123
00:05:50,770 --> 00:05:51,650
यह पहले से ही एक पता है.

124
00:05:51,650 --> 00:05:54,510
>> और चलो इस शब्द चलो मुझे "भ्रमित" चलो
अभी के लिए, उदाहरण के लिए, यह कॉल

125
00:05:54,510 --> 00:05:55,050
सादगी.

126
00:05:55,050 --> 00:05:58,250
लेकिन मैं क्योंकि में यह बफर बुलाया है
सामान्य, प्रोग्रामिंग में, यदि आपके पास एक

127
00:05:58,250 --> 00:06:02,130
स्मृति, जो एक स्ट्रिंग सच का हिस्सा
बस है, आप एक बफर यह फोन हो सकता है.

128
00:06:02,130 --> 00:06:04,460
यह जानकारी स्टोर करने के लिए एक जगह है.

129
00:06:04,460 --> 00:06:07,400
>> यूट्यूब की तरह बातें करने के लिए इसी तरह के जब
वे, इतनी बात करने के बफरिंग रहे हैं कि

130
00:06:07,400 --> 00:06:10,270
बस इसे से बिट्स डाउनलोड करने का मतलब
इंटरनेट और एक में उन्हें भंडारण

131
00:06:10,270 --> 00:06:14,160
स्थानीय सरणी, स्मृति की एक स्थानीय हिस्सा तो
आप बिना बाद में यह देख सकते हैं कि

132
00:06:14,160 --> 00:06:16,830
यह लंघन या फांसी पर
आप वापस खेलते समय.

133
00:06:16,830 --> 00:06:20,930
>> तो एक समस्या है, हालांकि यहाँ है
मैं scanf बता रहा हूँ क्योंकि, उम्मीद है एक

134
00:06:20,930 --> 00:06:22,320
उपयोगकर्ता से स्ट्रिंग.

135
00:06:22,320 --> 00:06:24,410
यहां के पते है
स्मृति का एक हिस्सा.

136
00:06:24,410 --> 00:06:26,180
वहाँ कि स्ट्रिंग रखो.

137
00:06:26,180 --> 00:06:31,230
क्यों है कि बाध्य दे
हमें परेशानी है, हालांकि?

138
00:06:31,230 --> 00:06:33,490
>> वह क्या है?

139
00:06:33,490 --> 00:06:35,510
मैं का उपयोग करने की अनुमति दी हूँ
स्मृति का वह हिस्सा?

140
00:06:35,510 --> 00:06:36,250
तुम्हें पता है, मैं नहीं जानता.

141
00:06:36,250 --> 00:06:39,210
बफर initialized किया गया है क्योंकि
कुछ भी करने के लिए?

142
00:06:39,210 --> 00:06:39,820
ऐसा नहीं है.

143
00:06:39,820 --> 00:06:43,090
और इसलिए यह हम बुला रहा हूँ क्या है
एक कचरा मूल्य, जो

144
00:06:43,090 --> 00:06:44,040
एक औपचारिक शब्द नहीं है.

145
00:06:44,040 --> 00:06:49,200
यह सिर्फ हमें पता नहीं है इसका मतलब क्या बिट्स
कि चार बाइट्स के अंदर कर रहे हैं

146
00:06:49,200 --> 00:06:51,240
मैं बफर के रूप में आवंटित किया है.

147
00:06:51,240 --> 00:06:52,450
>> मैं malloc नहीं बुलाया है.

148
00:06:52,450 --> 00:06:53,940
मैं निश्चित रूप से GetString नहीं बुलाया गया है.

149
00:06:53,940 --> 00:06:56,380
तो जो वास्तव में है क्या जानता है
बफर के अंदर?

150
00:06:56,380 --> 00:07:00,550
और फिर भी scanf कह रही आँख बंद करके, वहाँ जाना
और उपयोगकर्ता टाइप किया जो कुछ भी डाल दिया.

151
00:07:00,550 --> 00:07:04,460
>> तो क्या कारण होने की संभावना है
हमारे कोड में अगर हम इसे चलाने के?

152
00:07:04,460 --> 00:07:05,700
शायद एक segfault.

153
00:07:05,700 --> 00:07:07,970
शायद नहीं, लेकिन शायद एक segfault.

154
00:07:07,970 --> 00:07:10,620
और मैं कहना शायद नहीं, क्योंकि कभी कभी
आप कभी कभी, करते हैं

155
00:07:10,620 --> 00:07:11,380
आप एक segfault नहीं मिलता.

156
00:07:11,380 --> 00:07:14,280
कभी कभी तुम सिर्फ भाग्यशाली हो, लेकिन
यह फिर भी होने जा रहा है

157
00:07:14,280 --> 00:07:15,340
हमारे कार्यक्रम में एक बग.

158
00:07:15,340 --> 00:07:17,060
>> तो मुझे आगे जाना है और इस संकलन करते हैं.

159
00:07:17,060 --> 00:07:18,280
मैं इसे पुराने तरीके से करने के लिए जा रहा हूँ.

160
00:07:18,280 --> 00:07:23,825
तो बजना पानी का छींटा 0, scanf -1,
scanf-1.c, लिखें.

161
00:07:23,825 --> 00:07:24,720
ओह, बहुत पुराना स्कूल.

162
00:07:24,720 --> 00:07:26,550
चलो देखते हैं.

163
00:07:26,550 --> 00:07:28,440
मैं कहाँ गए थे?

164
00:07:28,440 --> 00:07:29,700
ओह, चार * बफर.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
ओह, शुक्रिया -

167
00:07:35,130 --> 00:07:36,930
ठीक है, बचाओ -

168
00:07:36,930 --> 00:07:37,690
बहुत पुराने स्कूल.

169
00:07:37,690 --> 00:07:38,900
ठीक है, यह एक समय हो गया है.

170
00:07:38,900 --> 00:07:41,720
>> तो मैं बस फ़ाइल के बाद बचा लिया
कि अस्थायी बना

171
00:07:41,720 --> 00:07:42,700
एक पल पहले बदल जाते हैं.

172
00:07:42,700 --> 00:07:46,090
और अब मैं इसे संकलित किया है
मैन्युअल रूप बजना के साथ.

173
00:07:46,090 --> 00:07:49,500
और अब मैं आगे जाने के लिए जा रहा हूँ
और लिखें, scanf -1 चलाते हैं.

174
00:07:49,500 --> 00:07:50,290
स्ट्रिंग कृपया.

175
00:07:50,290 --> 00:07:51,600
मैं "नमस्ते." टाइप करेंगे

176
00:07:51,600 --> 00:07:54,070
>> और अब, यहाँ कहाँ, सच में, printf है
कर सकते हैं एक छोटे से परेशान है.

177
00:07:54,070 --> 00:07:56,020
यह वास्तव में नहीं जा रहा है
इस मामले में segfault.

178
00:07:56,020 --> 00:07:59,860
Printf क्योंकि एक छोटी सी खास है
यह इतना सुपर आमतौर पर इस्तेमाल किया है कि

179
00:07:59,860 --> 00:08:03,570
अनिवार्य रूप से printf कर रही है
हमें एक एहसान और साकार,

180
00:08:03,570 --> 00:08:04,830
यह एक मान्य सूचक नहीं है.

181
00:08:04,830 --> 00:08:09,080
मुझे सिर्फ प्रिंट करने के लिए खुद पर लेते हैं
कोष्ठक में बाहर अशक्त, यहां तक ​​कि

182
00:08:09,080 --> 00:08:13,340
यह जरूरी है क्या नहीं है, हालांकि
हम खुद को उम्मीद थी.

183
00:08:13,340 --> 00:08:16,940
>> इसलिए हम वास्तव में आसानी से एक को प्रेरित नहीं कर सकता
इस के साथ segfault, लेकिन स्पष्ट रूप से इस

184
00:08:16,940 --> 00:08:18,600
मैं चाहता था व्यवहार नहीं है.

185
00:08:18,600 --> 00:08:19,800
तो सरल समाधान क्या है?

186
00:08:19,800 --> 00:08:25,650
खैर, scanf-2 में, मुझे का प्रस्ताव करते हैं कि
बजाय वास्तव में सिर्फ एक आवंटन की

187
00:08:25,650 --> 00:08:30,100
चार *, मेरे बारे में एक छोटे से होशियार रहने दो
यह है, और मुझे बफर आवंटित करते हैं

188
00:08:30,100 --> 00:08:32,940
16 अक्षरों का एक दृश्य के रूप में.

189
00:08:32,940 --> 00:08:34,200
>> तो मैं तरीके के एक जोड़े में ऐसा कर सकते हैं.

190
00:08:34,200 --> 00:08:35,610
मैं पूरी तरह से malloc इस्तेमाल कर सकते हैं.

191
00:08:35,610 --> 00:08:38,980
लेकिन मैं सप्ताह में दो को वापस जा सकते हैं जब
मैं सिर्फ एक पूरी गुच्छा की जरूरत

192
00:08:38,980 --> 00:08:39,620
अक्षर.

193
00:08:39,620 --> 00:08:40,860
वह सिर्फ एक सरणी है.

194
00:08:40,860 --> 00:08:44,870
तो मुझे बजाय बफर को फिर से परिभाषित करते हैं
16 अक्षरों का एक सरणी.

195
00:08:44,870 --> 00:08:47,340
>> और अब, मैं में बफर पारित जब -

196
00:08:47,340 --> 00:08:49,940
और यह हम नहीं था कुछ है
सप्ताह में दो के बारे में बात करते हैं -

197
00:08:49,940 --> 00:08:53,730
लेकिन आप एक सरणी के रूप में इलाज कर सकते हैं
यह एक पता है, हालांकि.

198
00:08:53,730 --> 00:08:56,390
तकनीकी तौर पर, हमने देखा है, वे कर रहे हैं
अलग एक छोटा सा.

199
00:08:56,390 --> 00:09:01,290
आप इसे पारित लेकिन अगर scanf बुरा नहीं लगेगा
किसी सरणी का नाम, क्योंकि क्या

200
00:09:01,290 --> 00:09:05,030
हमें अनिवार्य रूप से है के लिए बजना क्या करेंगे
जैसा कि सरणी के नाम का इलाज

201
00:09:05,030 --> 00:09:08,280
16 बाइट्स का हिस्सा का पता.

202
00:09:08,280 --> 00:09:09,550
>> तो यह बेहतर है.

203
00:09:09,550 --> 00:09:12,110
यह अब है कि मुझे उम्मीद है कि सकता है इसका मतलब
निम्नलिखित है.

204
00:09:12,110 --> 00:09:16,800
मुझे एक पल के लिए बाहर ज़ूम करते हैं और
scanf -2, ठीक संकलित कर सकता हूँ.

205
00:09:16,800 --> 00:09:19,390
अब मुझे स्लैश scanf -2 मिला करते हैं.

206
00:09:19,390 --> 00:09:22,430
स्ट्रिंग कृपया. "नमस्ते." और यह
इस समय काम करने के लिए लग रहा था.

207
00:09:22,430 --> 00:09:26,020
>> लेकिन किसी एक परिदृश्य प्रस्ताव कर सकते हैं
यह अभी भी काम नहीं कर सकता जो में?

208
00:09:26,020 --> 00:09:28,550
हाँ?

209
00:09:28,550 --> 00:09:30,640
16 वर्णों से अधिक कुछ है.

210
00:09:30,640 --> 00:09:32,020
और वास्तव में, हम हो सकता है
एक छोटे से अधिक सटीक.

211
00:09:32,020 --> 00:09:36,540
अब तो 15 अक्षर कुछ,
वास्तव में हम ध्यान में रखने की जरूरत है क्योंकि

212
00:09:36,540 --> 00:09:39,920
हम चाहते हैं कि बैकस्लैश शून्य की जरूरत है कि
उलझाव स्ट्रिंग के अंत में,

213
00:09:39,920 --> 00:09:42,950
एक तरफ scanf आम तौर पर जो होगा
हमारे लिए ध्यान रखना.

214
00:09:42,950 --> 00:09:46,210
>> तो मेरे जैसे कुछ करते हैं -

215
00:09:46,210 --> 00:09:48,040
कभी कभी हम कर सकते हैं बस
यह उस तरह छोड़ दें.

216
00:09:48,040 --> 00:09:50,630
ठीक है, तो हम अब प्रेरित किया है
हमारे विखंडन दोष.

217
00:09:50,630 --> 00:09:51,000
क्यों?

218
00:09:51,000 --> 00:09:54,940
मैं 15 से अधिक करने के लिए टाइप की वजह
वर्ण, और इसलिए हम है वास्तव में

219
00:09:54,940 --> 00:09:58,280
छुआ स्मृति कि मैं वास्तव में
नहीं होना चाहिए.

220
00:09:58,280 --> 00:10:00,180
>> तो क्या सच में यहाँ समाधान है?

221
00:10:00,180 --> 00:10:02,210
ठीक है, हम एक लंबी स्ट्रिंग क्या जरूरत है?

222
00:10:02,210 --> 00:10:03,960
ठीक है, हम शायद यह 32 बाइट्स बनाते हैं.

223
00:10:03,960 --> 00:10:05,160
खैर, क्या है कि लंबे समय पर्याप्त नहीं है तो क्या होगा?

224
00:10:05,160 --> 00:10:06,040
कैसे 64 बाइट्स के बारे में?

225
00:10:06,040 --> 00:10:07,080
क्या है कि लंबे समय पर्याप्त नहीं है तो क्या होगा?

226
00:10:07,080 --> 00:10:09,640
कैसे 128 या 200 बाइट्स के बारे में?

227
00:10:09,640 --> 00:10:12,660
वास्तव में यहाँ समाधान क्या है
सामान्य मामले, हम में पता नहीं है अगर

228
00:10:12,660 --> 00:10:14,460
उपयोगकर्ता टाइप करने के लिए क्या हो रहा है अग्रिम?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> यह गधा में बस की तरह एक बड़ा दर्द है,
ईमानदार होना करने के लिए, जो है क्यों

231
00:10:23,050 --> 00:10:29,050
CS50 पुस्तकालय कुछ दर्जन लाइनों की है
सामूहिक रूप से लागू है कि कोड

232
00:10:29,050 --> 00:10:32,390
हम नहीं करते कि एक तरह से स्ट्रिंग GetString
अग्रिम में पता है क्या

233
00:10:32,390 --> 00:10:33,430
उपयोगकर्ता टाइप करने के लिए जा रहा है.

234
00:10:33,430 --> 00:10:37,370
विशेष रूप से, आप में वापस देखो
दो सप्ताह पहले से cs50.c, आप देखेंगे

235
00:10:37,370 --> 00:10:40,480
कि GetString वास्तव में करता है
इस तरह से scanf का उपयोग नहीं.

236
00:10:40,480 --> 00:10:43,720
दरअसल, यह एक चरित्र पढ़ता
एक समय में.

237
00:10:43,720 --> 00:10:46,010
>> क्योंकि एक के बारे में अच्छी बात यह है
एक चरित्र पढ़ने में हम कर सकते है

238
00:10:46,010 --> 00:10:48,490
हमेशा के लिए खुद की गारंटी
कम से कम एक चार है.

239
00:10:48,490 --> 00:10:51,740
मैं सिर्फ एक चार की घोषणा, और तब ले जा सकते हैं
अभी तक ये वास्तव में बच्चे के कदम

240
00:10:51,740 --> 00:10:54,380
एक में में एक चरित्र को पढ़ने
कीबोर्ड से समय.

241
00:10:54,380 --> 00:10:58,240
और फिर, क्या आप GetString देखेंगे
है, यह से बाहर चलाता है हर समय है

242
00:10:58,240 --> 00:11:02,280
कहते हैं, स्मृति के 16 बाइट्स, यह उपयोग करता है
malloc, या एक चचेरा भाई उसके लिए

243
00:11:02,280 --> 00:11:06,810
पुराने नकल, और अधिक स्मृति आवंटित
रेंगने तो नई है, और में स्मृति

244
00:11:06,810 --> 00:11:09,900
साथ एक समय में एक चरित्र हो रही है,
और यह है कि से बाहर चलाता है

245
00:11:09,900 --> 00:11:13,370
स्मृति का हिस्सा, पकड़ लेता है, इसे दूर फेंकता
स्मृति का एक बड़ा हिस्सा, प्रतियां पुराने

246
00:11:13,370 --> 00:11:14,750
नई, और दोहराता में.

247
00:11:14,750 --> 00:11:18,480
और यह वास्तव में वास्तव में एक दर्द है
के रूप में सरल कुछ को लागू

248
00:11:18,480 --> 00:11:19,710
एक उपयोगकर्ता से इनपुट हो रही है.

249
00:11:19,710 --> 00:11:21,090
>> तो आप scanf का उपयोग कर सकते हैं.

250
00:11:21,090 --> 00:11:22,430
आप अन्य इसी तरह के कार्यों का उपयोग कर सकते हैं.

251
00:11:22,430 --> 00:11:25,420
और ऑनलाइन पाठ्य पुस्तकों का एक बहुत
उदाहरण करते हैं, लेकिन वे सभी कर रहे हैं

252
00:11:25,420 --> 00:11:27,210
इस तरह की समस्याओं की चपेट में.

253
00:11:27,210 --> 00:11:29,550
और अंत में, एक segfault हो रही
एक तरह से परेशान है.

254
00:11:29,550 --> 00:11:30,680
यह उपयोगकर्ता के लिए अच्छा नहीं है.

255
00:11:30,680 --> 00:11:33,560
>> लेकिन सबसे खराब स्थिति में, क्या करता है
यह मौलिक डाल अपने

256
00:11:33,560 --> 00:11:37,160
के जोखिम में कोड?

257
00:11:37,160 --> 00:11:39,250
संभावित हमले के कुछ प्रकार,.

258
00:11:39,250 --> 00:11:41,680
हम के बारे में ऐसे ही एक हमले में बात की -
ढेर बह निकला.

259
00:11:41,680 --> 00:11:44,660
लेकिन सामान्य तौर पर, आप की अनुमति दी हो अगर
हम किया था, एक बफर अतिप्रवाह एक

260
00:11:44,660 --> 00:11:48,070
सिर्फ लिखने के साथ सप्ताह पहले की जोड़ी,
जितना अधिक आप ढेर पर "नमस्ते" से

261
00:11:48,070 --> 00:11:52,330
वास्तव में, संभावित, पर ले जा सकते हैं
कंप्यूटर, या कम से कम डेटा पर मिलता है

262
00:11:52,330 --> 00:11:53,510
आप का नहीं है.

263
00:11:53,510 --> 00:11:55,970
>> हमारे पास तो यही कारण है संक्षेप में, यह है
उन प्रशिक्षण पहियों.

264
00:11:55,970 --> 00:11:59,090
लेकिन अब, हम उन्हें दूर ले शुरू
हमारे कार्यक्रमों अब कोई ज़रूरत नहीं के रूप में,

265
00:11:59,090 --> 00:12:00,610
जरूरी उपयोगकर्ता से इनपुट.

266
00:12:00,610 --> 00:12:03,960
लेकिन समस्या के मामले में छह सेट,
अपने इनपुट एक विशाल से आ जाएगा

267
00:12:03,960 --> 00:12:07,520
150 से कुछ के साथ शब्दकोश फ़ाइल
हजार अजीब शब्द.

268
00:12:07,520 --> 00:12:10,330
>> तो आप के बारे में चिंता करने की ज़रूरत नहीं होगी
उपयोगकर्ता का मनमाना इनपुट.

269
00:12:10,330 --> 00:12:13,720
हम आपको कुछ मान्यताओं दे देंगे
उस फ़ाइल के बारे में.

270
00:12:13,720 --> 00:12:20,340
संकेत या scanf पर किसी भी सवाल
या सामान्य में उपयोगकर्ता इनपुट?

271
00:12:20,340 --> 00:12:24,450
>> ठीक है, तो एक पर तो एक त्वरित देखो
दो सप्ताह पहले से विषय अनुगामी.

272
00:12:24,450 --> 00:12:28,590
और कहा कि एक संरचना की इस धारणा थी.

273
00:12:28,590 --> 00:12:34,180
ऐसा नहीं है कि - एक की इस धारणा
संरचना, क्या जो था?

274
00:12:34,180 --> 00:12:35,430
संरचना हमारे लिए क्या किया?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> परिभाषित करें -

277
00:12:39,860 --> 00:12:41,710
क्षमा करें?

278
00:12:41,710 --> 00:12:42,820
एक चर प्रकार परिभाषित करें.

279
00:12:42,820 --> 00:12:44,410
तो ऐसा.

280
00:12:44,410 --> 00:12:46,180
हम वास्तव में दो विषयों के संयोजन कर रहे हैं.

281
00:12:46,180 --> 00:12:49,510
तो typedef के साथ, याद हम कर सकते हैं कि
एक तरह हमारी खुद की एक प्रकार है, की घोषणा

282
00:12:49,510 --> 00:12:51,500
चार के लिए स्ट्रिंग * जैसे पर्याय,.

283
00:12:51,500 --> 00:12:56,200
लेकिन typedef और संरचना का उपयोग कर, हम कर सकते हैं
सही मायने में हमारे अपने डेटा संरचना बनाने.

284
00:12:56,200 --> 00:12:59,600
>> उदाहरण के लिए, मैं जीएडिट में वापस जाना है
यहां सिर्फ एक पल के लिए, और मुझे आगे जाना है

285
00:12:59,600 --> 00:13:08,230
और कुछ करना पसंद है, मुझे बचाने के लिए
इस रूप में, हम कहते हैं, structs.c

286
00:13:08,230 --> 00:13:10,840
अस्थायी रूप से, मैं अभी जा रहा हूँ
आगे बढ़ो और शामिल करने के लिए

287
00:13:10,840 --> 00:13:14,360
standardio.h, int मुख्य शून्य.

288
00:13:14,360 --> 00:13:18,960
और फिर यहाँ में, मैं चाहता हूँ कि लगता है
एक प्रोग्राम लिखने के लिए भंडार है कि

289
00:13:18,960 --> 00:13:21,840
कई से कई छात्रों
घरों, उदाहरण के लिए.

290
00:13:21,840 --> 00:13:24,430
तो यह एक registrarial की तरह है
किसी प्रकार के डेटाबेस.

291
00:13:24,430 --> 00:13:29,550
>> मैं नाम से एक छात्र की जरूरत है ताकि अगर, मैं
चार * नाम की तरह कुछ कर सकता है,

292
00:13:29,550 --> 00:13:31,570
और मैं ऐसा कुछ करता हूँ -

293
00:13:31,570 --> 00:13:34,410
वास्तव में, के CS50 पुस्तकालय का उपयोग करते हैं
इस एक बनाने के लिए बस एक पल के लिए

294
00:13:34,410 --> 00:13:38,380
थोड़ा आसान है, तो हम उधार ले सकते हैं
कोड की लाइनों की उन दर्जनों.

295
00:13:38,380 --> 00:13:39,340
और चलो बस इसे सरल रखने के लिए.

296
00:13:39,340 --> 00:13:42,610
हम स्ट्रिंग रखना होगा,
और अब GetString.

297
00:13:42,610 --> 00:13:47,420
>> इसलिए मुझे लगता है कि मैं नाम संग्रहीत किया है कि अब दावा
कुछ छात्र, और के घर की

298
00:13:47,420 --> 00:13:50,240
कुछ छात्र, बस चर का उपयोग
जैसे हमने किया और एक सप्ताह में.

299
00:13:50,240 --> 00:13:52,370
लेकिन मैं अब का समर्थन करना चाहते हैं
कई छात्रों को.

300
00:13:52,370 --> 00:13:58,460
ठीक है, तो अपनी प्रवृत्ति ऐसा करने के लिए कर रहे हैं
स्ट्रिंग NAME2, GetString, स्ट्रिंग हो जाता है

301
00:13:58,460 --> 00:14:01,370
house2 GetString हो जाता है.

302
00:14:01,370 --> 00:14:05,850
और फिर हमारे तीसरे छात्र,
के name3 GetString करते हैं.

303
00:14:05,850 --> 00:14:09,170
>> ठीक है, तो यह उम्मीद है कि हड़ताली है
आप के रूप में बेवकूफ की तरह,

304
00:14:09,170 --> 00:14:11,580
इस प्रक्रिया को वास्तव में कभी नहीं है क्योंकि
अंत करने के लिए जा रहा है, और यह सिर्फ जा रहा है

305
00:14:11,580 --> 00:14:13,130
मेरे कोड देख भी बदतर बना
और बदतर और बदतर.

306
00:14:13,130 --> 00:14:14,810
लेकिन हम दो सप्ताह में भी इस का हल.

307
00:14:14,810 --> 00:14:19,450
हमारे अपेक्षाकृत स्वच्छ समाधान क्या था
हम में से कई चर था जब

308
00:14:19,450 --> 00:14:23,580
सभी संबंधित हैं, लेकिन कर रहे हैं कि एक ही डेटा प्रकार
हम इस नृशंस गड़बड़ नहीं करना चाहता था

309
00:14:23,580 --> 00:14:26,870
की इसी चर नाम दिया?

310
00:14:26,870 --> 00:14:30,060
हम बजाय क्या किया?

311
00:14:30,060 --> 00:14:31,260
>> इसलिए मुझे लगता है मैं कुछ स्थानों के बारे में सुना लगता है.

312
00:14:31,260 --> 00:14:32,590
हम एक सरणी था.

313
00:14:32,590 --> 00:14:37,110
आप के कई उदाहरण चाहते हैं
कुछ, क्यों हम यह सब साफ नहीं है

314
00:14:37,110 --> 00:14:39,540
ऊपर और बस का कहना है, मुझे दे
सरणी के नाम कहा जाता है?

315
00:14:39,540 --> 00:14:41,640
>> और अब के लिए, की हार्ड कोड 3 चलो.

316
00:14:41,640 --> 00:14:44,450
और फिर मुझे एक और सरणी दे
घरों कहा जाता है, और के लिए मुझे दो

317
00:14:44,450 --> 00:14:45,800
अब मुश्किल कोड 3.

318
00:14:45,800 --> 00:14:49,220
और मैं उसे बड़े पैमाने पर साफ कर दिया है
मैं अभी बनाया है कि गंदगी.

319
00:14:49,220 --> 00:14:52,400
अब, मैं अभी भी कड़ी मेहनत 3 कोडित है, लेकिन और भी
3 गतिशील रूप से आ सकता है

320
00:14:52,400 --> 00:14:54,350
उपयोगकर्ता, या argv, या पसंद है.

321
00:14:54,350 --> 00:14:55,720
तो यह पहले से ही क्लीनर है.

322
00:14:55,720 --> 00:15:00,100
>> लेकिन क्या इस बारे में परेशान है है कि
अब, एक नाम किसी न किसी तरह है, भले ही

323
00:15:00,100 --> 00:15:02,280
मूलरूप से जुड़ा हुआ
एक छात्र के घर -

324
00:15:02,280 --> 00:15:04,720
यह है कि मैं वास्तव में एक छात्र है
का प्रतिनिधित्व करना चाहते हैं -

325
00:15:04,720 --> 00:15:08,080
मैं अब समानांतर हैं कि दो सरणियों है
वे कर रहे हैं कि समझ में

326
00:15:08,080 --> 00:15:13,930
एक ही आकार, और नाम ब्रैकेट 0
शायद, घरों ब्रैकेट 0 नक्शे

327
00:15:13,930 --> 00:15:16,600
और नाम 1 नक्शे कोष्ठक
घरों के लिए 1 ब्रैकेट.

328
00:15:16,600 --> 00:15:19,280
दूसरे शब्दों में, कि छात्र में रहती है
उस घर, और कहा कि अन्य छात्र

329
00:15:19,280 --> 00:15:20,530
कि दूसरे घर में रहती है.

330
00:15:20,530 --> 00:15:23,720
लेकिन निश्चित रूप से यह हो सकता है
और भी अधिक सफाई से किया.

331
00:15:23,720 --> 00:15:24,990
>> खैर, यह वास्तव में, यह कर सकते हैं.

332
00:15:24,990 --> 00:15:28,730
और मुझे आगे जाना है और खुला
structs.h ऊपर, और तुम हूँ

333
00:15:28,730 --> 00:15:31,130
यहाँ इस विचार को देखें.

334
00:15:31,130 --> 00:15:34,905
मैं आप के रूप में, typedef का उपयोग किया है कि नोटिस
घोषणा करने के लिए एक पल पहले तक alluded हमारे

335
00:15:34,905 --> 00:15:35,570
खुद के डेटा प्रकार.

336
00:15:35,570 --> 00:15:39,660
लेकिन मैं भी इस दूसरे कीवर्ड का उपयोग कर रहा हूँ
मुझे एक नया देता है जो बुलाया संरचना

337
00:15:39,660 --> 00:15:40,790
डेटा संरचना.

338
00:15:40,790 --> 00:15:43,980
>> और मैं दावा यह आंकड़ा संरचना जा रहा है
के अंदर दो बातों के लिए

339
00:15:43,980 --> 00:15:47,060
यह - नाम नामक एक स्ट्रिंग, और
एक स्ट्रिंग घर बुलाया.

340
00:15:47,060 --> 00:15:49,820
और नाम मैं करने के लिए देने के लिए जा रहा हूँ
इस डेटा संरचना जा रहा है

341
00:15:49,820 --> 00:15:51,005
छात्र बुलाया जाए.

342
00:15:51,005 --> 00:15:54,030
मैं मैं चाहता हूँ कुछ भी कह सकते हैं,
लेकिन इस शब्दार्थ बनाने

343
00:15:54,030 --> 00:15:55,810
मेरे मन में मेरे लिए कोई मतलब.

344
00:15:55,810 --> 00:15:59,160
>> तो अब, मैं एक बेहतर संस्करण को खोलने अगर
कार्यक्रम की मैं लिखना शुरू कर दिया

345
00:15:59,160 --> 00:16:00,390
वहाँ, मुझे शीर्ष पर स्क्रॉल करते हैं.

346
00:16:00,390 --> 00:16:03,190
और कोड के कुछ और लाइनें है
यहाँ, लेकिन मेरे लिए ध्यान केंद्रित

347
00:16:03,190 --> 00:16:04,160
एक पर पल.

348
00:16:04,160 --> 00:16:07,790
मैं छात्रों को बुलाया एक निरंतर घोषित कर दिया है
और कठिन अब के लिए 3 कोडित.

349
00:16:07,790 --> 00:16:11,110
लेकिन अब, नोटिस कैसे साफ
मेरे कोड प्राप्त करने के लिए शुरू होता है.

350
00:16:11,110 --> 00:16:15,030
>> लाइन 22 में, मैं घोषणा
छात्रों की सरणी.

351
00:16:15,030 --> 00:16:18,760
और कहा कि छात्र जाहिरा तौर पर है नोटिस
अब एक डेटा प्रकार.

352
00:16:18,760 --> 00:16:23,360
इस वजह से फाइल, नोटिस के शीर्ष पर
मुझे लगता है कि हैडर फ़ाइल शामिल किया है

353
00:16:23,360 --> 00:16:24,820
मैं बस एक पल पहले तक खींच लिया है.

354
00:16:24,820 --> 00:16:28,820
और कहा कि शीर्ष फाइल काफी बस था
एक छात्र की इस परिभाषा.

355
00:16:28,820 --> 00:16:32,470
>> तो अब, मैं अपने स्वयं के कस्टम डेटा बनाया है
टाइप सी कि साल के लेखकों

356
00:16:32,470 --> 00:16:33,890
पहले अग्रिम में नहीं सोचा.

357
00:16:33,890 --> 00:16:34,570
लेकिन कोई बात नहीं.

358
00:16:34,570 --> 00:16:35,870
मैं इसे अपने आप कर सकते हैं.

359
00:16:35,870 --> 00:16:39,050
तो यह छात्रों को बुलाया एक सरणी है
जिसका सदस्यों में से प्रत्येक

360
00:16:39,050 --> 00:16:41,100
एक छात्र संरचना है.

361
00:16:41,100 --> 00:16:44,270
और मैं चाहता हूँ कि उन में से तीन
सरणी में.

362
00:16:44,270 --> 00:16:46,030
>> और अब, क्या बाकी है
इस कार्यक्रम की क्या ज़रूरत है?

363
00:16:46,030 --> 00:16:47,550
मैं एक छोटे से मनमाने ढंग से कुछ की जरूरत है.

364
00:16:47,550 --> 00:16:51,450
तो, आगे 24 ऑनलाइन से
मैं 0-3 पुनरावृति.

365
00:16:51,450 --> 00:16:54,000
मैं तो के लिए उपयोगकर्ता पूछना
छात्र का नाम.

366
00:16:54,000 --> 00:16:56,110
और फिर मैं पहले की तरह GetString का उपयोग करें.

367
00:16:56,110 --> 00:16:59,410
तब मैं छात्र के घर के लिए पूछना,
और मैं पहले की तरह GetString का उपयोग करें.

368
00:16:59,410 --> 00:17:01,780
>> लेकिन सूचना - थोड़ा नया
वाक्यविन्यास का टुकड़ा -

369
00:17:01,780 --> 00:17:07,010
मैं, मैं वें छात्र को अभी भी सूचकांक कर सकते हैं
लेकिन कैसे मैं विशिष्ट डेटा पर मिलता है

370
00:17:07,010 --> 00:17:08,354
संरचना के अंदर क्षेत्र?

371
00:17:08,354 --> 00:17:11,770
खैर, जाहिरा तौर पर क्या है
वाक्यविन्यास का नया टुकड़ा?

372
00:17:11,770 --> 00:17:13,339
यह सिर्फ डॉट ऑपरेटर है.

373
00:17:13,339 --> 00:17:14,510
>> हम वास्तव में इस से पहले नहीं देखा है.

374
00:17:14,510 --> 00:17:17,819
आप आपने अगर pset पांच में यह देखा है
बिटमैप फ़ाइलों के साथ पहले से ही में डुबकी लगाई.

375
00:17:17,819 --> 00:17:22,372
लेकिन डॉट सिर्फ इस के अंदर का मतलब
संरचना या कई क्षेत्रों, डॉट दे

376
00:17:22,372 --> 00:17:24,510
नाम, या मुझे डॉट घर दे.

377
00:17:24,510 --> 00:17:28,690
उस संरचना के अंदर जाने का मतलब
और विशेष रूप से उन क्षेत्रों को मिलता है.

378
00:17:28,690 --> 00:17:30,200
>> इस कार्यक्रम के बाकी क्या करता है?

379
00:17:30,200 --> 00:17:31,190
यह सब है कि सेक्सी नहीं है.

380
00:17:31,190 --> 00:17:34,640
मैं फिर से 0-3 पुनरावृति सूचना है कि,
और मैं बस एक अंग्रेजी बना

381
00:17:34,640 --> 00:17:40,500
इतना और इतनी तरह मुहावरा ऐसे और में है
ऐसे घर से डॉट नाम में गुजर

382
00:17:40,500 --> 00:17:43,320
i-वीं के छात्र और उनके
घर के रूप में अच्छी तरह से.

383
00:17:43,320 --> 00:17:47,560
>> और फिर अंत में, अब हम पाने के लिए शुरू करेंगे
इस बारे में गुदा, अब हम कर रहे हैं कि

384
00:17:47,560 --> 00:17:49,580
क्या malloc से परिचित और
अन्य कार्यों के लिए किया गया है

385
00:17:49,580 --> 00:17:50,570
यह सब समय कर रहे हैं.

386
00:17:50,570 --> 00:17:54,220
क्यों मैं नाम दोनों को मुक्त करने की क्या ज़रूरत है
और घर, भले ही मैं

387
00:17:54,220 --> 00:17:56,960
malloc फोन नहीं किया?

388
00:17:56,960 --> 00:17:58,020
>> GetString किया.

389
00:17:58,020 --> 00:18:00,930
और उसके लिए गंदे छोटे से रहस्य था
कई हफ्तों, लेकिन GetString है

390
00:18:00,930 --> 00:18:03,530
सब से अधिक स्मृति लीक किया गया
इस प्रकार अब तक सभी सेमेस्टर जगह है.

391
00:18:03,530 --> 00:18:05,990
और valgrand अंत में होगा
हमारे लिए यह प्रकट करते हैं.

392
00:18:05,990 --> 00:18:10,730
>> क्योंकि मुझे पता है लेकिन यह एक बड़ा सौदा नहीं है
मैं बस नाम मुक्त कर सकते हैं

393
00:18:10,730 --> 00:18:15,750
और घर, तकनीकी, हालांकि
सुपर, सुपर सुरक्षित, मैं होना चाहिए

394
00:18:15,750 --> 00:18:17,890
यहाँ की जाँच के कुछ त्रुटि रही.

395
00:18:17,890 --> 00:18:19,040
आप कह रही है अपने सहज ज्ञान क्या हैं?

396
00:18:19,040 --> 00:18:22,480
मैं के लिए क्या जाँच की जानी चाहिए
मैं एक है क्या मुक्त करने से पहले

397
00:18:22,480 --> 00:18:25,470
स्ट्रिंग, उर्फ ​​जो एक चार *?

398
00:18:25,470 --> 00:18:33,460
>> छात्रों अगर मैं वास्तव में जाँच की जानी चाहिए
ब्रैकेट मैं नाम नहीं करता है डॉट

399
00:18:33,460 --> 00:18:34,840
बराबर अशक्त.

400
00:18:34,840 --> 00:18:40,400
तो यह आगे जाने के लिए ठीक है और मुक्त हो जाएगा
कि सूचक, और उसी या अन्य

401
00:18:40,400 --> 00:18:41,160
एक के रूप में अच्छी तरह से.

402
00:18:41,160 --> 00:18:46,860
छात्रों मैं डॉट कोष्ठक तो घर नहीं है
अशक्त करने के लिए बराबर है, यह अब रक्षा करेगा

403
00:18:46,860 --> 00:18:52,520
कोने मामले के खिलाफ जो में
GetString बातिल की तरह कुछ देता है.

404
00:18:52,520 --> 00:18:57,310
और हम एक क्षण पहले, printf इच्छा देखा
बस कह कर हमें यहाँ ऊपर की रक्षा

405
00:18:57,310 --> 00:18:58,990
अशक्त, अजीब लग रहा है, जो.

406
00:18:58,990 --> 00:19:02,340
लेकिन कम से कम यह segfault नहीं होगा,
हमने देखा है.

407
00:19:02,340 --> 00:19:05,990
>> खैर, मुझे यहां एक और बात करते हैं.
structs -0 एक बेवकूफ कार्यक्रम की तरह है

408
00:19:05,990 --> 00:19:09,700
मैं तो यह सभी डेटा दर्ज करें, और क्योंकि
कार्यक्रम समाप्त होता है एक बार वह खो दिया है.

409
00:19:09,700 --> 00:19:10,940
लेकिन मुझे आगे जाना है और यह करते हैं.

410
00:19:10,940 --> 00:19:12,830
मुझे टर्मिनल बनाने दो.
एक बड़ा सा खिड़की.

411
00:19:12,830 --> 00:19:17,000
मुझे बनाते हैं structs -1, जो
इस का एक नया संस्करण है.

412
00:19:17,000 --> 00:19:18,520
>> मैं एक छोटा सा में ज़ूम करेंगे.

413
00:19:18,520 --> 00:19:21,620
और अब मुझे डॉट चलाते हैं
स्लैश structs-1.

414
00:19:21,620 --> 00:19:22,590
छात्र का नाम -

415
00:19:22,590 --> 00:19:31,500
डेविड माथर, रोब किर्कलैंड करते हैं
के लॉरेन Leverett करते हैं.

416
00:19:31,500 --> 00:19:33,650
क्या अब दिलचस्प की सूचना है -

417
00:19:33,650 --> 00:19:35,540
और मैं केवल इस वजह से जानते हैं
मैं प्रोग्राम लिखा -

418
00:19:35,540 --> 00:19:38,930
एक फाइल मेरे वर्तमान पर अब वहाँ
निर्देशिका students.csv कहा जाता है.

419
00:19:38,930 --> 00:19:40,420
आप में से कुछ देखा हो सकता है
इन वास्तविक दुनिया में.

420
00:19:40,420 --> 00:19:42,980
>> एक सीएसवी फ़ाइल क्या है?

421
00:19:42,980 --> 00:19:44,170
अल्पविराम से अलग किए गए मान.

422
00:19:44,170 --> 00:19:46,670
यह तरह की तरह है एक गरीब आदमी का
एक एक्सेल फ़ाइल का संस्करण.

423
00:19:46,670 --> 00:19:50,580
यह पंक्तियों और स्तंभों की एक मेज है कि
आप, एक्सेल की तरह एक कार्यक्रम में खोल सकते हैं

424
00:19:50,580 --> 00:19:51,800
या एक मैक पर संख्या.

425
00:19:51,800 --> 00:19:55,180
>> और मैं जीएडिट पर यहाँ इस फाइल को खोलते हैं,
सूचना - और संख्या वहाँ नहीं कर रहे हैं.

426
00:19:55,180 --> 00:19:57,360
वह सिर्फ जीएडिट कह रही है
मुझे नंबर लाइन.

427
00:19:57,360 --> 00:19:59,740
इस की पहली पंक्ति पर नोटिस
फ़ाइल दाऊद और माथर है.

428
00:19:59,740 --> 00:20:01,450
अगली पंक्ति रोब अल्पविराम किर्कलैंड है.

429
00:20:01,450 --> 00:20:04,170
और तीसरी पंक्ति लॉरेन है
अल्पविराम Leverett.

430
00:20:04,170 --> 00:20:05,480
>> तो मैं क्या बनाया है?

431
00:20:05,480 --> 00:20:09,580
मैं अब एक सी प्रोग्राम लिखा है कि
प्रभावी ढंग से स्प्रेडशीट उत्पन्न कर सकते हैं

432
00:20:09,580 --> 00:20:11,840
कि एक में खोला जा सकता है
एक्सेल जैसे कार्यक्रम.

433
00:20:11,840 --> 00:20:15,520
बिल्कुल नहीं है कि सम्मोहक एक डेटा सेट, लेकिन
आप में से बहुत बड़ा हिस्सा है अगर

434
00:20:15,520 --> 00:20:18,440
आप वास्तव में चाहते हैं कि डेटा
हेरफेर और का ग्राफ बनाने और

435
00:20:18,440 --> 00:20:21,260
जैसे, यह शायद एक है
उस डेटा को बनाने के लिए जिस तरह से.

436
00:20:21,260 --> 00:20:25,370
इसके अलावा, CSVs वास्तव में सुपर आम हैं
सिर्फ साधारण डेटा संग्रहीत करने के लिए -

437
00:20:25,370 --> 00:20:28,940
याहू वित्त, उदाहरण के लिए, यदि आप प्राप्त
उनके तथाकथित के माध्यम से शेयरों के भाव

438
00:20:28,940 --> 00:20:33,180
एपीआई, आप की सुविधा देता है कि नि: शुल्क सेवा
वर्तमान अप करने की तारीख शेयर मिल

439
00:20:33,180 --> 00:20:35,650
वे, कंपनियों के लिए उद्धरण
में डेटा वापस दे

440
00:20:35,650 --> 00:20:37,800
सुपर सरल सीएसवी प्रारूप.

441
00:20:37,800 --> 00:20:39,380
>> तो हम ऐसा कैसे कर दिया?

442
00:20:39,380 --> 00:20:42,530
खैर, इस कार्यक्रम के सबसे नोटिस
लगभग एक ही.

443
00:20:42,530 --> 00:20:46,870
बल्कि प्रिंट से, यहां नीचे नोटिस
बाहर, लाइन 35 पर छात्र

444
00:20:46,870 --> 00:20:51,040
आगे, मैं मैं बचत कर रहा हूँ कि दावा
डिस्क के लिए छात्रों को, तो एक फ़ाइल बचत.

445
00:20:51,040 --> 00:20:53,630
>> इसलिए मैं * एक फाइल घोषणा कर रहा हूँ नोटिस -

446
00:20:53,630 --> 00:20:57,260
अब, यह सी में एक विसंगति की तरह है
जो भी कारण के लिए, फ़ाइल सभी टोपी है,

447
00:20:57,260 --> 00:21:00,690
सबसे अन्य डेटा प्रकार की तरह नहीं है जो
सी. में लेकिन यह एक निर्मित है

448
00:21:00,690 --> 00:21:02,320
डेटा प्रकार, फ़ाइल *.

449
00:21:02,320 --> 00:21:05,900
और मैं एक फ़ाइल के लिए एक संकेत घोषणा कर रहा हूँ,
तुम उस के बारे में सोच सकते हैं.

450
00:21:05,900 --> 00:21:08,070
>> fopen फ़ाइल खोलने का मतलब है.

451
00:21:08,070 --> 00:21:09,470
आप को खोलने के लिए क्या फ़ाइल चाहते हो?

452
00:21:09,470 --> 00:21:12,620
मैं मैं है कि एक फ़ाइल को खोलने के लिए चाहते हैं
मनमाने ढंग से students.csv कहते हैं.

453
00:21:12,620 --> 00:21:14,480
मैं चाहता हूँ कि कुछ भी कह सकते हैं.

454
00:21:14,480 --> 00:21:15,200
>> और फिर एक अनुमान ले.

455
00:21:15,200 --> 00:21:18,960
दूसरा तर्क क्या करता है
शायद fopen के लिए क्या मतलब है?

456
00:21:18,960 --> 00:21:21,480
ठीक है, डब्ल्यू लिखने के लिए, कर सकता है
पढ़ने के लिए हो आर.

457
00:21:21,480 --> 00:21:24,120
आप अगर एक संलग्न के लिए नहीं है
पंक्तियों और नहीं जोड़ना चाहते हैं

458
00:21:24,120 --> 00:21:25,200
पूरी बात को अधिलेखित.

459
00:21:25,200 --> 00:21:28,005
>> लेकिन मैं सिर्फ यह फाइल नहीं बनाना चाहता
एक बार, तो मैं बोली डब्ल्यू गंदें शब्द बोलना इस्तेमाल करेंगे.

460
00:21:28,005 --> 00:21:31,880
और मुझे पता है कि केवल पढने से
प्रलेखन, या आदमी पेज.

461
00:21:31,880 --> 00:21:35,100
फ़ाइल रिक्त नहीं है - दूसरे शब्दों में,
वहाँ कुछ भी नहीं गलत हो गया है -

462
00:21:35,100 --> 00:21:37,820
मुझे अधिक पुनरावृति करते हैं
0-3 छात्रों को.

463
00:21:37,820 --> 00:21:40,410
>> और अब वहाँ कुछ नोटिस
कभी तो थोड़ा अलग

464
00:21:40,410 --> 00:21:42,110
यहाँ लाइन 41 के बारे में.

465
00:21:42,110 --> 00:21:42,960
यह printf नहीं है.

466
00:21:42,960 --> 00:21:46,530
यह फाइल printf के लिए fprintf है.

467
00:21:46,530 --> 00:21:47,790
तो यह फ़ाइल में लिखने के लिए जा रहा है.

468
00:21:47,790 --> 00:21:48,860
कौन सा फाइल?

469
00:21:48,860 --> 00:21:53,630
जिसका सूचक आपके द्वारा निर्दिष्ट एक
पहले तर्क के रूप में.

470
00:21:53,630 --> 00:21:55,940
>> तो फिर हम एक प्रारूप स्ट्रिंग निर्दिष्ट करें.

471
00:21:55,940 --> 00:21:59,660
तब हम हम क्या चाहते हैं स्ट्रिंग निर्दिष्ट
पहला प्रतिशत के लिए में प्लग, और

472
00:21:59,660 --> 00:22:04,320
फिर एक और चर या
दूसरी प्रतिशत है.

473
00:22:04,320 --> 00:22:06,760
तो फिर हम fclose साथ फ़ाइल बंद करें.

474
00:22:06,760 --> 00:22:09,380
मैं हालांकि, पहले के रूप में स्मृति से मुक्त
मैं में वापस जाने के लिए और जोड़ने चाहिए

475
00:22:09,380 --> 00:22:10,540
अशक्त के लिए कुछ चेक.

476
00:22:10,540 --> 00:22:12,090
>> और यह बात है.

477
00:22:12,090 --> 00:22:16,960
fopen, fprintf, fclose मुझे देता है
पाठ फ़ाइलें बनाने की क्षमता.

478
00:22:16,960 --> 00:22:19,640
अब, आप समस्या से पांच सेट में देखेंगे
छवियों शामिल है, जो आप का उपयोग होगा

479
00:22:19,640 --> 00:22:20,990
बाइनरी फ़ाइलों के बजाय.

480
00:22:20,990 --> 00:22:24,200
लेकिन मूलरूप में, विचार, एक ही है
भले ही आप हूँ कार्यों

481
00:22:24,200 --> 00:22:28,710
देखना थोड़ा अलग हैं.

482
00:22:28,710 --> 00:22:32,580
>> तो बवंडर दौरे, लेकिन आप मिल जाएगा
सब भी फाइल के साथ परिचित I/O--

483
00:22:32,580 --> 00:22:34,960
इनपुट और आउटपुट - pset पाँच के साथ.

484
00:22:34,960 --> 00:22:38,607
और के बारे में किसी भी सवाल
यहां प्रारंभिक मूल बातें?

485
00:22:38,607 --> 00:22:39,857
हाँ?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> क्या आप एक नल मान को मुक्त करने की कोशिश की तो?

488
00:22:43,710 --> 00:22:48,880
मुक्त हो गया है जब तक कि मेरा मानना ​​है कि एक
उपयोगकर्ता के अनुकूल है, आप कर सकते हैं थोड़ा अधिक

489
00:22:48,880 --> 00:22:49,890
संभावित segfault.

490
00:22:49,890 --> 00:22:54,160
मैं नहीं है क्योंकि यह शून्य पासिंग बुरा है
आप के लिए जाँच करने के लिए स्वतंत्र परेशान मानना ​​है,

491
00:22:54,160 --> 00:22:57,330
यह संभवतः एक बेकार हो जाएगा क्योंकि
इसके लिए ही करने के लिए समय की

492
00:22:57,330 --> 00:22:59,022
दुनिया में हर कोई.

493
00:22:59,022 --> 00:23:00,590
अच्छा सवाल है, यद्यपि.

494
00:23:00,590 --> 00:23:04,300
>> ठीक है, तो इस तरह का हो जाता है
एक दिलचस्प विषय के लिए हमें.

495
00:23:04,300 --> 00:23:07,010
समस्या के विषय सेट
पांच फोरेंसिक है.

496
00:23:07,010 --> 00:23:08,420
कम से कम उस एक भाग है
समस्या का सेट.

497
00:23:08,420 --> 00:23:12,030
फोरेंसिक आम तौर पर करने के लिए संदर्भित करता है
कि हो सकता है या जानकारी की वसूली

498
00:23:12,030 --> 00:23:14,110
हटा दिया गया है नहीं हो सकता
जानबूझ.

499
00:23:14,110 --> 00:23:18,680
और इसलिए मुझे लगता है मैं तुम्हें एक त्वरित देने लगा
वास्तव में सब क्या हो रहा है का स्वाद

500
00:23:18,680 --> 00:23:21,230
नीचे इस समय
आपके कंप्यूटर के हुड.

501
00:23:21,230 --> 00:23:23,960
>> उदाहरण के लिए, आप के अंदर है तो अपने
लैपटॉप या अपने डेस्कटॉप कंप्यूटर एक

502
00:23:23,960 --> 00:23:28,040
हार्ड ड्राइव, यह या तो एक यांत्रिक है
वास्तव में spins कि डिवाइस -

503
00:23:28,040 --> 00:23:31,650
थाली बुलाया परिपत्र चीज़ें हैं
कि काफी क्या मैं की तरह दिखते

504
00:23:31,650 --> 00:23:34,540
अभी हालांकि, यहां स्क्रीन पर पड़ा
इस तेजी से पुराने स्कूल है.

505
00:23:34,540 --> 00:23:37,370
यह एक तीन और एक से डेढ़ इंच है
हार्ड ड्राइव.

506
00:23:37,370 --> 00:23:40,070
और साढ़े तीन इंच के लिए संदर्भित करता है
बात के साथ आप इसे स्थापित जब

507
00:23:40,070 --> 00:23:40,890
एक कंप्यूटर में.

508
00:23:40,890 --> 00:23:44,890
>> अब आपके लैपटॉप में आप लोगों में से कई
सॉलिड स्टेट ड्राइव, या SSDs है,

509
00:23:44,890 --> 00:23:46,260
नहीं चलती भागों है.

510
00:23:46,260 --> 00:23:49,170
वे और अधिक रैम की तरह और कम पसंद कर रहे हैं
इन यांत्रिक उपकरणों.

511
00:23:49,170 --> 00:23:51,450
लेकिन विचारों में अभी भी वही कर रहे हैं,
निश्चित रूप से वे संबंधित हैं

512
00:23:51,450 --> 00:23:52,790
समस्या को पांच सेट.

513
00:23:52,790 --> 00:23:57,400
>> और तुम अब एक हार्ड ड्राइव के बारे में अगर आपको लगता है
एक चक्र, किया जा रहा है जो प्रतिनिधित्व करता है

514
00:23:57,400 --> 00:23:58,930
मैं यहाँ इस तरह आकर्षित करेंगे.

515
00:23:58,930 --> 00:24:02,290
आप अपने कंप्यूटर पर एक फ़ाइल बनाते हैं,
यह एक SSD है, या में चाहे

516
00:24:02,290 --> 00:24:06,610
इस मामले में, एक पुराने स्कूल हार्ड ड्राइव,
उस फाइल कई बिट्स शामिल हैं.

517
00:24:06,610 --> 00:24:10,510
चलो यह इस 0 और 1 है कि हम कहते हैं,
0 और 1 की एक पूरी गुच्छा.

518
00:24:10,510 --> 00:24:11,660
तो यह अपने पूरे हार्ड ड्राइव है.

519
00:24:11,660 --> 00:24:13,225
यह जाहिरा तौर पर एक बहुत बड़ा फ़ाइल है.

520
00:24:13,225 --> 00:24:18,080
और यह उस पर 0 और 1 का उपयोग कर रहा है
शारीरिक थाली का भाग.

521
00:24:18,080 --> 00:24:19,750
>> खैर, कि शारीरिक भाग क्या है?

522
00:24:19,750 --> 00:24:25,310
खैर, यह पता चला है कि एक हार्ड ड्राइव पर,
इस प्रकार के कम से कम, वहाँ है

523
00:24:25,310 --> 00:24:27,340
इन छोटे छोटे चुंबकीय कणों.

524
00:24:27,340 --> 00:24:32,630
और वे अनिवार्य रूप से उत्तर दिया है और
उन्हें दक्षिण डंडे, इतना है कि आप अगर

525
00:24:32,630 --> 00:24:35,710
उन चुंबकीय कणों में से एक बारी
इस तरह, आप यह कह सकते हैं कि

526
00:24:35,710 --> 00:24:36,720
एक 1 का प्रतिनिधित्व.

527
00:24:36,720 --> 00:24:39,340
और यह करने के लिए दक्षिण उल्टा है अगर
उत्तरी, आप यह कह सकते हैं कि

528
00:24:39,340 --> 00:24:40,390
एक 0 का प्रतिनिधित्व.

529
00:24:40,390 --> 00:24:43,660
>> तो वास्तविक भौतिक दुनिया में, कि
आप में कुछ का प्रतिनिधित्व कर सकता कैसे

530
00:24:43,660 --> 00:24:45,670
बाइनरी 0 से राज्य और एक 1.

531
00:24:45,670 --> 00:24:46,720
ताकि सभी एक फाइल है.

532
00:24:46,720 --> 00:24:49,300
चुंबकीय की एक पूरी गुच्छा है
उनके इस तरह से कर रहे हैं या कि कणों

533
00:24:49,300 --> 00:24:51,920
इस तरह, बनाने पैटर्न
0 और 1 की.

534
00:24:51,920 --> 00:24:56,760
>> आप एक फ़ाइल को बचाने लेकिन जब यह पता चला है,
कुछ जानकारी अलग से बचाया है.

535
00:24:56,760 --> 00:25:00,000
तो यह एक छोटी मेज है,
इतनी बात करने के लिए एक निर्देशिका,.

536
00:25:00,000 --> 00:25:05,810
और मैं इस स्तंभ नाम फोन, और हूँ
मैं इस कॉलम स्थान बुलाता हूँ.

537
00:25:05,810 --> 00:25:08,850
>> और मुझे लगता है, कहने जा रहा हूँ
यह मेरा फिर से शुरू है.

538
00:25:08,850 --> 00:25:14,050
मेरा resume.doc में संग्रहीत किया जाता है
स्थान, 123 कहते हैं.

539
00:25:14,050 --> 00:25:15,390
मैं हमेशा उस संख्या के लिए जाना.

540
00:25:15,390 --> 00:25:18,810
लेकिन जैसे कि कहने के लिए पर्याप्त
राम में, आप एक हार्ड ड्राइव ले जा सकते हैं

541
00:25:18,810 --> 00:25:22,350
कि एक गीगाबाइट या 200 गीगाबाइट है
या एक टेराबाइट, और आप कर सकते हैं

542
00:25:22,350 --> 00:25:23,750
बाइट्स के सभी संख्या.

543
00:25:23,750 --> 00:25:26,480
आप 8 बिट के सभी हिस्सा नंबर कर सकते हैं.

544
00:25:26,480 --> 00:25:29,030
>> तो हम कह देंगे कि इस
स्थान 123 है.

545
00:25:29,030 --> 00:25:32,070
मेरे परिचालन के अंदर तो इस निर्देशिका
प्रणाली याद है मेरी

546
00:25:32,070 --> 00:25:34,250
फिर से शुरू स्थान 123 पर है.

547
00:25:34,250 --> 00:25:36,850
लेकिन यह दिलचस्प हो जाता है जब
आप एक फ़ाइल को नष्ट.

548
00:25:36,850 --> 00:25:37,820
>> उदाहरण के लिए तो -

549
00:25:37,820 --> 00:25:40,790
और शुक्र है, दुनिया की सबसे अधिक है
इस पर पकड़ा - क्या होता है जब

550
00:25:40,790 --> 00:25:45,040
आप अपने मैक ओएस कचरा पेटी में एक फ़ाइल खींचें
या अपने Windows रीसायकल बिन?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
कि ऐसा करने का उद्देश्य क्या है?

553
00:25:50,510 --> 00:25:53,860
यह फाइल से छुटकारा पाने के लिए स्पष्ट रूप से है,
लेकिन क्या खींचकर का कार्य करता है और

554
00:25:53,860 --> 00:25:57,550
अपने ट्रैश या में छोड़ने अपने
रीसायकल बिन एक कंप्यूटर पर करते हैं?

555
00:25:57,550 --> 00:25:59,230
>> बिल्कुल कुछ भी नहीं, वास्तव में.

556
00:25:59,230 --> 00:26:00,320
यह सिर्फ एक फ़ोल्डर की तरह है.

557
00:26:00,320 --> 00:26:01,800
यह सुनिश्चित किया जाना, एक विशेष फ़ोल्डर है.

558
00:26:01,800 --> 00:26:04,460
लेकिन यह वास्तव में फ़ाइल को नष्ट करता है?

559
00:26:04,460 --> 00:26:06,780
>> ठीक है, नहीं, क्योंकि आप में से कुछ शायद
लानत ओह, तुम नहीं किया, की तरह किया गया है

560
00:26:06,780 --> 00:26:07,420
ऐसा करने के लिए मतलब है.

561
00:26:07,420 --> 00:26:09,130
तो अगर आप डबल क्लिक करें
कचरा पेटी या रीसायकल बिन.

562
00:26:09,130 --> 00:26:11,630
आप आसपास poked है और तुम बरामद किया
बस इसे खींचकर फ़ाइल

563
00:26:11,630 --> 00:26:12,110
वहाँ से बाहर.

564
00:26:12,110 --> 00:26:14,420
तो जाहिर है, यह जरूरी नहीं है
इसे हटाने.

565
00:26:14,420 --> 00:26:15,990
>> ठीक है, तुम कि अधिक चालाक हो.

566
00:26:15,990 --> 00:26:18,860
तुम्हें पता है कि बस में खींच
कचरा या रीसायकल बिन मतलब यह नहीं है

567
00:26:18,860 --> 00:26:19,930
आप कचरा खाली कर रहे हैं.

568
00:26:19,930 --> 00:26:24,110
तो आप मेनू के लिए ऊपर जाना है, और तुम कहते हो
रद्दी खाली या खाली रीसायकल बिन.

569
00:26:24,110 --> 00:26:25,360
फिर क्या होता है?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> हाँ, तो यह और अधिक इसलिए हटा दिया गया है.

572
00:26:32,530 --> 00:26:37,660
लेकिन ऐसा होता है कि यह सब है.

573
00:26:37,660 --> 00:26:45,350
कंप्यूटर जहाँ भूल जाता है
resume.doc था.

574
00:26:45,350 --> 00:26:47,400
>> लेकिन क्या जाहिरा तौर पर नहीं बदला है
तस्वीर में?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
बिट्स, मैं दावा है कि 0 और 1 हैं
कुछ शारीरिक पहलू से की साइट पर

577
00:26:55,570 --> 00:26:56,280
हार्डवेयर.

578
00:26:56,280 --> 00:26:57,110
वे वहाँ अभी भी कर रहे हैं.

579
00:26:57,110 --> 00:26:58,930
यह सिर्फ कंप्यूटर की गई है
वे क्या कर रहे हैं भूल.

580
00:26:58,930 --> 00:27:03,160
>> इसलिए यह अनिवार्य रूप से मुक्त कर दिया है फ़ाइल की
बिट्स वे पुन: उपयोग किया जा सकता है.

581
00:27:03,160 --> 00:27:06,940
लेकिन यदि आप अधिक फाइलें नहीं बना जब तक
और अधिक फाइलें, और अधिक फाइलें होगा

582
00:27:06,940 --> 00:27:12,150
संभवतया, उन 0 और 1,
उन चुंबकीय कणों, पुन: उपयोग किया हो,

583
00:27:12,150 --> 00:27:16,220
के लिए ऊपर या दाएं ऊपर
अन्य फाइलें, 0 और 1.

584
00:27:16,220 --> 00:27:17,980
>> तो तुम समय की इस खिड़की है.

585
00:27:17,980 --> 00:27:19,860
और यह उम्मीद के मुताबिक की नहीं है
लंबाई, वास्तव में.

586
00:27:19,860 --> 00:27:22,240
यह आपके हार्ड के आकार पर निर्भर करता है
ड्राइव और कितने फ़ाइलें आप की है और

587
00:27:22,240 --> 00:27:23,490
कितनी जल्दी आप नए बनाते हैं.

588
00:27:23,490 --> 00:27:27,050
लेकिन समय की इस विंडो के दौरान वहाँ
उस फ़ाइल को पूरी तरह से अभी भी है जो

589
00:27:27,050 --> 00:27:27,770
वसूली.

590
00:27:27,770 --> 00:27:31,050
>> तो तुम कभी McAfee जैसे कार्यक्रमों का उपयोग करते हैं
या Norton ठीक करने के लिए प्रयास करने के लिए

591
00:27:31,050 --> 00:27:35,680
डेटा, वे सब कर रहे हैं करने के लिए कोशिश कर रहा है
करने के लिए इस तथाकथित निर्देशिका की वसूली

592
00:27:35,680 --> 00:27:37,340
आपकी फ़ाइल था जहां यह पता लगाने.

593
00:27:37,340 --> 00:27:40,605
और कभी कभी Norton और कहेंगे,
फाइल 93% वसूली योग्य है.

594
00:27:40,605 --> 00:27:42,020
खैर, इसका क्या मतलब है?

595
00:27:42,020 --> 00:27:45,690
वह सिर्फ मतलब है कि कुछ अन्य फ़ाइल
संयोग से, कहते हैं, का उपयोग कर समाप्त

596
00:27:45,690 --> 00:27:48,920
अपने मूल फाइल से बाहर उन बिट्स.

597
00:27:48,920 --> 00:27:51,950
>> तो शामिल वास्तव में क्या है
डाटा की वसूली में?

598
00:27:51,950 --> 00:27:55,720
खैर, आप की तरह कुछ भी नहीं है अगर
नॉर्टन आपके कंप्यूटर पर पहले से स्थापित,

599
00:27:55,720 --> 00:27:59,510
आप कभी कभी ऐसा कर सकते हैं सर्वोत्तम है
की तलाश में पूरे हार्ड ड्राइव पर

600
00:27:59,510 --> 00:28:00,510
बिट्स के पैटर्न.

601
00:28:00,510 --> 00:28:05,350
और समस्या के विषयों में से एक सेट
पाँच आप खोज करेंगे कि है

602
00:28:05,350 --> 00:28:09,570
एक हार्ड ड्राइव के बराबर, एक फोरेंसिक
एक से एक कॉम्पैक्ट फ़्लैश कार्ड की छवि

603
00:28:09,570 --> 00:28:13,660
डिजिटल कैमरा, 0s के लिए खोज
और कहा कि आम तौर पर, साथ 1s उच्च

604
00:28:13,660 --> 00:28:16,720
संभावना का प्रतिनिधित्व
एक JPEG छवि के लगते हैं.

605
00:28:16,720 --> 00:28:21,120
>> और तुम लोगों ने उन छवियों को ठीक कर सकते हैं
मैं इस पैटर्न के देखते हैं, यह सोचते हैं

606
00:28:21,120 --> 00:28:24,380
साथ फोरेंसिक छवि, पर बिट्स
प्रबल संभावना है कि, निशान

607
00:28:24,380 --> 00:28:25,650
एक JPEG के शुरू.

608
00:28:25,650 --> 00:28:29,520
और मैं फिर से एक ही पैटर्न देखते हैं,
कि शायद की शुरुआत के निशान

609
00:28:29,520 --> 00:28:32,440
एक और जेपीईजी, और अन्य
जेपीईजी, और एक और जेपीईजी.

610
00:28:32,440 --> 00:28:34,970
और यह आमतौर पर है कि कैसे
डेटा वसूली काम करेंगे.

611
00:28:34,970 --> 00:28:37,870
क्या JPEGs के बारे में अच्छी बात है, भले ही है
फ़ाइल स्वरूप ही कुछ हद तक है

612
00:28:37,870 --> 00:28:44,400
जटिल, हर तरह के की शुरुआत
फ़ाइल वास्तव में काफी पहचान योग्य है

613
00:28:44,400 --> 00:28:47,370
और जैसा कि आप देखेंगे, सरल,
यदि आपने ऐसा नहीं किया है.

614
00:28:47,370 --> 00:28:50,270
>> तो चलो एक करीब देखो नीचे ले जाने
हो गया है कि क्या वास्तव में के रूप में डाकू

615
00:28:50,270 --> 00:28:53,360
चल रहा है, और क्या इन 0 और 1
आप एक के लिए थोड़ा और अधिक देने के लिए कर रहे हैं,

616
00:28:53,360 --> 00:28:55,330
इस विशेष चुनौती के लिए संदर्भ.

617
00:28:55,330 --> 00:28:55,510
>> [वीडियो प्लेबैक]

618
00:28:55,510 --> 00:28:58,700
>> कहाँ अपने पीसी भंडार सबसे
इसके स्थायी डेटा की.

619
00:28:58,700 --> 00:29:03,390
ऐसा करने के लिए, डेटा रैम से यात्रा
बता कि सॉफ्टवेयर संकेतों के साथ

620
00:29:03,390 --> 00:29:06,110
मुश्किल यह है कि डेटा स्टोर करने के लिए कैसे ड्राइव.

621
00:29:06,110 --> 00:29:09,410
हार्ड ड्राइव सर्किट अनुवाद
वोल्टेज में उन संकेतों

622
00:29:09,410 --> 00:29:10,870
उतार चढ़ाव.

623
00:29:10,870 --> 00:29:14,970
इन, बारी में, हार्ड ड्राइव के नियंत्रण
चलती भागों, कुछ का कुछ

624
00:29:14,970 --> 00:29:17,910
में छोड़ा चलती भागों
आधुनिक कंप्यूटर.

625
00:29:17,910 --> 00:29:22,130
>> संकेतों में से कुछ एक मोटर नियंत्रण
जो धातु में लिपटे थाली घूमती है.

626
00:29:22,130 --> 00:29:25,470
आपका डेटा वास्तव में संग्रहीत किया जाता है
इन थाली पर.

627
00:29:25,470 --> 00:29:28,610
अन्य संकेतों को पढ़ने / लिखने के लिए कदम
पढ़ने के लिए सिर या

628
00:29:28,610 --> 00:29:30,710
थाली पर डेटा लिखें.

629
00:29:30,710 --> 00:29:35,450
इतनी सटीक यह मशीनरी कि एक मानव
बाल भी बीच पारित नहीं कर सकता

630
00:29:35,450 --> 00:29:37,280
सिर और कताई थाली.

631
00:29:37,280 --> 00:29:40,316
फिर भी, यह सब भयानक गति से काम करता है.

632
00:29:40,316 --> 00:29:40,660
>> [अंत वीडियो प्लेबैक]

633
00:29:40,660 --> 00:29:42,190
>> डेविड मालन: एक छोटी सी में ज़ूम
अब क्या है पर गहरा

634
00:29:42,190 --> 00:29:44,360
वास्तव में उन थाली पर.

635
00:29:44,360 --> 00:29:44,720
>> [वीडियो प्लेबैक]

636
00:29:44,720 --> 00:29:47,660
>> चलो क्या हम बस पर देखने दो.
धीमी गति में देखा था.

637
00:29:47,660 --> 00:29:51,710
बिजली का एक संक्षिप्त नाड़ी है जब
flips, तो पढ़ने / लिखने के सिर को भेजा

638
00:29:51,710 --> 00:29:54,650
के लिए एक छोटे से विद्युत पर
एक दूसरे के एक अंश.

639
00:29:54,650 --> 00:29:58,970
चुंबक, एक क्षेत्र है जो बनाता है
एक छोटे, छोटे के polarity परिवर्तन

640
00:29:58,970 --> 00:30:02,850
धातु के कणों का भाग है जो
कोट प्रत्येक थाली सतह.

641
00:30:02,850 --> 00:30:05,940
>> इन छोटे का एक पैटर्न श्रृंखला,
डिस्क पर आरोप लगाया अप क्षेत्रों

642
00:30:05,940 --> 00:30:08,470
की एक एकल बिट का प्रतिनिधित्व करता है
बाइनरी संख्या में डेटा

643
00:30:08,470 --> 00:30:10,530
कंप्यूटर द्वारा उपयोग किया प्रणाली.

644
00:30:10,530 --> 00:30:13,775
अब, वर्तमान एक तरह से भेजा जाता है तो
पढ़ने / लिखने के सिर के माध्यम से, क्षेत्र

645
00:30:13,775 --> 00:30:15,970
एक दिशा में polarized है.

646
00:30:15,970 --> 00:30:17,950
वर्तमान में भेजा जाता है तो
विपरीत दिशा,

647
00:30:17,950 --> 00:30:19,930
ध्रुवीकरण उलट है.

648
00:30:19,930 --> 00:30:22,370
>> आप हार्ड डिस्क से डाटा प्राप्त करें कैसे?

649
00:30:22,370 --> 00:30:24,090
बस प्रक्रिया को उल्टा.

650
00:30:24,090 --> 00:30:26,550
तो यह डिस्क पर कणों है
उस में चालू हो

651
00:30:26,550 --> 00:30:27,960
/ लिखने के सिर घूम पढ़ा.

652
00:30:27,960 --> 00:30:30,700
इनमें से लाखों लोगों को एक साथ रखा
चुम्बकीय क्षेत्रों, और

653
00:30:30,700 --> 00:30:32,160
आप एक फाइल मिल गया है.

654
00:30:32,160 --> 00:30:36,060
>> अब, एक एकल फाइल के टुकड़े हो सकता है
सभी एक ड्राइव के पर बिखरे हुए किया

655
00:30:36,060 --> 00:30:39,970
तरह की गड़बड़ की तरह थाली,
अपनी मेज पर पत्रों का.

656
00:30:39,970 --> 00:30:43,500
तो एक विशेष अतिरिक्त फ़ाइल ट्रैक रखता है
सब कुछ है, जहां की.

657
00:30:43,500 --> 00:30:45,985
आप आप था इच्छा मत करो
ऐसा कुछ?

658
00:30:45,985 --> 00:30:46,470
>> [अंत वीडियो प्लेबैक]

659
00:30:46,470 --> 00:30:47,820
>> डेविड मालन: ठीक है, शायद नहीं.

660
00:30:47,820 --> 00:30:52,070
आप लोगों का तो कितने
इन के साथ बड़ा हुआ?

661
00:30:52,070 --> 00:30:53,970
ठीक है, तो यह कम और कम है
हाथों हर वर्ष.

662
00:30:53,970 --> 00:30:56,550
लेकिन मैं आपको कम से कम परिचित हैं खुश हूँ
उनके साथ, क्योंकि यह और हमारे अपने

663
00:30:56,550 --> 00:31:00,520
पुस्तक डेमो, अफसोस की बात है, एक बहुत ही मर रहे हैं
यहां अपनेपन की मौत धीमी गति से.

664
00:31:00,520 --> 00:31:04,010
>> लेकिन यह क्या मैं, कम से कम, पीठ में है
उच्च विद्यालय, बैकअप के लिए इस्तेमाल का उपयोग करें.

665
00:31:04,010 --> 00:31:08,110
और यह अद्भुत था क्योंकि आप
1.4 मेगाबाइट पर दुकान सकता है

666
00:31:08,110 --> 00:31:08,930
इस विशेष डिस्क.

667
00:31:08,930 --> 00:31:12,260
और इस उच्च घनत्व संस्करण था,
जो है HD, ने संकेत दिया

668
00:31:12,260 --> 00:31:14,240
आज की एचडी वीडियो से पहले अर्थ.

669
00:31:14,240 --> 00:31:16,400
>> स्टैंडर्ड घनत्व 800 किलोबाइट था.

670
00:31:16,400 --> 00:31:18,640
और उससे पहले, वहाँ थे
400 किलोबाइट डिस्क.

671
00:31:18,640 --> 00:31:23,120
और उससे पहले, 5 और 1/4 वहाँ थे
सही मायने में फ्लॉपी थे जो इंच डिस्क,,

672
00:31:23,120 --> 00:31:25,680
और एक छोटे से व्यापक और लम्बे
यहाँ इन बातों से.

673
00:31:25,680 --> 00:31:29,150
लेकिन आप वास्तव में तथाकथित देख सकते हैं
इन डिस्क के फ्लॉपी पहलू.

674
00:31:29,150 --> 00:31:32,630
>> और कार्यात्मक, वे वास्तव में कर रहे हैं
पर की हार्ड ड्राइव करने के लिए बहुत समान

675
00:31:32,630 --> 00:31:33,570
कम से कम इस प्रकार के.

676
00:31:33,570 --> 00:31:37,270
फिर, नए कंप्यूटर में SSDs
एक छोटे से अलग काम करते हैं.

677
00:31:37,270 --> 00:31:41,530
लेकिन आप उस छोटे से धातु टैब ले जाते हैं,
आप वास्तव में एक छोटे कुकी देख सकते हैं,

678
00:31:41,530 --> 00:31:42,560
या थाली.

679
00:31:42,560 --> 00:31:43,830
>> यह यह एक तरह धातु नहीं है.

680
00:31:43,830 --> 00:31:46,000
यह एक वास्तव में कुछ सस्ता है
प्लास्टिक सामग्री.

681
00:31:46,000 --> 00:31:46,750
और आप की तरह यह wiggle कर सकते हैं.

682
00:31:46,750 --> 00:31:50,310
और तुम trully बस कुछ दूर मिटा दिया है
बिट्स या चुंबकीय कणों की संख्या

683
00:31:50,310 --> 00:31:51,220
इस डिस्क से.

684
00:31:51,220 --> 00:31:52,710
>> तो शुक्र है, इस पर कुछ भी नहीं है.

685
00:31:52,710 --> 00:31:55,790
और कवर - बात यह है कि रास्ते में है तो
अपनी आँखें और अपने पड़ोसी के उन -

686
00:31:55,790 --> 00:31:58,865
आप बस की तरह खींच कर सकते हैं
पूरी तरह है कि बंद म्यान.

687
00:31:58,865 --> 00:32:01,900
लेकिन एक छोटे से वसंत है, इसलिए हो सकता है
अपनी आँखों से इस बात का पता.

688
00:32:01,900 --> 00:32:03,620
तो अब आप सही मायने में एक फ्लॉपी डिस्क है.

689
00:32:03,620 --> 00:32:07,090
>> और क्या इस बारे में उल्लेखनीय है
है कि यह है जितना में एक

690
00:32:07,090 --> 00:32:10,830
एक बड़े से छोटे पैमाने पर प्रतिनिधित्व
हार्ड ड्राइव, इन बातों को, सुपर रहे हैं

691
00:32:10,830 --> 00:32:11,590
सुपर सरल.

692
00:32:11,590 --> 00:32:15,170
आपको लगता है कि अब यह के नीचे, चुटकी, तो
धातु है कि बात के लिए रवाना, और छील

693
00:32:15,170 --> 00:32:20,990
उन्हें खोलने, सब वहाँ के दो टुकड़े है
महसूस किया और तथाकथित फ्लॉपी डिस्क

694
00:32:20,990 --> 00:32:22,930
अंदर पर धातु का एक टुकड़ा के साथ.

695
00:32:22,930 --> 00:32:25,990
>> और के आधे वहां से चला जाता है
मेरी डिस्क की सामग्री.

696
00:32:25,990 --> 00:32:27,540
उनमें से एक और आधा हो जाता है.

697
00:32:27,540 --> 00:32:31,375
लेकिन वह अंदर कताई था वह सब है
पहल साल में अपने कंप्यूटर की.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> और फिर, परिप्रेक्ष्य में यह डाल,
अपने से ज्यादातर कितना बड़ा है

700
00:32:38,310 --> 00:32:39,560
कठिन इन दिनों ड्राइव?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 गीगाबाइट, एक टेराबाइट, शायद में
एक डेस्कटॉप कंप्यूटर, 2 टेराबाइट्स, 3

703
00:32:46,230 --> 00:32:47,630
टेराबाइट्स, 4 टेराबाइट्स, सही?

704
00:32:47,630 --> 00:32:52,480
यह एक मेगाबाइट, दे या ले है
यहां तक ​​कि एक ठेठ एमपी 3 फिट नहीं कर सकते जो

705
00:32:52,480 --> 00:32:55,310
अब और इन दिनों, या कुछ
इसी तरह संगीत फ़ाइल.

706
00:32:55,310 --> 00:32:59,500
>> तो आप के लिए एक छोटी सी स्मारिका आज, और
यह भी क्या contextualize मदद करने के लिए

707
00:32:59,500 --> 00:33:03,570
हम के लिए दी ले जा सकता हूँ
अब समस्या में पांच सेट.

708
00:33:03,570 --> 00:33:04,820
तो उन तुम्हारा रखने के लिए कर रहे हैं.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
तो मुझे कहाँ होगी करने के लिए संक्रमण करते हैं
साथ ही अगले pset खर्च.

711
00:33:13,370 --> 00:33:18,470
तो हम अब के लिए इस पेज को निर्धारित किया है - ओह,
घोषणाओं के एक जोड़े को जल्दी से.

712
00:33:18,470 --> 00:33:21,730
>> इस शुक्रवार, अगर आप चाहेंगे CS50 जुड़ने
दोपहर के भोजन के लिए, सामान्य जगह पर जाना

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
और अंतिम परियोजना -

715
00:33:25,100 --> 00:33:28,520
इसलिए सिलेबस के अनुसार, हम पोस्ट किया है
पहले से ही अंतिम परियोजना विनिर्देश.

716
00:33:28,520 --> 00:33:31,410
इसका मतलब यह नहीं है कि एहसास
यह विशेष रूप से जल्द ही कारण है.

717
00:33:31,410 --> 00:33:33,990
यह सिर्फ पाने के लिए, वास्तव में, तैनात है
आप इसके बारे में सोच लड़के.

718
00:33:33,990 --> 00:33:37,620
और वास्तव में, एक सुपर महत्वपूर्ण
आप का प्रतिशत से निपटने की जाएगी

719
00:33:37,620 --> 00:33:40,780
सामग्री पर अंतिम परियोजनाओं है कि हम
यहां तक ​​कि क्लास में करने के लिए नहीं मिल गया है,

720
00:33:40,780 --> 00:33:42,730
लेकिन के रूप में अगले हफ्ते की शुरुआत के रूप में होगा.

721
00:33:42,730 --> 00:33:45,530
>> सूचना, हालांकि, कल्पना के लिए कहता है
की कुछ अलग घटकों

722
00:33:45,530 --> 00:33:46,190
अंतिम परियोजना.

723
00:33:46,190 --> 00:33:49,590
सबसे पहले, एक कुछ हफ्तों में, एक है
पूर्व प्रस्ताव, एक सुंदर आकस्मिक ईमेल करने के लिए

724
00:33:49,590 --> 00:33:52,760
अपने TF आप क्या कर रहे हैं उसे बता सकते हैं या करने के लिए
साथ, अपनी परियोजना के बारे में सोच

725
00:33:52,760 --> 00:33:53,650
कोई प्रतिबद्धता.

726
00:33:53,650 --> 00:33:56,710
प्रस्ताव अपने विशेष होगा
प्रतिबद्धता, कह रही है, यहाँ, यह क्या है

727
00:33:56,710 --> 00:33:57,770
मैं अपनी परियोजना के लिए करना चाहते हैं.

728
00:33:57,770 --> 00:33:58,250
आप क्या सोचते हैं?

729
00:33:58,250 --> 00:33:58,650
बहुत बड़ा है?

730
00:33:58,650 --> 00:33:59,145
बहुत छोटा?

731
00:33:59,145 --> 00:34:00,330
यह प्रबंधनीय है?

732
00:34:00,330 --> 00:34:02,230
और अगर आप अधिक जानकारी के लिए कल्पना देखते हैं.

733
00:34:02,230 --> 00:34:05,060
>> उसके बाद सप्ताह की जोड़ी स्थिति है
एक इसी तरह की है, जो रिपोर्ट

734
00:34:05,060 --> 00:34:08,260
कहने के लिए अपने TF करने के लिए आकस्मिक ईमेल बस कैसे
आप अपने अंतिम में हैं बहुत पीछे

735
00:34:08,260 --> 00:34:12,360
द्वारा पीछा परियोजना के कार्यान्वयन,
CS50 Hackathon जहाँ हर कोई

736
00:34:12,360 --> 00:34:17,520
आमंत्रित किया है, से एक घटना होगी जो
7:00 तक एक शाम को 8:00

737
00:34:17,520 --> 00:34:19,150
अगली सुबह हूँ.

738
00:34:19,150 --> 00:34:22,560
मैं सप्ताह में उल्लेख किया है मई के रूप में पिज्जा,
शून्य, 9:00 पर कार्य किया जा wil,

739
00:34:22,560 --> 00:34:24,120
1:00 पर चीनी खाना.

740
00:34:24,120 --> 00:34:27,929
और तुम अब भी 5:00 पर जाग रहे हैं,
हम नाश्ते के लिए IHOP के लिए ले जाऊँगा.

741
00:34:27,929 --> 00:34:31,310
>> तो Hackathon अधिक में से एक है
वर्ग में यादगार अनुभव.

742
00:34:31,310 --> 00:34:35,290
तब कार्यान्वयन की वजह से है, और
तब चरम CS50 मेला.

743
00:34:35,290 --> 00:34:38,070
इन सब के बारे में अधिक जानकारी
आने वाले सप्ताहों में.

744
00:34:38,070 --> 00:34:40,739
>> लेकिन कुछ करने के लिए वापस जाओ
पुराने स्कूल -

745
00:34:40,739 --> 00:34:41,920
फिर, एक सरणी.

746
00:34:41,920 --> 00:34:45,040
इसे हल इसलिए क्योंकि एक सरणी, अच्छा था
हम जैसी समस्याओं को देखा सिर्फ एक

747
00:34:45,040 --> 00:34:49,290
छात्र संरचनाओं के साथ पहले पल
एक छोटे से नियंत्रण से बाहर हो रही है अगर हम

748
00:34:49,290 --> 00:34:52,405
छात्र एक, छात्र दो है चाहता हूँ,
छात्र तीन, छात्र डॉट डॉट डॉट,

749
00:34:52,405 --> 00:34:54,400
छात्रों में से कुछ मनमाना संख्या.

750
00:34:54,400 --> 00:34:58,850
>> तो सरणियों, कुछ हफ्ते पहले, में swooped
और नहीं के बारे में हमारी सभी समस्याओं का हल

751
00:34:58,850 --> 00:35:03,340
अग्रिम में जानने कितनी बातें
कुछ प्रकार के हम चाहते हो सकता है.

752
00:35:03,340 --> 00:35:07,390
और हम structs हमारी मदद कर सकते हैं कि देखा है
आगे हमारे कोड को संगठित करने और रखने के

753
00:35:07,390 --> 00:35:11,660
एक तरह धारणात्मक समान चर,
नाम और एक घर, एक साथ, ताकि हम

754
00:35:11,660 --> 00:35:15,570
अंदर, एक इकाई के रूप में उन्हें इलाज कर सकते हैं
छोटे टुकड़े कर रहे हैं जो की.

755
00:35:15,570 --> 00:35:17,810
>> लेकिन सरणियों कुछ नुकसान है.

756
00:35:17,810 --> 00:35:19,780
नुकसान की कुछ क्या हैं
हम सामना करना पड़ा है

757
00:35:19,780 --> 00:35:22,320
सरणियों के साथ इस प्रकार अब तक?

758
00:35:22,320 --> 00:35:23,450
वह क्या है?

759
00:35:23,450 --> 00:35:28,130
निश्चित आकार - तो भी आप कर सकते हैं, हालांकि
एक के लिए स्मृति आवंटित करने में सक्षम हो

760
00:35:28,130 --> 00:35:32,310
सरणी, आप कितने छात्रों को पता एक बार
आपको लगता है कि कितने अक्षर है,

761
00:35:32,310 --> 00:35:35,460
उपयोगकर्ता से, एक बार आप आवंटित किया है
सरणी, आप की तरह चित्रित किया

762
00:35:35,460 --> 00:35:36,740
एक कोने में अपने आप को.

763
00:35:36,740 --> 00:35:40,600
>> आप नए तत्वों को सम्मिलित नहीं कर सकता, क्योंकि
एक सरणी के बीच में.

764
00:35:40,600 --> 00:35:43,660
आप अधिक तत्व सम्मिलित नहीं कर सकता
एक सरणी के अंत में.

765
00:35:43,660 --> 00:35:47,750
वास्तव में, यदि आप एक बनाने का सहारा
हम चर्चा की है के रूप में पूरी नई सरणी,,

766
00:35:47,750 --> 00:35:49,320
नई में पुराने नकल.

767
00:35:49,320 --> 00:35:52,610
और फिर, कि सिर दर्द है कि
आप के लिए के साथ सौदों GetString.

768
00:35:52,610 --> 00:35:56,170
>> लेकिन फिर, आप भी सम्मिलित नहीं कर सकता
सरणी के बीच में कुछ

769
00:35:56,170 --> 00:35:58,200
दर पूरी तरह भरा नहीं है.

770
00:35:58,200 --> 00:36:03,010
उदाहरण के लिए, अगर आकार के यहां इस सरणी
छह ही, इसमें पांच बातें

771
00:36:03,010 --> 00:36:06,080
ठीक है, तुम सिर्फ हमले कर सकता है
अंत पर कुछ.

772
00:36:06,080 --> 00:36:08,200
लेकिन अगर आप कुछ सम्मिलित करने के लिए क्या चाहते हैं
के बीच में

773
00:36:08,200 --> 00:36:11,280
यह हो सकता है, भले ही सरणी,
पांच इसमें छह चीजों से बाहर?

774
00:36:11,280 --> 00:36:14,250
>> हम सभी था जब खैर, हम क्या किया
हमारे मानव स्वयंसेवकों मंच में की

775
00:36:14,250 --> 00:36:15,110
सप्ताह पिछले?

776
00:36:15,110 --> 00:36:18,710
हम या तो किसी को यहाँ डाल करना चाहते थे
इस स्थानांतरित करने के लिए कैसे इन लोगों को

777
00:36:18,710 --> 00:36:22,540
इस स्थानांतरित करने के लिए कैसे रास्ता, या इन लोगों
जिस तरह से, और उस महंगा हो गया.

778
00:36:22,540 --> 00:36:26,950
एक के अंदर लोगों का स्थानांतरण
सरणी जोड़ने और लागत को समाप्त हो गया

779
00:36:26,950 --> 00:36:31,240
हमें समय, हमारे n इसलिए बहुत चुकता
के लिए, सम्मिलन सॉर्ट ऐसे समय चल रहा है

780
00:36:31,240 --> 00:36:32,550
उदाहरण के लिए, सबसे खराब स्थिति में.

781
00:36:32,550 --> 00:36:36,520
तो सरणियों महान हैं, लेकिन आप के लिए है
आप चाहते हैं उन्हें कितना बड़ा पहले से पता है.

782
00:36:36,520 --> 00:36:38,030
>> तो ठीक है, यहाँ एक समाधान है.

783
00:36:38,030 --> 00:36:43,860
कितने मैं पहले से नहीं जानते हैं
छात्रों मैं हो सकता है, और मैं एक बार पता

784
00:36:43,860 --> 00:36:47,870
मैं हालांकि, मैं उस के साथ फँस गया हूँ, तय
कई छात्रों, क्यों नहीं मैं तो बस हमेशा

785
00:36:47,870 --> 00:36:51,740
दो बार के रूप में ज्यादा जगह आवंटित
मैं मैं की जरूरत है लगता है कि शायद?

786
00:36:51,740 --> 00:36:54,450
नहीं एक उचित समाधान है?

787
00:36:54,450 --> 00:36:58,240
>> वास्तविक, मुझे लगता है हम कर रहे हैं कि नहीं लगता
50 से अधिक स्लॉट की जरूरत के लिए जा रहा

788
00:36:58,240 --> 00:37:02,190
एक मध्यम आकार के वर्ग के लिए एक सरणी में,
तो चलो बस को गोल करते हैं.

789
00:37:02,190 --> 00:37:07,040
मैं सिर्फ अपने सरणी में 100 स्लॉटों कर दूँगा
हम निश्चित रूप से प्राप्त कर सकते हैं

790
00:37:07,040 --> 00:37:10,330
मुझे उम्मीद है छात्रों की संख्या के लिए
कुछ मध्यम आकार के वर्ग में हो.

791
00:37:10,330 --> 00:37:14,320
तो क्यों अभी तक दौर और आवंटित नहीं
अधिक स्मृति, आम तौर पर, एक सरणी के लिए

792
00:37:14,320 --> 00:37:16,290
आपको लगता है कि आप भी जरूरत हो सकती है?

793
00:37:16,290 --> 00:37:20,190
इस सरल pushback क्या है
यह विचार है कि करने के लिए?

794
00:37:20,190 --> 00:37:21,440
>> तुम सिर्फ स्मृति बर्बाद कर रहे हैं.

795
00:37:21,440 --> 00:37:25,350
आप तो लिखने सचमुच हर कार्यक्रम
शायद दो बार के रूप में ज्यादा स्मृति के रूप में उपयोग कर रहा है

796
00:37:25,350 --> 00:37:26,680
आप वास्तव में जरूरत है.

797
00:37:26,680 --> 00:37:28,990
और वह सिर्फ एक तरह महसूस नहीं करता
विशेष रूप से सुरुचिपूर्ण समाधान.

798
00:37:28,990 --> 00:37:31,990
इसके अलावा, यह सिर्फ कम हो जाती है
एक समस्या की संभावना.

799
00:37:31,990 --> 00:37:35,300
आप एक लोकप्रिय कोर्स के लिए होता है
एक सेमेस्टर और आप 101 है

800
00:37:35,300 --> 00:37:39,610
छात्रों, अपने कार्यक्रम अभी भी है
मूलरूप में एक ही मुद्दे का सामना करना पड़.

801
00:37:39,610 --> 00:37:44,280
>> तो शुक्र है, वहाँ एक समाधान है
फॉर्म में इस विज्ञापन हमारी सभी समस्याओं

802
00:37:44,280 --> 00:37:46,790
हैं कि डेटा संरचनाओं की
लोगों की तुलना में अधिक जटिल

803
00:37:46,790 --> 00:37:47,970
हम इस प्रकार अब तक देखा है.

804
00:37:47,970 --> 00:37:50,530
यह, मैं दावा, एक लिंक सूची है.

805
00:37:50,530 --> 00:37:51,920
इस नंबर की एक सूची है -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, और 34 -

807
00:37:54,970 --> 00:38:00,120
वैसे एक साथ जोड़ दिया गया है कि
मैं तीर के रूप में तैयार किया है क्या की.

808
00:38:00,120 --> 00:38:03,580
>> दूसरे शब्दों में, मैं प्रतिनिधित्व करना चाहता था
एक सरणी, मैं क्या कर सकता

809
00:38:03,580 --> 00:38:04,910
कुछ इस तरह.

810
00:38:04,910 --> 00:38:07,310
और मैं भूमि के ऊपर पर डाल देता हूँ
बस एक पल में.

811
00:38:07,310 --> 00:38:09,970
मैं कर सकता है -

812
00:38:09,970 --> 00:38:12,520
नमस्कार, सब ठीक है.

813
00:38:12,520 --> 00:38:14,470
द्वारा खड़े हो जाओ.

814
00:38:14,470 --> 00:38:17,360
यहां नई कंप्यूटर, साफ -

815
00:38:17,360 --> 00:38:18,090
ठीक है.

816
00:38:18,090 --> 00:38:21,730
>> तो मैं सरणी में इन नंबर हैं -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
जरूरी नहीं पैमाने पर करने की.

819
00:38:30,530 --> 00:38:33,730
ठीक है, तो यहाँ मेरे सरणी है -

820
00:38:33,730 --> 00:38:34,980
हे भगवान.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
ठीक है, तो यहाँ मेरे सरणी है.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
हे भगवान.

825
00:38:45,050 --> 00:38:48,820
>> [हंसी]

826
00:38:48,820 --> 00:38:49,440
>> डेविड मालन: नाटक.

827
00:38:49,440 --> 00:38:52,330
यह वापस जाने के लिए बहुत अधिक प्रयास है
और इसलिए वहाँ, तय है कि -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
इसलिए हम इस सरणी है
9, 17, 22, 26, और 34.

830
00:38:57,650 --> 00:39:00,260
आप में से उन देख सकते हैं
शर्मनाक गलती मैं सिर्फ बनाया,

831
00:39:00,260 --> 00:39:00,830
वहाँ यह है.

832
00:39:00,830 --> 00:39:04,490
>> इसलिए मैं इस का दावा है कि एक
बहुत ही कुशल समाधान.

833
00:39:04,490 --> 00:39:07,310
मैं के रूप में कई ints आवंटित किया है
मैं की जरूरत है - एक, दो, तीन,

834
00:39:07,310 --> 00:39:09,100
चार, पांच या छह -

835
00:39:09,100 --> 00:39:11,660
और मैं तो संख्या संग्रहीत किया है
इस सरणी के अंदर.

836
00:39:11,660 --> 00:39:15,220
लेकिन लगता है, तो, मैं सम्मिलित करना चाहते हैं
8 नंबर की तरह एक मूल्य है?

837
00:39:15,220 --> 00:39:16,100
खैर, जहां यह जाना है?

838
00:39:16,100 --> 00:39:18,530
मैं सम्मिलित करने के लिए चाहता हूँ
20 की तरह एक नंबर.

839
00:39:18,530 --> 00:39:19,790
खैर, जहां यह जाना है?

840
00:39:19,790 --> 00:39:23,160
कहीं बीच में,
या संख्या 35 से जाना है

841
00:39:23,160 --> 00:39:24,010
अंत में कहीं.

842
00:39:24,010 --> 00:39:25,320
लेकिन मैं अंतरिक्ष के बाहर सब कर रहा हूँ.

843
00:39:25,320 --> 00:39:29,120
>> और इसलिए यह एक मौलिक चुनौती है
सरणियों का समाधान कर रहे हैं कि है.

844
00:39:29,120 --> 00:39:32,280
मैं GetString, एक पल पहले दावा किया
इस समस्या को हल करती है.

845
00:39:32,280 --> 00:39:37,380
आप एक छठे नंबर डालने के लिए चाहते हैं
इस सरणी में, कम से कम एक क्या है

846
00:39:37,380 --> 00:39:40,090
आप सुनिश्चित करने के लिए पीठ पर गिर सकता है समाधान,
हम GetString साथ बस पसंद नहीं है?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
वह क्या है?

849
00:39:46,030 --> 00:39:48,190
>> खैर, यह बड़ा है कर
आसान काम से कहा.

850
00:39:48,190 --> 00:39:52,810
हम जरूरी सरणी नहीं कर सकता
बड़ा, लेकिन हम क्या कर सकते हैं?

851
00:39:52,810 --> 00:39:56,570
आकार का बड़ा है कि एक नई सरणी, बनाओ
6, या शायद 10 आकार, अगर हम चाहते हैं

852
00:39:56,570 --> 00:40:00,490
चीज़ों के आगे मिलता है, और फिर कॉपी करने के लिए
तो नया है, और में पुराने सरणी

853
00:40:00,490 --> 00:40:01,680
पुराने सरणी मुक्त.

854
00:40:01,680 --> 00:40:05,770
>> लेकिन समय चल रहा है क्या है
अब उस प्रक्रिया की?

855
00:40:05,770 --> 00:40:09,870
यह, एन के बिग हे क्योंकि नकल
आप में से कुछ इकाइयों खर्च हो रहा है

856
00:40:09,870 --> 00:40:13,480
समय, तो हम ऐसा करने के लिए आदर्श है, अगर नहीं
जा रहा है जो एक नई सरणी, आवंटित

857
00:40:13,480 --> 00:40:15,610
दो बार के रूप में ज्यादा उपभोग करने के लिए
स्मृति को अस्थायी रूप से.

858
00:40:15,610 --> 00:40:16,660
नई में पुरानी कॉपी -

859
00:40:16,660 --> 00:40:18,800
मेरा मतलब है, यह सिर्फ एक सिरदर्द है, जो
, फिर से, हम क्यों लिखा है

860
00:40:18,800 --> 00:40:19,920
आप के लिए GetString.

861
00:40:19,920 --> 00:40:21,380
>> तो हम बजाय क्या कर सकता है?

862
00:40:21,380 --> 00:40:25,000
खैर, क्या हुआ अगर हमारे डेटा संरचना
वास्तव में यह अंतराल है?

863
00:40:25,000 --> 00:40:30,790
मैं होने के अपने लक्ष्य को आराम कि मान लीजिए
स्मृति के सन्निहित हिस्सा, जहां 9

864
00:40:30,790 --> 00:40:34,500
ठीक बगल में 17 को, जो है
22 के बगल में, और इतने पर.

865
00:40:34,500 --> 00:40:39,570
>> और 9 में यहाँ पर हो सकता है कि लगता है
रैम, और 17, रैम में यहाँ पर हो सकता है

866
00:40:39,570 --> 00:40:40,990
और 22 यहाँ रैम में खत्म हो सकता है.

867
00:40:40,990 --> 00:40:43,610
दूसरे शब्दों में, मैं उन्हें जरूरत नहीं है
यहां तक ​​कि अब और वापस वापस.

868
00:40:43,610 --> 00:40:47,850
मैं तो बस किसी तरह एक सुई धागा करने के लिए है
इन नंबरों में से प्रत्येक, या प्रत्येक के माध्यम से

869
00:40:47,850 --> 00:40:51,010
हम फोन करता हूँ इन नोड्स के, के रूप में
मैं करने के लिए, उन्हें तैयार किया है के रूप में आयतों

870
00:40:51,010 --> 00:40:55,670
पिछले करने के लिए प्राप्त करने के लिए कैसे याद
पहले से ऐसी नोड.

871
00:40:55,670 --> 00:40:59,940
>> तो प्रोग्रामिंग का निर्माण क्या है
हम काफी हाल ही में देखा है, जिसके साथ मैं

872
00:40:59,940 --> 00:41:03,030
उस धागे को लागू करने, या कर सकते हैं
जिसके साथ मैं कर सकता हूँ, यहाँ तैयार

873
00:41:03,030 --> 00:41:05,430
उन तीरों को लागू?

874
00:41:05,430 --> 00:41:06,500
तो संकेत, सही?

875
00:41:06,500 --> 00:41:09,560
मैं न सिर्फ एक आवंटित हैं
INT, लेकिन एक नोड - और से

876
00:41:09,560 --> 00:41:10,810
नोड, मैं सिर्फ कंटेनर मतलब.

877
00:41:10,810 --> 00:41:12,900
और नेत्रहीन, मैं एक आयत का मतलब.

878
00:41:12,900 --> 00:41:16,420
तो एक नोड जाहिरा तौर पर की जरूरत है
दो मूल्यों को नियंत्रित करने के लिए -

879
00:41:16,420 --> 00:41:21,490
के रूप में निहित, तो खुद INT, और
आयत के नीचे आधा,

880
00:41:21,490 --> 00:41:23,010
एक पूर्णांक के लिए पर्याप्त जगह.

881
00:41:23,010 --> 00:41:26,130
>> तो बस, यहाँ आगे की सोच
इस नोड यह कितना बड़ा है

882
00:41:26,130 --> 00:41:27,170
प्रश्न में कंटेनर?

883
00:41:27,170 --> 00:41:29,250
कितने बाइट्स int के लिए?

884
00:41:29,250 --> 00:41:31,310
मुमकिन 4, अगर यह
हमेशा की तरह ही है.

885
00:41:31,310 --> 00:41:33,270
और फिर कितने बाइट्स
सूचक के लिए?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
तो इस कंटेनर, या इस नोड है
एक 8 बाइट संरचना होने जा रहा.

888
00:41:37,940 --> 00:41:41,760
ओह, और कहा कि यह सुखद संयोग है कि
हम सिर्फ इस धारणा की शुरुआत की

889
00:41:41,760 --> 00:41:44,400
एक संरचना, या एक सी संरचना.

890
00:41:44,400 --> 00:41:48,890
>> इसलिए मुझे लगता है मैं एक कदम उठाना चाहते हैं कि दावा
यह और अधिक परिष्कृत की ओर

891
00:41:48,890 --> 00:41:52,560
नंबरों की सूची के कार्यान्वयन, एक
नंबरों की सूची जुड़ा है, मैं क्या करने की जरूरत है एक

892
00:41:52,560 --> 00:41:56,920
थोड़ा अधिक सामने सोच और
न सिर्फ एक पूर्णांक, लेकिन एक struct घोषित

893
00:41:56,920 --> 00:41:58,620
मैं पारंपरिक, फोन करता हूँ कि
यहाँ, नोड.

894
00:41:58,620 --> 00:42:01,630
हम चाहते हैं कि कुछ भी कहते हैं, लेकिन हो सकता है
नोड एक बहुत में विषयगत होने जा रहा है

895
00:42:01,630 --> 00:42:03,560
चीजों की अब हम पर तलाश शुरू.

896
00:42:03,560 --> 00:42:06,480
>> कि नोड के अंदर एक पूर्णांक n है.

897
00:42:06,480 --> 00:42:09,350
और फिर इस वाक्य रचना, एक छोटे से
पहली नज़र में अजीब -

898
00:42:09,350 --> 00:42:12,960
संरचना नोड * अगले.

899
00:42:12,960 --> 00:42:16,900
खैर सचित्र रूप से, कि क्या है?

900
00:42:16,900 --> 00:42:21,000
उस के नीचे आधा है
हमने देखा है कि आयत

901
00:42:21,000 --> 00:42:22,730
बस एक पल पहले.

902
00:42:22,730 --> 00:42:27,600
>> लेकिन क्यों मैं * संरचना नोड कह रहा हूँ
* बस नोड के लिए विरोध के रूप में?

903
00:42:27,600 --> 00:42:31,370
कि सूचक इशारा कर रहा है क्योंकि अगर
अन्य नोड में, यह सिर्फ

904
00:42:31,370 --> 00:42:32,760
एक नोड के पते.

905
00:42:32,760 --> 00:42:35,630
यही कारण है कि हम क्या है के साथ संगत है
इस प्रकार अब तक संकेत के बारे में चर्चा की.

906
00:42:35,630 --> 00:42:39,690
मैं दावा करते हैं लेकिन क्यों, इस संरचना है
नोड कहा जाता है, मैं संरचना कहना है

907
00:42:39,690 --> 00:42:42,660
नोड यहाँ अंदर?

908
00:42:42,660 --> 00:42:43,190
>> बिल्कुल सही.

909
00:42:43,190 --> 00:42:46,490
यह सी. के प्रकार की एक बेवकूफ वास्तविकता है
typedef, तो बात है, नहीं है

910
00:42:46,490 --> 00:42:47,220
अभी तक हुआ.

911
00:42:47,220 --> 00:42:48,510
सी सुपर शाब्दिक है.

912
00:42:48,510 --> 00:42:51,050
यह करने के लिए अपने कोड शीर्ष पढ़ता
सही करने के लिए छोड़ दिया तल,.

913
00:42:51,050 --> 00:42:54,930
और उस पर कि अर्धविराम हिट जब तक
लब्बोलुआब यह नहीं करता है लगता है क्या

914
00:42:54,930 --> 00:42:57,590
एक डेटा प्रकार के रूप में मौजूद है?

915
00:42:57,590 --> 00:42:59,060
नोड, बोली गंदें शब्द बोलना नोड.

916
00:42:59,060 --> 00:43:03,050
>> लेकिन क्योंकि अधिक वाचाल की
घोषणा मैं पहली पंक्ति पर किया था -

917
00:43:03,050 --> 00:43:05,340
typedef struct नोड -

918
00:43:05,340 --> 00:43:08,790
उससे पहले, पहली बार आया था, क्योंकि
घुंघराले ब्रेसिज़, उस तरह की तरह है

919
00:43:08,790 --> 00:43:11,800
बजना पूर्व शिक्षित कि, आप
, मुझे एक संरचना दे पता है क्या

920
00:43:11,800 --> 00:43:13,570
संरचना नोड कहा जाता है.

921
00:43:13,570 --> 00:43:16,270
सच कहूँ तो, मैं चीजों को बुला पसंद नहीं है
संरचना नोड, संरचना नोड सभी

922
00:43:16,270 --> 00:43:17,090
मेरे कोड भर में.

923
00:43:17,090 --> 00:43:20,660
लेकिन मैं केवल बस के अंदर, एक बार इसे इस्तेमाल करेंगे
मैं इतना है कि प्रभावी ढंग से कर सकते हैं

924
00:43:20,660 --> 00:43:25,010
, परिपत्र संदर्भ का एक तरह से नहीं बना
दर असल अपने आप को, लेकिन एक के लिए एक सूचक

925
00:43:25,010 --> 00:43:29,400
की एक और करने के लिए सूचक
एक समान प्रकार.

926
00:43:29,400 --> 00:43:32,330
>> तो यह पता चला है कि एक आंकड़ा संरचना पर
इस तरह, कुछ नहीं है

927
00:43:32,330 --> 00:43:34,470
हो सकता है कि आपरेशन
हमारे लिए ब्याज की.

928
00:43:34,470 --> 00:43:37,460
हम सम्मिलित करने के लिए चाहते हो सकता है
इस प्रकार की सूची में.

929
00:43:37,460 --> 00:43:39,850
हम हटाने के लिए चाहते हो सकता है
इस तरह से एक सूची से.

930
00:43:39,850 --> 00:43:43,490
हम एक के लिए सूची खोज करने के लिए चाहते हो सकता है
मूल्य, या अधिक आम तौर पार.

931
00:43:43,490 --> 00:43:46,410
और पार सिर्फ एक अच्छा तरीका की है
बाएँ पर शुरू कह रही है और सभी कदम

932
00:43:46,410 --> 00:43:47,650
सही तरीके से करने.

933
00:43:47,650 --> 00:43:52,640
>> और यहां तक ​​कि यह थोड़ा अधिक के साथ, नोटिस
परिष्कृत डेटा संरचना, चलो

934
00:43:52,640 --> 00:43:56,510
मुझे हम में से कुछ उधार ले सकते हैं कि प्रस्ताव
पिछले दो हफ्तों के विचारों और

935
00:43:56,510 --> 00:43:58,410
कहा जाता है एक समारोह को लागू
इस तरह से खोज.

936
00:43:58,410 --> 00:44:01,360
यह सच लौटने के लिए जा रहा है या कर रहा है
झूठा, यह दर्शाता है, हाँ या

937
00:44:01,360 --> 00:44:03,390
नहीं, पता सूची में है.

938
00:44:03,390 --> 00:44:05,960
इसका दूसरा तर्क एक सूचक है
सूची पर ही है, एक तो

939
00:44:05,960 --> 00:44:07,920
एक नोड के लिए सूचक.

940
00:44:07,920 --> 00:44:10,350
>> मैं फिर क्या करने जा रहा हूँ घोषित है
एक अस्थायी चर.

941
00:44:10,350 --> 00:44:12,730
हम कन्वेंशन द्वारा पीटीआर यह फोन करता हूँ
सूचक के लिए.

942
00:44:12,730 --> 00:44:15,220
और मैं यह करने के लिए बराबर आवंटित
सूची की शुरुआत.

943
00:44:15,220 --> 00:44:16,680
>> और अब जबकि पाश नोटिस.

944
00:44:16,680 --> 00:44:20,640
इतने लंबे समय के सूचक बराबर नहीं है के रूप में
अशक्त करने के लिए, मैं जाँच करने के लिए जा रहा हूँ.

945
00:44:20,640 --> 00:44:24,520
सूचक तीर n के बराबर है
में पारित किया गया था कि पता?

946
00:44:24,520 --> 00:44:26,410
और एक मिनट रुको - नई
वाक्यविन्यास का टुकड़ा.

947
00:44:26,410 --> 00:44:29,324
तीर अचानक क्या है?

948
00:44:29,324 --> 00:44:30,574
हाँ?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> बिल्कुल सही.

951
00:44:34,810 --> 00:44:38,860
तो, जबकि कुछ मिनट पहले, हम इस्तेमाल
कुछ का उपयोग करने के लिए डॉट संकेतन

952
00:44:38,860 --> 00:44:43,080
एक संरचना के अंदर, अगर चर
आप संरचना नहीं है है

953
00:44:43,080 --> 00:44:47,420
ही है, लेकिन एक संरचना पर कोई सूचक,
शुक्र है, वाक्य रचना का एक टुकड़ा है कि

954
00:44:47,420 --> 00:44:48,620
अंत में सहज ज्ञान युक्त समझ में आता है.

955
00:44:48,620 --> 00:44:52,360
तीर सूचक का पालन करने का मतलब है,
हमारे तीर आम तौर पर मतलब है की तरह

956
00:44:52,360 --> 00:44:56,570
सचित्र रूप से, और पर जाना
डेटा क्षेत्र के अंदर.

957
00:44:56,570 --> 00:44:59,700
तो तीर डॉट के रूप में एक ही बात है, लेकिन
आप एक सूचक है जब आप इसे उपयोग.

958
00:44:59,700 --> 00:45:05,270
>> तो बस, तो संक्षिप्त करने के लिए करते हैं तो क्षेत्र
संरचना के अंदर सूचक कहा जाता है

959
00:45:05,270 --> 00:45:07,760
बराबर होती n के बराबर होती है, सच वापसी.

960
00:45:07,760 --> 00:45:11,970
अन्यथा, यहाँ इस लाइन - सूचक
अगले सूचक के बराबर होती है.

961
00:45:11,970 --> 00:45:17,540
तो यह क्या कर रहा है, नोटिस, अगर मैं
वर्तमान संरचना पर इशारा कर रहा हूँ

962
00:45:17,540 --> 00:45:21,430
9, और 9 युक्त संख्या नहीं है
मैं देख रहा हूँ लगता है - मैं देख रहा हूँ

963
00:45:21,430 --> 00:45:22,830
N के लिए 50 के बराबर होती है -

964
00:45:22,830 --> 00:45:25,930
मैं अपने अस्थायी सूचक अद्यतन करने के लिए जा रहा हूँ
इस नोड पर बात नहीं करने के लिए

965
00:45:25,930 --> 00:45:31,190
अब और नहीं, लेकिन सूचक तीर अगला, जो
मुझे यहाँ रखा जा रहा है.

966
00:45:31,190 --> 00:45:34,270
>> अब, मुझे एहसास हुआ कि एक बवंडर है
परिचय.

967
00:45:34,270 --> 00:45:37,380
बुधवार को, हम वास्तव में इस करूँगा
कुछ मनुष्यों के साथ और कुछ और के साथ

968
00:45:37,380 --> 00:45:38,900
एक धीमी गति से कोड.

969
00:45:38,900 --> 00:45:42,990
लेकिन, पता ही अब हम अपने डेटा कर रहे हैं
संरचनाओं और अधिक जटिल है, ताकि हमारे

970
00:45:42,990 --> 00:45:45,780
एल्गोरिदम, अधिक कुशल प्राप्त कर सकते हैं जो
के लिए अपेक्षित होने जा रहा है

971
00:45:45,780 --> 00:45:50,500
pset छह, हम, फिर से, उन में लोड करते हैं
150,000 शब्द हैं, लेकिन ऐसा करने की जरूरत

972
00:45:50,500 --> 00:45:55,650
कुशलतापूर्वक, और आदर्श रूप में, एक बना
हमारे उपयोगकर्ताओं को नहीं में लिए चलता है कि कार्यक्रम

973
00:45:55,650 --> 00:46:00,460
रेखीय, एन में चुकता, लेकिन में नहीं
आदर्श में लगातार समय,.

974
00:46:00,460 --> 00:46:02,300
>> हम बुधवार को देखेंगे.

975
00:46:02,300 --> 00:46:07,240
>> अध्यक्ष: अगले CS50, डेविड में
उसके आधार मामले को भूल जाता है.

976
00:46:07,240 --> 00:46:12,770
>> डेविड मालन: और है कि आप भेजने कैसे है
सी. क्या साथ पाठ संदेश -

977
00:46:12,770 --> 00:46:14,020
>> [विभिन्न पाठ संदेश
अधिसूचना ध्वनियों]

978
00:46:14,020 --> 00:46:19,734