1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [वेलग्रिंड]

2
00:00:02,000 --> 00:00:05,000
[नैट Hardison, हार्वर्ड विश्वविद्यालय]

3
00:00:05,000 --> 00:00:07,000
इस CS50 है, CS50.TV]

4
00:00:07,000 --> 00:00:10,000
सी कार्यक्रमों में सबसे कठिन कीड़े के कुछ

5
00:00:10,000 --> 00:00:13,000
स्मृति के कुप्रबंधन से आते हैं.

6
00:00:13,000 --> 00:00:15,000
बातें पेंच के तरीके की एक बड़ी संख्या है,

7
00:00:15,000 --> 00:00:17,000
स्मृति के गलत राशि का आवंटन भी शामिल है,

8
00:00:17,000 --> 00:00:20,000
चर इनिशियलाइज़ भूल,

9
00:00:20,000 --> 00:00:23,000
एक बफर के अंत से पहले या बाद में लेखन,

10
00:00:23,000 --> 00:00:25,000
मुक्त और स्मृति कई बार रखना.

11
00:00:25,000 --> 00:00:28,000
लक्षण आंतरायिक दुर्घटनाओं से लेकर

12
00:00:28,000 --> 00:00:30,000
को अधिलेखित कर दिया मूल्यों के लिए रहस्यमय तरीके से,

13
00:00:30,000 --> 00:00:34,000
अक्सर स्थानों और समय तक मूल त्रुटि से हटा.

14
00:00:34,000 --> 00:00:37,000
मनाया समस्या वापस अनुरेखण अंतर्निहित जड़

15
00:00:37,000 --> 00:00:39,000
चुनौतीपूर्ण हो सकता है,

16
00:00:39,000 --> 00:00:42,000
लेकिन सौभाग्य से वहाँ एक उपयोगी कार्यक्रम वेलग्रिंड बुलाया है

17
00:00:42,000 --> 00:00:44,000
कि एक बहुत कुछ करने के लिए मदद कर सकते हैं.

18
00:00:44,000 --> 00:00:47,000
>> आप वेलग्रिंड के तहत एक कार्यक्रम चलाने करने के लिए सक्षम

19
00:00:47,000 --> 00:00:50,000
ढेर स्मृति आवंटन और accesses के व्यापक जाँच.

20
00:00:50,000 --> 00:00:53,000
जब वेलग्रिंड एक समस्या का पता लगाता है, यह आप तत्काल देता है,

21
00:00:53,000 --> 00:00:56,000
प्रत्यक्ष जानकारी है कि आप के लिए अनुमति देता है

22
00:00:56,000 --> 00:00:58,000
और अधिक आसानी से खोजने के लिए और समस्या को ठीक.

23
00:00:58,000 --> 00:01:01,000
भी कम घातक स्मृति के मुद्दों पर रिपोर्ट वेलग्रिंड,

24
00:01:01,000 --> 00:01:04,000
जैसे स्मृति लीक, ढेर स्मृति आवंटन

25
00:01:04,000 --> 00:01:07,000
और इसे मुफ्त भूल.

26
00:01:07,000 --> 00:01:10,000
हमारे debugger में हमारे संकलक बजना, GDB की तरह,

27
00:01:10,000 --> 00:01:14,000
वेलग्रिंड मुफ्त सॉफ्टवेयर है, और यह उपकरण पर स्थापित है.

28
00:01:14,000 --> 00:01:16,000
वेलग्रिंड अपने द्विआधारी निष्पादन पर चलाता है,

29
00:01:16,000 --> 00:01:20,000
या नहीं, आपके ग ज. स्रोत कोड फ़ाइलें,

30
00:01:20,000 --> 00:01:23,000
तो सुनिश्चित करें कि आप अपने कार्यक्रम की एक प्रतिलिपि अप तारीख संकलित किया है

31
00:01:23,000 --> 00:01:25,000
बजना का उपयोग कर या बनाओ.

32
00:01:25,000 --> 00:01:28,000
फिर, वेलग्रिंड के तहत अपने कार्यक्रम चल रहा हो सकता है

33
00:01:28,000 --> 00:01:32,000
सिर्फ शब्द मेजबान पर चल साथ मानक कार्यक्रम कमांड prefixing के रूप में सरल,

34
00:01:32,000 --> 00:01:35,000
जो शुरू होता है वेलग्रिंड और इसे के अंदर कार्यक्रम चलाता है.

35
00:01:35,000 --> 00:01:38,000
जब शुरू, वेलग्रिंड कुछ जटिल करता है

36
00:01:38,000 --> 00:01:41,000
स्मृति की जाँच के लिए निष्पादन कॉन्फ़िगर jiggering,

37
00:01:41,000 --> 00:01:44,000
तो यह थोड़ा लेने के लिए और चलाने के लिए कर सकते हैं.

38
00:01:44,000 --> 00:01:48,000
कार्यक्रम तो सामान्य रूप से निष्पादित, यह हो सकता है और अधिक धीरे धीरे,

39
00:01:48,000 --> 00:01:52,000
और जब यह खत्म, वेलग्रिंड अपनी स्मृति के उपयोग का एक सारांश मुद्रित होगा.

40
00:01:52,000 --> 00:01:58,000
यदि सब कुछ ठीक हो जाता है, तो यह कुछ इस तरह दिखेगा:

41
00:01:58,000 --> 00:02:01,000
इस मामले में, / clean_program

42
00:02:01,000 --> 00:02:04,000
कार्यक्रम मैं चलाने के लिए करना चाहते हैं के लिए रास्ता है.

43
00:02:04,000 --> 00:02:06,000
और जब यह एक किसी भी तर्क नहीं है,

44
00:02:06,000 --> 00:02:09,000
अगर यह था कि मैं सामान्य रूप से आदेश का अंत करने के लिए सिर्फ उन्हें कील था.

45
00:02:09,000 --> 00:02:12,000
स्वच्छ कार्यक्रम सिर्फ एक मूर्ख थोड़ा कार्यक्रम मैंने बनाया है

46
00:02:12,000 --> 00:02:15,000
कि ढेर पर ints की एक ब्लॉक के लिए अंतरिक्ष का आवंटन,

47
00:02:15,000 --> 00:02:19,000
उनमें से अंदर कुछ मूल्यों डाल, और पूरे ब्लॉक को मुक्त कर देते.

48
00:02:19,000 --> 00:02:23,000
यह है कि क्या आप के लिए शूटिंग कर रहे हैं, कोई त्रुटि है और कोई लीक.

49
00:02:23,000 --> 00:02:27,000
>> एक अन्य महत्वपूर्ण मीट्रिक आवंटित बाइट्स की कुल संख्या है.

50
00:02:27,000 --> 00:02:32,000
कार्यक्रम पर निर्भर करता है, अगर अपने आवंटन मेगाबाइट या उच्च में हैं,

51
00:02:32,000 --> 00:02:34,000
आप शायद कुछ गलत कर रहे हैं.

52
00:02:34,000 --> 00:02:37,000
तुम बेकार में डुप्लिकेट भंडारण?

53
00:02:37,000 --> 00:02:40,000
क्या आप भंडारण के लिए ढेर का उपयोग कर रहा है, जब यह बेहतर होगा ढेर प्रयोग करेंगे?

54
00:02:40,000 --> 00:02:43,000
तो, मेमोरी त्रुटियों को सही मायने में बुराई हो सकता है.

55
00:02:43,000 --> 00:02:46,000
अधिक प्रकट वाले शानदार दुर्घटनाओं का कारण,

56
00:02:46,000 --> 00:02:49,000
लेकिन फिर भी यह अभी भी इंगित करने के लिए मुश्किल हो सकता है

57
00:02:49,000 --> 00:02:51,000
क्या वास्तव में दुर्घटना के लिए नेतृत्व किया.

58
00:02:51,000 --> 00:02:54,000
अधिक सकपट, एक स्मृति त्रुटि के साथ एक कार्यक्रम

59
00:02:54,000 --> 00:02:56,000
अभी भी सफाई से संकलन कर सकते हैं

60
00:02:56,000 --> 00:02:58,000
और अभी भी सही ढंग से काम करने लग सकता है

61
00:02:58,000 --> 00:03:01,000
क्योंकि तुम समय की सबसे भाग्यशाली पाने में कामयाब रहे.

62
00:03:01,000 --> 00:03:04,000
कई के बाद, "" सफल परिणाम

63
00:03:04,000 --> 00:03:07,000
आपको लगता है कि एक दुर्घटना कंप्यूटर के एक अस्थायी है हो सकता है,

64
00:03:07,000 --> 00:03:10,000
लेकिन कंप्यूटर कभी भी गलत नहीं है.

65
00:03:10,000 --> 00:03:13,000
>> मेजबान पर चल रनिंग मदद कर सकते हैं कि आप नीचे दिखाई स्मृति त्रुटियों के कारण ट्रैक

66
00:03:13,000 --> 00:03:18,000
के रूप में अच्छी तरह के रूप में त्रुटियों गुप्त खोजने के लिए आप के बारे में भी अभी तक पता नहीं है.

67
00:03:18,000 --> 00:03:22,000
हर समय वेलग्रिंड एक समस्या का पता लगाता है, यह क्या देखा के बारे में जानकारी प्रिंट.

68
00:03:22,000 --> 00:03:24,000
प्रत्येक आइटम काफी संक्षिप्त है -

69
00:03:24,000 --> 00:03:27,000
हमलावर अनुदेश के स्रोत रेखा क्या मुद्दा है,,

70
00:03:27,000 --> 00:03:30,000
और शामिल स्मृति के बारे में एक छोटी सी जानकारी -

71
00:03:30,000 --> 00:03:34,000
लेकिन अक्सर यह पर्याप्त जानकारी के लिए सही जगह के लिए आपका ध्यान प्रत्यक्ष है.

72
00:03:34,000 --> 00:03:37,000
यहाँ वेलग्रिंड का एक उदाहरण है एक छोटी गाड़ी कार्यक्रम पर चल रहा है

73
00:03:37,000 --> 00:03:40,000
कि ढेर स्मृति के एक अवैध पढ़ा करता है.

74
00:03:40,000 --> 00:03:49,000
हम संकलन में कोई त्रुटि या चेतावनी को देखते हैं.

75
00:03:49,000 --> 00:03:53,000
ओह, त्रुटि सारांश का कहना है कि वहाँ दो त्रुटियाँ हैं -

76
00:03:53,000 --> 00:03:56,000
4 आकार के दो अवैध पढ़ता बाइट -, कि है.

77
00:03:56,000 --> 00:04:01,000
दोनों बुरा पढ़ता invalid_read.c के मुख्य समारोह में हुई,

78
00:04:01,000 --> 00:04:04,000
16 लाइन और 19 लाइन पर 2 पर 1.

79
00:04:04,000 --> 00:04:06,000
चलो कोड को देखो.

80
00:04:06,000 --> 00:04:11,000
1 के लिए printf हमारी स्मृति ब्लॉक के अंत पिछले एक int पढ़ने की कोशिश करता है कॉल की तरह लग रहा है.

81
00:04:11,000 --> 00:04:13,000
यदि हम वेलग्रिंड उत्पादन में वापस देखो,

82
00:04:13,000 --> 00:04:16,000
हम देखते हैं कि वेलग्रिंड हमें पता चलता है कि वास्तव में बताया.

83
00:04:16,000 --> 00:04:19,000
हम पता करने के लिए पढ़ने की कोशिश कर रहे हैं 0 बाइट्स शुरू

84
00:04:19,000 --> 00:04:22,000
पिछले 16 बाइट आकार के ब्लॉक के अंत -

85
00:04:22,000 --> 00:04:25,000
चार 32-bit ints है कि हम आवंटित.

86
00:04:25,000 --> 00:04:29,000
यही है, पता हम पढ़ने की कोशिश कर रहे थे हमारे ब्लॉक के अंत में शुरू होता है,

87
00:04:29,000 --> 00:04:32,000
बस के रूप में हम हमारे बुरा printf कॉल में देखते हैं.

88
00:04:32,000 --> 00:04:36,000
अब, अमान्य पढ़ता है जैसे कि एक समझौते के बड़ा नहीं लग सकता है,

89
00:04:36,000 --> 00:04:39,000
लेकिन अगर आपको लगता है कि डेटा का उपयोग कर रहे हैं अपने कार्यक्रम के प्रवाह को नियंत्रित

90
00:04:39,000 --> 00:04:42,000
उदाहरण के लिए, एक के हिस्से के रूप में अगर बयान या पाश -

91
00:04:42,000 --> 00:04:45,000
फिर बातें चुपचाप बुरा जा सकते हैं.

92
00:04:45,000 --> 00:04:47,000
देखो कैसे मैं invalid_read कार्यक्रम चला सकते हैं

93
00:04:47,000 --> 00:04:50,000
और कुछ भी नहीं है कि साधारण से बाहर होता है.

94
00:04:50,000 --> 00:04:52,000
डरावना, हुह?

95
00:04:52,000 --> 00:04:56,000
>> अब, चलो त्रुटियों के कुछ प्रकार है कि आप अपने कोड में मुठभेड़ हो सकता है पर देखो,

96
00:04:56,000 --> 00:04:59,000
और हम देखेंगे कि मेजबान पर चल उन्हें कैसे पता लगाता है.

97
00:04:59,000 --> 00:05:01,000
हम सिर्फ एक invalid_read की एक उदाहरण देखा है,

98
00:05:01,000 --> 00:05:04,000
तो अब चलो एक invalid_write.

99
00:05:04,000 --> 00:05:09,000
फिर, संकलन में कोई त्रुटि या चेतावनी.

100
00:05:09,000 --> 00:05:12,000
ठीक है, वेलग्रिंड का कहना है कि इस कार्यक्रम में दो त्रुटियाँ हैं -

101
00:05:12,000 --> 00:05:15,000
और invalid_write और एक invalid_read.

102
00:05:15,000 --> 00:05:18,000
चलो इस कोड की जाँच करें.

103
00:05:18,000 --> 00:05:21,000
लगता है जैसे हम क्लासिक strlen प्लस एक बग का एक उदाहरण मिल गया है.

104
00:05:21,000 --> 00:05:24,000
कोड malloc अंतरिक्ष के एक अतिरिक्त बाइट नहीं है

105
00:05:24,000 --> 00:05:26,000
0 / चरित्र के लिए,

106
00:05:26,000 --> 00:05:30,000
इसलिए जब str प्रतिलिपि यह ssubstrlen में लिखने के लिए चला गया "CS50 चट्टानों!"

107
00:05:30,000 --> 00:05:33,000
यह हमारी ब्लॉक के अंत पिछले 1 बाइट लिखा था.

108
00:05:33,000 --> 00:05:36,000
invalid_read आता है जब हम printf हमारे कॉल करते हैं.

109
00:05:36,000 --> 00:05:40,000
Printf अमान्य स्मृति पढ़ने समाप्त होता है जब यह / 0 चरित्र पढ़ता

110
00:05:40,000 --> 00:05:43,000
के रूप में यह इस ई स्ट्रिंग के अंत में लग रहा है यह मुद्रण है.

111
00:05:43,000 --> 00:05:45,000
लेकिन इस बात का कोई भी मेजबान पर चल भाग निकले.

112
00:05:45,000 --> 00:05:48,000
हम str प्रतिलिपि का हिस्सा के रूप में देखते हैं है कि यह invalid_write पकड़ा

113
00:05:48,000 --> 00:05:51,000
मुख्य के 11 लाइन पर, और invalid_read printf का हिस्सा है.

114
00:05:51,000 --> 00:05:54,000
पर रॉक, वेलग्रिंड.

115
00:05:54,000 --> 00:05:57,000
फिर, यह एक बड़ा सौदा की तरह प्रतीत नहीं हो सकता है.

116
00:05:57,000 --> 00:06:00,000
वेलग्रिंड के बाहर इस प्रोग्राम चला सकते हैं हम और अधिक से अधिक

117
00:06:00,000 --> 00:06:03,000
देखने के लिए और किसी भी त्रुटि के लक्षण नहीं है.

118
00:06:03,000 --> 00:06:06,000
>> हालांकि, इस बात का एक मामूली बदलाव को देखने के लिए

119
00:06:06,000 --> 00:06:09,000
चीजें बहुत खराब कैसे प्राप्त कर सकते हैं.

120
00:06:09,000 --> 00:06:14,000
तो दी, हम चीजों को कोस रहे हैं तो बस इस कोड में एक बिट से अधिक.

121
00:06:14,000 --> 00:06:17,000
हम ढेर पर ही कर रहे हैं, दो तार के लिए अंतरिक्ष का आवंटन

122
00:06:17,000 --> 00:06:19,000
CS50 चट्टानों की लंबाई,

123
00:06:19,000 --> 00:06:22,000
इस समय, 0 / चरित्र को याद.

124
00:06:22,000 --> 00:06:25,000
लेकिन फिर हम स्मृति ब्लॉक में एक सुपर लंबे स्ट्रिंग में फेंक

125
00:06:25,000 --> 00:06:27,000
एस की ओर इशारा करते है.

126
00:06:27,000 --> 00:06:30,000
क्या प्रभाव है कि स्मृति ब्लॉक पर होगा कि करने के लिए टी अंक?

127
00:06:30,000 --> 00:06:34,000
वैसे, अगर स्मृति टी कहते हैं कि सिर्फ एस के लिए आसन्न है,

128
00:06:34,000 --> 00:06:37,000
यह बस के बाद आ रहा है,

129
00:06:37,000 --> 00:06:39,000
तो हम टी. भाग पर लिखा है हो सकता है

130
00:06:39,000 --> 00:06:41,000
चलो इस कोड को चलाने.

131
00:06:41,000 --> 00:06:43,000
क्या हुआ देखो.

132
00:06:43,000 --> 00:06:47,000
तार हम हमारे ढेर दोनों ब्लॉकों में संग्रहीत करने के लिए बाहर मुद्रित है सही ढंग से दिखाई दिया.

133
00:06:47,000 --> 00:06:49,000
सभी में कुछ भी गलत नहीं लगता है.

134
00:06:49,000 --> 00:06:52,000
हालांकि, हमारे कोड में वापस जाने के लिए और

135
00:06:52,000 --> 00:06:55,000
बाहर लाइन टिप्पणी जहाँ हम CS50 चट्टानों की प्रतिलिपि

136
00:06:55,000 --> 00:06:59,000
2 स्मृति ब्लॉक में, टी द्वारा की ओर इशारा किया.

137
00:06:59,000 --> 00:07:02,000
अब, जब हम इस कोड को चलाने हम चाहिए

138
00:07:02,000 --> 00:07:06,000
केवल देखने के लिए पहली स्मृति ब्लॉक की सामग्री मुद्रित करने के लिए.

139
00:07:06,000 --> 00:07:09,000
वाह, भले ही हम str कॉपी नहीं किया

140
00:07:09,000 --> 00:07:12,000
2 ढेर ब्लॉक में कोई भी वर्ण, एक टी द्वारा की ओर इशारा किया,

141
00:07:12,000 --> 00:07:15,000
हम एक प्रिंट बाहर निकालो.

142
00:07:15,000 --> 00:07:18,000
दरअसल, स्ट्रिंग हम हमारे 1 ब्लॉक में भरवां

143
00:07:18,000 --> 00:07:21,000
1 और 2 ब्लॉक में ब्लॉक overran,

144
00:07:21,000 --> 00:07:23,000
जिससे सब कुछ सामान्य लग रहे हैं.

145
00:07:23,000 --> 00:07:26,000
मेजबान पर चल रहा है, हालांकि, हमें सच्ची कहानी बताता है.

146
00:07:26,000 --> 00:07:28,000
हम वहाँ जाते हैं.

147
00:07:28,000 --> 00:07:32,000
उन अमान्य पढ़ता और लिखता है.

148
00:07:32,000 --> 00:07:36,000
>> चलो त्रुटि का एक और प्रकार का एक उदाहरण देखते हैं.

149
00:07:36,000 --> 00:07:39,000
यहाँ हम कुछ बल्कि यह दुर्भाग्यपूर्ण है.

150
00:07:39,000 --> 00:07:41,000
हम ढेर पर एक int के लिए अंतरिक्ष ले लो,

151
00:07:41,000 --> 00:07:45,000
पी - उस स्थान को इंगित करने के लिए और हम एक int सूचक इनिशियलाइज़.

152
00:07:45,000 --> 00:07:48,000
हालांकि, जबकि हमारे सूचक initialized है,

153
00:07:48,000 --> 00:07:52,000
डेटा है कि यह की ओर इशारा करते है बस कबाड़ ढेर के उस हिस्से में जो कुछ भी है.

154
00:07:52,000 --> 00:07:55,000
इसलिए, जब हम int i में है कि डेटा लोड

155
00:07:55,000 --> 00:07:57,000
हम तकनीकी रूप से मैं प्रारंभिकीकरण

156
00:07:57,000 --> 00:08:00,000
लेकिन हम कबाड़ डेटा के साथ ऐसा करते हैं.

157
00:08:00,000 --> 00:08:03,000
कॉल जोर है, जो एक आसान debugging मैक्रो

158
00:08:03,000 --> 00:08:06,000
पुस्तकालय aptly नाम जोर में परिभाषित किया गया है,

159
00:08:06,000 --> 00:08:09,000
गर्भपात कार्यक्रम अगर अपने परीक्षण हालत में विफल रहता है.

160
00:08:09,000 --> 00:08:11,000
यही है, अगर मैं 0 नहीं है.

161
00:08:11,000 --> 00:08:14,000
ढेर अंतरिक्ष में क्या था पर निर्भर करता है, पी द्वारा की ओर इशारा किया,

162
00:08:14,000 --> 00:08:18,000
इस कार्यक्रम कभी कभी काम और अन्य समय में असफल हो सकता है.

163
00:08:18,000 --> 00:08:20,000
अगर यह काम करता है, हम सिर्फ भाग्यशाली हो रही है.

164
00:08:20,000 --> 00:08:24,000
संकलक इस त्रुटि पकड़ नहीं है, लेकिन यकीन है कि इच्छा वेलग्रिंड होगा.

165
00:08:24,000 --> 00:08:28,000
वहाँ हम हमारे कि जंक डेटा के उपयोग से stemming त्रुटि देखते.

166
00:08:28,000 --> 00:08:32,000
>> जब आप ढेर स्मृति आवंटित लेकिन deallocate या नहीं यह मुक्त

167
00:08:32,000 --> 00:08:34,000
कि एक रिसाव कहा जाता है.

168
00:08:34,000 --> 00:08:37,000
एक छोटी सी, अल्पकालिक कार्यक्रम चलाता है और तुरंत बाहर निकलता है,

169
00:08:37,000 --> 00:08:39,000
लीक काफी हानिरहित हैं,

170
00:08:39,000 --> 00:08:42,000
लेकिन बड़े आकार और / या दीर्घायु की एक परियोजना के लिए,

171
00:08:42,000 --> 00:08:46,000
यहां तक ​​कि एक छोटी सी दरार कुछ प्रमुख में यौगिक कर सकते हैं.

172
00:08:46,000 --> 00:08:49,000
CS50 के लिए, हम आप के लिए उम्मीद है

173
00:08:49,000 --> 00:08:51,000
ढेर स्मृति है कि आप आवंटित की सभी मुक्त का ख्याल रखना,

174
00:08:51,000 --> 00:08:54,000
के बाद से हम आप कौशल का निर्माण करने के लिए ठीक से मैनुअल प्रक्रिया संभाल करना चाहते हैं

175
00:08:54,000 --> 00:08:56,000
सी. द्वारा आवश्यक

176
00:08:56,000 --> 00:08:59,000
ऐसा करने के लिए, अपने प्रोग्राम एक सटीक होना चाहिए

177
00:08:59,000 --> 00:09:03,000
malloc और मुक्त कॉल के बीच एक से एक पत्राचार.

178
00:09:03,000 --> 00:09:06,000
सौभाग्य से, वेलग्रिंड स्मृति लीक के साथ आप भी मदद कर सकते हैं.

179
00:09:06,000 --> 00:09:09,000
यहाँ एक टपकाया leak.c कार्यक्रम बुलाया है कि का आवंटन

180
00:09:09,000 --> 00:09:13,000
अंतरिक्ष ढेर पर, यह करने के लिए लिखते हैं, लेकिन यह मुक्त नहीं है.

181
00:09:13,000 --> 00:09:16,000
हम यह बनाओ और यह वेलग्रिंड के तहत चलाने के साथ संकलित,

182
00:09:16,000 --> 00:09:18,000
और हम देखते हैं, जब तक हम कोई स्मृति त्रुटियों है कि,

183
00:09:18,000 --> 00:09:20,000
हम एक दरार है.

184
00:09:20,000 --> 00:09:23,000
16 बाइट्स निश्चित रूप से खो रहे हैं,

185
00:09:23,000 --> 00:09:27,000
जिसका अर्थ है कि कि स्मृति के लिए सूचक दायरे में नहीं था, जब इस कार्यक्रम से बाहर निकल गया.

186
00:09:27,000 --> 00:09:30,000
अब, हमें वेलग्रिंड रिसाव के बारे में जानकारी का एक टन नहीं दे करता है,

187
00:09:30,000 --> 00:09:35,000
लेकिन अगर हम इस छोटे नोट का पालन करें कि यह अपनी रिपोर्ट के नीचे की ओर नीचे देता है

188
00:09:35,000 --> 00:09:38,000
के साथ फिर से दौड़ना - रिसाव की जांच पूरी =

189
00:09:38,000 --> 00:09:41,000
लीक स्मृति के पूर्ण विवरण देखने के लिए,

190
00:09:41,000 --> 00:09:44,000
हम और अधिक जानकारी प्राप्त करेंगे.

191
00:09:44,000 --> 00:09:46,000
अब, ढेर सारांश में,

192
00:09:46,000 --> 00:09:50,000
वेलग्रिंड हमें बताता है, जहां स्मृति खो गया था कि शुरू में आवंटित किया गया था.

193
00:09:50,000 --> 00:09:52,000
बस के रूप में हम स्रोत कोड में देखने से पता

194
00:09:52,000 --> 00:09:55,000
वेलग्रिंड हमें बताते हैं कि हम स्मृति लीक

195
00:09:55,000 --> 00:09:58,000
leak.c की 8 लाइन पर malloc के लिए एक फोन के साथ आवंटित

196
00:09:58,000 --> 00:10:00,000
मुख्य समारोह में.

197
00:10:00,000 --> 00:10:02,000
सुंदर गंधा.

198
00:10:02,000 --> 00:10:04,000
>> वेलग्रिंड categorizes लीक इन शब्दों का प्रयोग:

199
00:10:04,000 --> 00:10:07,000
निश्चित रूप से खो - यह ढेर आवंटित स्मृति है

200
00:10:07,000 --> 00:10:10,000
जो कार्यक्रम अब एक सूचक है.

201
00:10:10,000 --> 00:10:14,000
वेलग्रिंड जानता है कि आप एक बार सूचक था लेकिन बाद में इसे का ट्रैक खो दिया.

202
00:10:14,000 --> 00:10:17,000
इस स्मृति को निश्चित रूप से लीक है.

203
00:10:17,000 --> 00:10:20,000
परोक्ष रूप से खो - यह ढेर आवंटित स्मृति है

204
00:10:20,000 --> 00:10:24,000
जो यह करने के लिए केवल संकेत भी खो रहे हैं.

205
00:10:24,000 --> 00:10:27,000
उदाहरण के लिए, यदि आप एक लिंक सूची के पहले नोड के लिए अपने सूचक को खो दिया है,

206
00:10:27,000 --> 00:10:30,000
तो पहला नोड ही निश्चित रूप से खो जाएगा,

207
00:10:30,000 --> 00:10:34,000
जबकि किसी भी बाद नोड्स परोक्ष रूप से खो जाएगा.

208
00:10:34,000 --> 00:10:37,000
संभवत: खो - यह ढेर आवंटित स्मृति है

209
00:10:37,000 --> 00:10:41,000
जो वेलग्रिंड यकीन है कि वहाँ एक सूचक है या नहीं है नहीं हो सकता.

210
00:10:41,000 --> 00:10:44,000
अभी भी पहुँच से बाहर ढेर आवंटित स्मृति है

211
00:10:44,000 --> 00:10:47,000
जो कार्यक्रम अभी भी बाहर निकलने पर एक सूचक है,

212
00:10:47,000 --> 00:10:50,000
जो आम तौर पर इसका मतलब है कि यह एक वैश्विक चर अंक.

213
00:10:50,000 --> 00:10:53,000
इन लीक की जांच करने के लिए, आप भी विकल्प शामिल होगा

214
00:10:53,000 --> 00:10:55,000
- अभी भी पहुँच से बाहर = हाँ

215
00:10:55,000 --> 00:10:58,000
वेलग्रिंड के अपने मंगलाचरण में.

216
00:10:58,000 --> 00:11:01,000
>> इन अलग अलग मामलों में उन्हें सफाई के लिए अलग रणनीति की आवश्यकता हो सकती है,

217
00:11:01,000 --> 00:11:05,000
लेकिन लीक समाप्त किया जाना चाहिए.

218
00:11:05,000 --> 00:11:08,000
दुर्भाग्य से, लीक फिक्सिंग करने के लिए कठिन हो सकता है,

219
00:11:08,000 --> 00:11:11,000
के बाद से मुक्त करने के लिए गलत कॉल के अपने कार्यक्रम को उड़ा सकते हैं.

220
00:11:11,000 --> 00:11:14,000
उदाहरण के लिए, अगर हम invalid_free.c में देखो,

221
00:11:14,000 --> 00:11:18,000
हम बुरा स्मृति deallocation का एक उदाहरण देखते हैं.

222
00:11:18,000 --> 00:11:21,000
क्या एक एकल कॉल करने के लिए पूरे ब्लॉक मुक्त होना चाहिए

223
00:11:21,000 --> 00:11:24,000
int_block द्वारा स्मृति के की ओर इशारा किया,

224
00:11:24,000 --> 00:11:27,000
बजाय एक int आकार के लिए प्रत्येक अनुभाग को मुक्त करने की कोशिश हो

225
00:11:27,000 --> 00:11:29,000
व्यक्तिगत रूप से स्मृति की.

226
00:11:29,000 --> 00:11:32,000
यह catastrophically असफल हो जायेगी.

227
00:11:32,000 --> 00:11:34,000
बूम! क्या एक त्रुटि है.

228
00:11:34,000 --> 00:11:36,000
यह निश्चित रूप से अच्छा नहीं है.

229
00:11:36,000 --> 00:11:39,000
यदि आप इस तरह की त्रुटि के साथ फंस रहे हैं, हालांकि, और आप देखने के लिए पता नहीं कहाँ से,

230
00:11:39,000 --> 00:11:41,000
अपने सर्वश्रेष्ठ नए दोस्त पर वापस आते हैं.

231
00:11:41,000 --> 00:11:44,000
आप यह अनुमान लगाया - वेलग्रिंड.

232
00:11:44,000 --> 00:11:47,000
वेलग्रिंड, हमेशा की तरह जानता है, वास्तव में क्या हो रहा है.

233
00:11:47,000 --> 00:11:50,000
alloc और मुक्त मायने रखता मेल नहीं खाते.

234
00:11:50,000 --> 00:11:52,000
हम 1 alloc और 4 को मुक्त कर देते मिल गया है.

235
00:11:52,000 --> 00:11:55,000
और वेलग्रिंड भी हमें बताता है जहां 1 बुरा मुफ्त कॉल -

236
00:11:55,000 --> 00:11:58,000
एक कि विस्फोट ट्रिगर से आ रही है -

237
00:11:58,000 --> 00:12:00,000
16 लाइन.

238
00:12:00,000 --> 00:12:03,000
जैसा कि आप देख, बुरा को मुफ्त फोन वास्तव में खराब कर रहे हैं,

239
00:12:03,000 --> 00:12:05,000
तो हम अपने कार्यक्रम रिसाव दे की सिफारिश

240
00:12:05,000 --> 00:12:08,000
जब आप कार्यक्षमता सही हो रही पर काम कर रहे हैं.

241
00:12:08,000 --> 00:12:12,000
लीक के लिए तलाश शुरू होने के बाद ही अपने कार्यक्रम ठीक से काम कर रहा है,

242
00:12:12,000 --> 00:12:14,000
किसी भी अन्य त्रुटियों के बिना.

243
00:12:14,000 --> 00:12:16,000
>> और कहा कि हम सभी इस वीडियो के लिए मिल गया है.

244
00:12:16,000 --> 00:12:18,000
अब आप के लिए क्या कर रहे हैं?

245
00:12:18,000 --> 00:12:21,000
जाओ अपने कार्यक्रमों पर अभी वेलग्रिंड चलाने के.

246
00:12:21,000 --> 00:12:25,000
मेरा नाम नैट Hardison है. यह CS50 है. [CS50.TV]